def run(self):
""" Setup input files, run a quest relaxation, and report results """
# construct the Relax object
relaxation = seqquest.Relax(self.calcdir, self.run_settings())
# check the current status
(status, task) = relaxation.status()
if status == "complete":
print("Status:", status)
sys.stdout.flush()
# mark job as complete in db
if self.auto:
try:
complete_job()
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# write results to properties.calc.json
self.finalize()
return
elif status == "not_converging":
print("Status:", status)
self.report_status("failed","run_limit")
print("Returning")
sys.stdout.flush()
return
elif status == "incomplete":
if task == "setup":
self.setup()
self.report_status("started")
(status, task) = relaxation.run()
else:
self.report_status("failed", "unknown")
raise QuestWrapperError("unexpected relaxation status: '" + status + "' and task: '" + task + "'")
sys.stdout.flush()
# once the run is done, update database records accordingly
if status == "not_converging":
# mark error
if self.auto:
try:
error_job("Not converging")
except (JobsError, JobDBError) as e:
print(str(e))
sys.stdout.flush()
print("Not Converging!")
sys.stdout.flush()
self.report_status("failed","run_limit")
# print a local settings file, so that the run_limit can be extended if the
# convergence problems are fixed
config_set_dir = self.casm_directories.configuration_calc_settings_dir(self.configname, self.clex)
try:
os.makedirs(config_set_dir)
except OSError:
pass
settingsfile = os.path.join(config_set_dir, "relax.json")
write_settings(self.settings, settingsfile)
print("Writing:", settingsfile)
print("Edit the 'run_limit' property if you wish to continue.")
sys.stdout.flush()
return
elif status == "complete":
# mark job as complete in db
if self.auto:
try:
complete_job()
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# write results to properties.calc.json
self.finalize()
else:
self.report_status("failed","unknown")
raise QuestWrapperError("quest relaxation complete with unexpected status: '"
+ status + "' and task: '" + task + "'")
sys.stdout.flush()
def submit(self): #pylint: disable=too-many-statements
"""Submit a job for this SeqQuest relaxation"""
print("Submitting...")
print("Configuration:", self.configname)
# first, check if the job has already been submitted and is not completed
db = JobDB()
print("Calculation directory:", self.calcdir)
id = db.select_regex_id("rundir", self.calcdir)
print("JobID:", id)
sys.stdout.flush()
if id != []:
for j in id:
job = db.select_job(j)
if job["jobstatus"] != "C":
print("JobID:", job["jobid"], " Jobstatus:", job["jobstatus"], " Not submitting.")
sys.stdout.flush()
return
# second, only submit a job if relaxation status is "incomplete"
# construct the Relax object
relaxation = seqquest.Relax(self.calcdir, self.run_settings())
# check the current status
(status, task) = relaxation.status()
if status == "complete":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
# ensure job marked as complete in db
if self.auto:
for j in id:
job = db.select_job(j)
if job["taskstatus"] == "Incomplete":
try:
complete_job(jobid=j)
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# ensure results report written
if not os.path.isfile(os.path.join(self.calcdir, "properties.calc.json")):
self.finalize()
return
elif status == "not_converging":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
return
elif status != "incomplete":
raise QuestWrapperError("unexpected relaxation status: '" + status
+ "' and task: '" + task + "'")
# This code can never be reached...
# sys.stdout.flush()
# return
print("Preparing to submit a SeqQuest relaxation job")
sys.stdout.flush()
# cd to configdir, submit jobs from configdir, then cd back to currdir
currdir = os.getcwd()
os.chdir(self.calcdir)
# determine the number of atoms in the configuration
print("Counting atoms in the POSCAR")
sys.stdout.flush()
geom = seqquest.seqquest_io.Geom.POS(os.path.join(self.configdir, "POS"))
N = len(geom.basis)
# construct command to be run
cmd = ""
if self.settings["preamble"] is not None:
# Append any instructions given in the 'preamble' file, if given
preamble = self.casm_directories.settings_path_crawl(self.settings["preamble"], self.configname, self.clex)
with open(preamble, 'rb') as my_preamble:
cmd += "".join(my_preamble.read().decode('utf-8')) + "\n"
if self.settings["prerun"] is not None:
cmd += self.settings["prerun"] + "\n"
cmd += "python -c \"import casm.questwrapper; casm.questwrapper.Relax('" + self.configdir + "').run()\"\n"
if self.settings["postrun"] is not None:
cmd += self.settings["postrun"] + "\n"
print("Constructing a job")
sys.stdout.flush()
# construct a Job
job = Job(name=wrapper.jobname(self.configname),\
account=self.settings["account"],\
nodes=int(math.ceil(float(N)/float(self.settings["atom_per_proc"])/float(self.settings["ppn"]))),\
ppn=int(self.settings["ppn"]),\
walltime=self.settings["walltime"],\
pmem=self.settings["pmem"],\
qos=self.settings["qos"],\
queue=self.settings["queue"],\
message=self.settings["message"],\
email=self.settings["email"],\
priority=self.settings["priority"],\
command=cmd,\
auto=self.auto)
print("Submitting")
sys.stdout.flush()
# submit the job
job.submit()
self.report_status("submitted")
# return to current directory
os.chdir(currdir)
print("CASM QuestWrapper relaxation job submission complete\n")
sys.stdout.flush()
def run(self):
"""run the job of a selection"""
for index, config_data in self.selection.data.iterrows():
settings = self.read_settings(config_data["setfile"])
calculation = self.calculator(config_data["calcdir"],
self.run_settings(settings))
# check the current status
(status, task) = calculation.status()
if status == "complete":
print("Status:", status)
sys.stdout.flush()
# mark job as complete in db
if self.auto:
try:
complete_job()
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# write results to properties.calc.json
if (is_converged(calculation)):
self.finalize(config_data)
continue
elif status == "not_converging":
print("Status:", status)
self.report_status(config_data["calcdir"], "failed",
"run_limit")
print("Returning")
sys.stdout.flush()
continue
elif status == "incomplete":
self.report_status(config_data["calcdir"], "started")
(status, task) = calculation.run()
else:
self.report_status(config_data["calcdir"], "failed", "unknown")
raise VaspWrapperError("unexpected relaxation status: '" +
status + "' and task: '" + task + "'")
sys.stdout.flush()
# once the run is done, update database records accordingly
if status == "not_converging":
# mark error
if self.auto:
try:
error_job("Not converging")
except (JobsError, JobDBError) as e:
print(str(e))
sys.stdout.flush()
print("Not Converging!")
sys.stdout.flush()
self.report_status(config_data["calcdir"], "failed",
"run_limit")
# print a local settings file, so that the run_limit can be extended if the
# convergence problems are fixed
config_set_dir = self.casm_directories.configuration_calc_settings_dir(
config_data["name"], self.clex, self.calc_subdir)
try:
os.makedirs(config_set_dir)
except:
pass
settingsfile = os.path.join(config_set_dir, "calc.json")
write_settings(settings, settingsfile)
print("Writing:", settingsfile)
print("Edit the 'run_limit' property if you wish to continue.")
sys.stdout.flush()
continue
elif status == "complete":
# mark job as complete in db
if self.auto:
try:
complete_job()
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# write results to properties.calc.json
if is_converged(calculation):
self.finalize(config_data)
else:
self.report_status(config_data["calcdir"], "failed", "unknown")
raise VaspWrapperError(
"vasp relaxation complete with unexpected status: '" +
status + "' and task: '" + task + "'")
sys.stdout.flush()
def submit(self):
"""Submit a PBS job for this Quantum Espresso relaxation"""
# first, check if the job has already been submitted and is not completed
db = JobDB()
print("rundir", self.calcdir)
id = db.select_regex_id("rundir", self.calcdir)
print("id:", id)
sys.stdout.flush()
if id != []:
db.update()
for j in id:
job = db.select_job(j)
# taskstatus = ["Incomplete","Complete","Continued","Check","Error:.*","Aborted"]
# jobstatus = ["C","Q","R","E","W","H","M"]
if job["jobstatus"] != "C":
print("JobID:", job["jobid"], " Jobstatus:",
job["jobstatus"], " Not submitting.")
sys.stdout.flush()
return
#elif job["taskstatus"] in ["Complete", "Check"] or re.match( "Error:.*", job["taskstatus"]):
# print "JobID:", job["jobid"], " Taskstatus:", job["taskstatus"], " Not submitting."
# sys.stdout.flush()
# return
# second, only submit a job if relaxation status is "incomplete"
# construct the Relax object
relaxation = quantumespresso.Relax(self.calcdir, self.run_settings())
# load infilename and outfilename
infilename = self.settings["infilename"]
outfilename = self.settings["outfilename"]
# check the current status
(status, task) = relaxation.status()
if status == "complete":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
# ensure job marked as complete in db
if self.auto:
for j in id:
job = db.select_job(j)
if job["taskstatus"] == "Incomplete":
try:
complete_job(jobid=j)
except (JobsError, JobDBError, EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# ensure results report written
if not os.path.isfile(
os.path.join(self.calcdir, "properties.calc.json")):
self.finalize()
return
elif status == "not_converging":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
return
elif status != "incomplete":
raise QEWrapperError("unexpected relaxation status: '" + status +
"' and task: '" + task + "'")
sys.stdout.flush()
return
print("Preparing to submit a Quantum Espresso relaxation PBS job")
sys.stdout.flush()
# cd to configdir, submit jobs from configdir, then cd back to currdir
currdir = os.getcwd()
os.chdir(self.calcdir)
# determine the number of atoms in the configuration
print(" Counting atoms in the POSCAR")
sys.stdout.flush()
pos = quantumespresso.qeio.Poscar(os.path.join(self.configdir, "POS"))
N = len(pos.basis)
print(" Constructing a PBS job")
sys.stdout.flush()
# construct a Job
job = Job(name=wrapper.jobname(self.configname),\
account=self.settings["account"],\
nodes=int(math.ceil(float(N)/float(self.settings["atom_per_proc"])/float(self.settings["ppn"]))),\
ppn=int(self.settings["ppn"]),\
walltime=self.settings["walltime"],\
pmem=self.settings["pmem"],\
qos=self.settings["qos"],\
queue=self.settings["queue"],\
message=self.settings["message"],\
email=self.settings["email"],\
priority=self.settings["priority"],\
command="python -c \"import casm.qewrapper; casm.qewrapper.Relax('" + self.configdir + "').run()\"",\
auto=self.auto)
print(" Submitting")
sys.stdout.flush()
# submit the job
job.submit()
self.report_status("submitted")
# return to current directory
os.chdir(currdir)
print("CASM QEWrapper relaxation PBS job submission complete\n")
sys.stdout.flush()
def submit(self):
""" submit jobs for a selection"""
self.pre_setup()
db = pbs.JobDB()
for index, config_data in self.selection.data.iterrows():
print("Submitting...")
print("Configuration:", config_data["name"])
#first, check if the job has already been submitted and is not completed
print("Calculation directory:", config_data["calcdir"])
id = db.select_regex_id("rundir", config_data["calcdir"])
print("JobID:", id)
sys.stdout.flush()
try:
if id != []:
db.update()
for j in id:
job = db.select_job(j)
if job["jobstatus"] != "C":
print("JobID:", job["jobid"], " Jobstatus:",
job["jobstatus"], " Not submitting.")
sys.stdout.flush()
raise BreakException
except BreakException:
continue
settings = self.read_settings(config_data["setfile"])
# construct the Relax object
calculation = self.calculator(config_data["calcdir"],
self.run_settings(settings))
# check the current status
(status, task) = calculation.status()
if status == "complete":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
# ensure job marked as complete in db
if self.auto:
for j in id:
job = db.select_job(j)
if job["taskstatus"] == "Incomplete":
try:
complete_job(jobid=j)
except (JobsError, JobDBError,
EligibilityError) as e:
print(str(e))
sys.stdout.flush()
# ensure results report written
if not os.path.isfile(
os.path.join(config_data["calcdir"],
"properties.calc.json")):
if (is_converged(calculation)):
self.finalize(config_data)
continue
elif status == "not_converging":
print("Status:", status, " Not submitting.")
sys.stdout.flush()
continue
elif status != "incomplete":
raise VaspWrapperError("unexpected relaxation status: '" +
status + "' and task: '" + task + "'")
sys.stdout.flush()
continue
print("Preparing to submit a VASP relaxation PBS job")
sys.stdout.flush()
# cd to configdir, submit jobs from configdir, then cd back to currdir
currdir = os.getcwd()
os.chdir(config_data["calcdir"])
self.config_setup(config_data)
nodes, ppn = self._calc_submit_node_info(settings, config_data)
# construct command to be run
cmd = ""
if settings["preamble"] is not None:
# Append any instructions given in the 'preamble' file, if given
preamble = self.casm_directories.settings_path_crawl(
settings["preamble"], config_data["name"], self.clex,
self.calc_subdir)
with open(preamble) as my_preamble:
cmd += "".join(my_preamble)
# Or just execute a single prerun line, if given
if settings["prerun"] is not None:
cmd += settings["prerun"] + "\n"
cmd += self.run_cmd(config_data["configdir"], self.calctype)
if settings["postrun"] is not None:
cmd += settings["postrun"] + "\n"
print("Constructing a PBS job")
sys.stdout.flush()
# construct a pbs.Job
job = pbs.Job(name=casm.jobname(config_data["configdir"]),
account=settings["account"],
nodes=nodes,
ppn=ppn,
walltime=settings["walltime"],
pmem=settings["pmem"],
qos=settings["qos"],
queue=settings["queue"],
message=settings["message"],
email=settings["email"],
priority=settings["priority"],
command=cmd,
auto=self.auto,
software=db.config["software"])
print("Submitting")
sys.stdout.flush()
# submit the job
job.submit()
self.report_status(config_data["calcdir"], "submitted")
# return to current directory
os.chdir(currdir)
print("CASM VASPWrapper relaxation PBS job submission complete\n")
sys.stdout.flush()