def test_offline_fw_passinfo(self):
fw1 = Firework([AdditionTask()], {"input_array": [1,1]}, name="1")
fw2 = Firework([AdditionTask()], {"input_array": [2,2]}, name="2")
fw3 = Firework([AdditionTask()], {"input_array": [3]}, parents=[fw1, fw2], name="3")
wf = Workflow([fw1, fw2, fw3])
self.lp.add_wf(wf)
# make dirs for launching jobs
cur_dir = os.path.dirname(os.path.abspath(__file__))
os.mkdir(os.path.join(cur_dir, "launcher_1"))
os.mkdir(os.path.join(cur_dir, "launcher_2"))
os.mkdir(os.path.join(cur_dir, "launcher_3"))
# launch two parent jobs
os.chdir(os.path.join(cur_dir, "launcher_1"))
fw, launch_id = self.lp.reserve_fw(self.fworker, os.getcwd())
setup_offline_job(self.lp, fw, launch_id)
launch_rocket(None, self.fworker)
os.chdir(os.path.join(cur_dir, "launcher_2"))
fw, launch_id = self.lp.reserve_fw(self.fworker, os.getcwd())
setup_offline_job(self.lp, fw, launch_id)
launch_rocket(None, self.fworker)
# recover jobs
for l in self.lp.offline_runs.find({"completed": False, "deprecated": False}, {"launch_id": 1}):
fw = self.lp.recover_offline(l['launch_id'])
# launch child job
os.chdir(os.path.join(cur_dir, "launcher_3"))
fw, launch_id = self.lp.reserve_fw(self.fworker, os.getcwd())
last_fw_id = fw.fw_id
setup_offline_job(self.lp, fw, launch_id)
launch_rocket(None, self.fworker)
# recover jobs
for l in self.lp.offline_runs.find({"completed": False, "deprecated": False}, {"launch_id": 1}):
fw = self.lp.recover_offline(l['launch_id'])
# confirm the sum in the child job
child_fw = self.lp.get_fw_by_id(last_fw_id)
self.assertEqual(set(child_fw.spec['input_array']), set([2, 3, 4]))
self.assertEqual(child_fw.launches[0].action.stored_data["sum"], 9)
def add_scripts(args):
lp = get_lp(args)
args.names = args.names if args.names else [None] * len(args.scripts)
args.wf_name = args.wf_name if args.wf_name else args.names[0]
fws = []
links = {}
for idx, s in enumerate(args.scripts):
fws.append(
Firework(ScriptTask({
'script': s,
'use_shell': True
}),
name=args.names[idx],
fw_id=idx))
if idx != 0:
links[idx - 1] = idx
lp.add_wf(Workflow(fws, links, args.wf_name))
def add_wf(j, dest, tracker, name):
fts = []
for i in range(j,j+25):
ft = ScriptTask.from_str('echo "' + str(i) + '" >> '+ dest,
{'store_stdout':True})
fts.append(ft)
fw1 = Firework(fts, spec={'_trackers':[tracker]},
fw_id=j+1, name=name+'1')
fts = []
for i in range(j+25,j+50):
ft = ScriptTask.from_str('echo "' + str(i) + '" >> ' + dest,
{'store_stdout':True})
fts.append(ft)
fw2 = Firework(fts, spec={'_trackers':[tracker]},
fw_id=j+2, name=name+'2')
wf = Workflow([fw1, fw2], links_dict={fw1:[fw2]})
self.lp.add_wf(wf)
def test_createfolder(self):
folder_name = "test_folder"
fw1 = Firework([
CreateFolder(folder_name=folder_name, change_dir=False),
PassCalcLocs(name="fw1")
],
name="fw3")
fw2 = Firework([PassCalcLocs(name="fw2")], name="fw2", parents=fw1)
wf = Workflow([fw1, fw2])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw2 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw2"})[0])
calc_locs = fw2.spec["calc_locs"]
self.assertTrue(
os.path.exists(
get_calc_loc("fw1", calc_locs)["path"] + "/" + folder_name))
def test_category(self):
task1 = ScriptTask.from_str('echo "Task 1"')
task2 = ScriptTask.from_str('echo "Task 2"')
spec = {'_category': 'dummy_category'}
fw1 = Firework(task1, fw_id=1, name='Task 1', spec=spec)
fw2 = Firework(task2, fw_id=2, name='Task 2', spec=spec)
self.lp.add_wf(Workflow([fw1, fw2]))
self.assertTrue(self.lp.run_exists(FWorker(category="dummy_category")))
self.assertFalse(self.lp.run_exists(
FWorker(category="other category")))
self.assertFalse(self.lp.run_exists(FWorker(category="__none__")))
self.assertTrue(self.lp.run_exists(FWorker())) # can run any category
self.assertTrue(
self.lp.run_exists(
FWorker(category=["dummy_category", "other category"])))
def __init__(self, vasp_input_set, spec):
# Initializes fws list and links_dict
fws = []
links_dict = {}
if 'additional_controllers' in spec:
additional_controllers = spec['additional_controllers']
spec.pop('additional_controllers')
else:
additional_controllers = [
WalltimeController(),
MemoryController(),
VaspXMLValidatorController()
]
control_procedure = ControlProcedure(
controllers=additional_controllers)
task_helper = MPRelaxTaskHelper()
task_type = task_helper.task_type
src_fws = createVaspSRCFireworks(vasp_input_set=vasp_input_set,
task_helper=task_helper,
task_type=task_type,
control_procedure=control_procedure,
custodian_handlers=[],
max_restarts=10,
src_cleaning=None,
task_index=None,
spec=None,
setup_spec_update=None,
run_spec_update=None)
fws.extend(src_fws['fws'])
links_dict_update(links_dict=links_dict,
links_update=src_fws['links_dict'])
self.wf = Workflow(fireworks=fws,
links_dict=links_dict,
metadata={
'workflow_class': self.workflow_class,
'workflow_module': self.workflow_module
},
name='MPRelaxFWWorkflowSRC')
def test_preserve_fworker(self):
fw1 = Firework([ScriptTask.from_str('echo "Testing preserve FWorker"')], spec={"_preserve_fworker": True}, fw_id=1)
fw2 = Firework([ScriptTask.from_str('echo "Testing preserve FWorker pt 2"')], spec={"target": 1}, parents=[fw1], fw_id=2)
self.lp.add_wf(Workflow([fw1, fw2]))
launch_rocket(self.lp, self.fworker)
target_fw_id = self.lp.get_fw_ids({"spec.target": 1})[0]
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
"""
cnt = 0
while '_fworker' not in modified_spec and cnt < 5:
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
print(modified_spec)
time.sleep(5)
cnt += 1
"""
self.assertIsNotNone(modified_spec['_fworker'])
def test_copyfilesfromcalcloc(self):
fw1 = Firework([
CopyVaspOutputs(calc_dir=self.plain_outdir),
PassCalcLocs(name="fw1")
],
name="fw1")
fw2 = Firework([
CopyVaspOutputs(calc_dir=self.relax2_outdir),
PassCalcLocs(name="fw2")
],
name="fw2")
fw3 = Firework([
CopyFilesFromCalcLoc(calc_loc="fw1",
filenames=["POSCAR"],
name_prepend="",
name_append="_0"),
CopyFilesFromCalcLoc(calc_loc="fw2",
filenames=["POSCAR"],
name_prepend="",
name_append="_1"),
PassCalcLocs(name="fw3")
],
name="fw3",
parents=[fw1, fw2])
fw4 = Firework([PassCalcLocs(name="fw4")], name="fw4", parents=fw3)
wf = Workflow([fw1, fw2, fw3, fw4])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw4 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw4"})[0])
calc_locs = fw4.spec["calc_locs"]
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR_0"))
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR_1"))
def test_files_in_out(self):
# create the Workflow that passes files_in and files_out
fw1 = Firework(
[ScriptTask.from_str('echo "This is the first FireWork" > test1')],
spec={"_files_out": {
"fwtest1": "test1"
}},
fw_id=1,
)
fw2 = Firework(
[ScriptTask.from_str("gzip hello")],
fw_id=2,
parents=[fw1],
spec={
"_files_in": {
"fwtest1": "hello"
},
"_files_out": {
"fw2": "hello.gz"
}
},
)
fw3 = Firework([ScriptTask.from_str("cat fwtest.2")],
fw_id=3,
parents=[fw2],
spec={"_files_in": {
"fw2": "fwtest.2"
}})
wf = Workflow([fw1, fw2, fw3], {fw1: [fw2], fw2: [fw3]})
# store workflow and launch it locally
self.lp.add_wf(wf)
launch_rocket(self.lp, self.fworker)
self.assertTrue(os.path.exists("test1"))
launch_rocket(self.lp, self.fworker)
self.assertTrue(os.path.exists("hello.gz"))
launch_rocket(self.lp, self.fworker)
self.assertTrue(os.path.exists("fwtest.2"))
for f in ["test1", "hello.gz", "fwtest.2"]:
os.remove(f)
def test_cleanupfiles(self):
fw1 = Firework(
[
CreateFolder(folder_name="to_remove.relax0"),
CreateFolder(folder_name="to_remove.relax1"),
CreateFolder(folder_name="dont_remove.relax0"),
CreateFolder(folder_name="shouldnt_touch"),
DeleteFilesPrevFolder(files=["to_remove*", "dont_remove"]),
PassCalcLocs(name="fw1"),
],
name="fw1",
)
fw2 = Firework([PassCalcLocs(name="fw2")], name="fw2", parents=fw1)
wf = Workflow([fw1, fw2])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw2 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw2"})[0])
calc_locs = fw2.spec["calc_locs"]
self.assertTrue(
os.path.exists(
os.path.join(
get_calc_loc("fw1", calc_locs)["path"],
"dont_remove.relax0")))
self.assertTrue(
os.path.exists(
os.path.join(
get_calc_loc("fw1", calc_locs)["path"], "shouldnt_touch")))
self.assertFalse(
os.path.exists(
os.path.join(
get_calc_loc("fw1", calc_locs)["path"],
"to_remove.relax0")))
self.assertFalse(
os.path.exists(
os.path.join(
get_calc_loc("fw1", calc_locs)["path"],
"to_remove.relax1")))
def test_job_info(self):
fw1 = Firework([ScriptTask.from_str('echo "Testing job info"')], spec={"_pass_job_info": True}, fw_id=1)
fw2 = Firework([DummyJobPassTask()], parents=[fw1], spec={"_pass_job_info": True, "target": 1}, fw_id=2)
fw3 = Firework([DummyJobPassTask()], parents=[fw2], spec={"target":2}, fw_id=3)
self.lp.add_wf(Workflow([fw1, fw2, fw3]))
launch_rocket(self.lp, self.fworker)
target_fw_id = self.lp.get_fw_ids({"spec.target": 1})[0]
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
"""
cnt = 0
while '_job_info' not in modified_spec and cnt < 5:
print(modified_spec)
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
time.sleep(5)
cnt += 1
"""
self.assertIsNotNone(modified_spec['_job_info'])
self.assertIsNotNone(modified_spec['_job_info'][0]["launch_dir"])
self.assertEqual(modified_spec['_job_info'][0]['name'], 'Unnamed FW')
self.assertEqual(modified_spec['_job_info'][0]['fw_id'], 1)
launch_rocket(self.lp, self.fworker)
target_fw_id = self.lp.get_fw_ids({"spec.target": 2})[0]
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
"""
cnt = 0
while '_job_info' not in modified_spec and cnt < 5:
print(modified_spec)
modified_spec = self.lp.get_fw_by_id(target_fw_id).spec
time.sleep(5)
cnt += 1
"""
self.assertEqual(len(modified_spec['_job_info']), 2)
def basic_wf_ex():
print("--- BASIC WORKFLOW EXAMPLE ---")
# setup
launchpad = setup()
# add FireWorks
task1 = ScriptTask.from_str('echo "Ingrid is the CEO."')
task2 = ScriptTask.from_str('echo "Jill is a manager."')
task3 = ScriptTask.from_str('echo "Jack is a manager."')
task4 = ScriptTask.from_str('echo "Kip is an intern."')
fw1 = Firework(task1, fw_id=1)
fw2 = Firework(task2, fw_id=2)
fw3 = Firework(task3, fw_id=3)
fw4 = Firework(task4, fw_id=4)
# make workflow
workflow = Workflow([fw1, fw2, fw3, fw4], {1: [2, 3], 2: [4], 3: [4]})
launchpad.add_wf(workflow)
# launch Rocket
rapidfire(launchpad, FWorker())
def test_passcalclocs(self):
fw1 = Firework([PassCalcLocs(name="fw1")], name="fw1")
fw2 = Firework([PassCalcLocs(name="fw2")], name="fw2", parents=fw1)
fw3 = Firework([PassCalcLocs(name="fw3")], name="fw3", parents=fw2)
wf = Workflow([fw1, fw2, fw3])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw2 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw2"})[0])
fw3 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw3"})[0])
self.assertEqual(len(fw2.spec["calc_locs"]), 1)
self.assertEqual(len(fw3.spec["calc_locs"]), 2)
self.assertEqual(fw3.spec["calc_locs"][0]["name"], "fw1")
self.assertEqual(fw3.spec["calc_locs"][1]["name"], "fw2")
self.assertNotEqual(fw3.spec["calc_locs"][0]["path"],
fw3.spec["calc_locs"][1]["path"])
calc_locs = fw3.spec["calc_locs"]
self.assertEqual(get_calc_loc("fw1", calc_locs), calc_locs[0])
self.assertEqual(get_calc_loc("fw2", calc_locs), calc_locs[1])
self.assertEqual(get_calc_loc(True, calc_locs), calc_locs[1])
def test_parallel_fibadder(self):
# this is really testing to see if a Workflow can handle multiple FWs updating it at once
parent = Firework(
ScriptTask.from_str("python -c 'print(\"test1\")'",
{'store_stdout': True}))
fib1 = Firework(FibonacciAdderTask(), {
'smaller': 0,
'larger': 1,
'stop_point': 30
},
parents=[parent])
fib2 = Firework(FibonacciAdderTask(), {
'smaller': 0,
'larger': 1,
'stop_point': 30
},
parents=[parent])
fib3 = Firework(FibonacciAdderTask(), {
'smaller': 0,
'larger': 1,
'stop_point': 30
},
parents=[parent])
fib4 = Firework(FibonacciAdderTask(), {
'smaller': 0,
'larger': 1,
'stop_point': 30
},
parents=[parent])
wf = Workflow([parent, fib1, fib2, fib3, fib4])
self.lp.add_wf(wf)
p = Pool(NCORES_PARALLEL_TEST)
creds_array = [self.lp.to_dict()] * NCORES_PARALLEL_TEST
p.map(random_launch, creds_array)
def test_init(self):
fws = []
for i in range(5):
fw = Firework([PyTask(func="print", args=[i])], fw_id=i)
fws.append(fw)
wf = Workflow(fws, links_dict={0: [1, 2, 3], 1: [4], 2: [4]})
self.assertIsInstance(wf, Workflow)
self.assertRaises(ValueError,
Workflow,
fws,
links_dict={
0: [1, 2, 3],
1: [4],
100: [4]
})
self.assertRaises(ValueError,
Workflow,
fws,
links_dict={
0: [1, 2, 3],
1: [4],
2: [100]
})
def __init__(self, abiinput):
abitask = AbiFireTask(abiinput)
self.fw = Firework(abitask)
self.wf = Workflow([self.fw])
def structure_to_wf(structure):
"""
This method starts with a Structure object and creates a Workflow object
The workflow has two steps - a structure relaxation and a static run
:param structure:
:return:
"""
fws = [] # list of FireWorks to run
connections = defaultdict(list) # dependencies between FireWorks
# generate VASP input objects for 1st VASP run - this is put in the FW spec
mpvis = MPGGAVaspInputSet(user_incar_settings={'NPAR': 2})
incar = mpvis.get_incar(structure)
poscar = mpvis.get_poscar(structure)
kpoints = mpvis.get_kpoints(structure)
potcar = mpvis.get_potcar(structure)
# serialize the VASP input objects to the FW spec
spec = {}
spec['vasp'] = {}
spec['vasp']['incar'] = incar.as_dict()
spec['vasp']['poscar'] = poscar.as_dict()
spec['vasp']['kpoints'] = kpoints.as_dict()
spec['vasp']['potcar'] = potcar.as_dict()
spec['vaspinputset_name'] = mpvis.__class__.__name__
spec['task_type'] = 'GGA optimize structure (2x) example'
# set up the custodian that we want to run
jobs = VaspJob.double_relaxation_run('')
for j in jobs: # turn off auto npar, it doesn't work for >1 node
j.auto_npar = False
handlers = [
VaspErrorHandler(),
FrozenJobErrorHandler(),
MeshSymmetryErrorHandler(),
NonConvergingErrorHandler()
]
c_params = {
'jobs': [j.as_dict() for j in jobs],
'handlers': [h.as_dict() for h in handlers],
'max_errors': 5
}
custodiantask = VaspCustodianTaskEx(c_params)
# 1st Firework - run GGA optimize structure
# VaspWriterTask - write input files (INCAR, POSCAR, KPOINTS, POSCAR) based on spec
# CustodianTaskEx - run VASP within a custodian
tasks = [VaspWriterTask(), custodiantask]
fws.append(
Firework(tasks,
spec,
name=get_name(structure, spec['task_type']),
fw_id=1))
# 2nd Firework - insert previous run into DB
spec = {'task_type': 'VASP db insertion example'}
fws.append(
Firework([VaspToDBTaskEx()],
spec,
name=get_name(structure, spec['task_type']),
fw_id=2))
connections[1] = [2]
# 3rd Firework - static run.
# VaspCopyTask - copy output from previous run to this directory
# SetupStaticRunTask - override old parameters for static run
# CustodianTaskEx - run VASP within a custodian
spec = {'task_type': 'GGA static example'}
copytask = VaspCopyTask({'use_CONTCAR': True, 'skip_CHGCAR': True})
setuptask = SetupStaticRunTask()
custodiantask = VaspCustodianTaskEx({
'jobs': [VaspJob('', auto_npar=False).as_dict()],
'handlers': [h.as_dict() for h in handlers],
'max_errors':
5
})
fws.append(
Firework([copytask, setuptask, custodiantask],
spec,
name=get_name(structure, spec['task_type']),
fw_id=3))
connections[2] = [3]
# 4th Firework - insert previous run into DB
spec = {'task_type': 'VASP db insertion example'}
fws.append(
Firework([VaspToDBTaskEx()],
spec,
name=get_name(structure, spec['task_type']),
fw_id=4))
connections[3] = [4]
return Workflow(fws, connections, name=get_slug(structure.formula))
def parchg_get_for_localization_check(dir, vasp_cmd, label):
"""
Args:
dir: directory need to scan
vasp_cmd: vasp run command executed by os.system, e.g. 'vasp_std'
label: a label for these jobs
"""
scan = subprocess.Popen(['find', dir, '-name', 'wavecar'],
stdout=subprocess.PIPE)
scan.wait()
dir_coll = scan.stdout.read().split()
exclude = re.compile('.*charge0|.*charge_0|.*skip')
include = re.compile('.*subst|.*sub|.*vac|.*inter|.*as')
work_dirs = [
dir for dir in dir_coll
if not exclude.match(dir) and include.match(dir)
]
fws = []
njobs = 0
dir_end = 'parchg'
for work_dir in work_dirs:
with cd(work_dir):
print work_dir
if os.path.isdir(dir_end):
if glob.glob(os.path.join('parchg', 'PARCHG*')) != []:
print work_dir, ' was already well done! Skip now!'
continue
else:
delect = subprocess.Popen(['rm', '-rf', dir_end])
delect.wait()
os.mkdir(dir_end)
iband = get_iband(work_dir)
incar = Incar.from_file('INCAR')
incar['ICHARG'] = 0
incar['ISTART'] = 1
incar['LPARD'] = True
incar['IBAND'] = iband
incar['KPUSE'] = 1
incar['LSEPB'] = True
incar['LSEPK'] = True
incar.write_file(os.path.join(dir_end, 'INCAR'))
shutil.copyfile('IBZKPT', os.path.join(dir_end, 'KPOINTS'))
inputs_other = ['POTCAR', 'POSCAR', 'WAVECAR']
for input in inputs_other:
shutil.copy(input, dir_end)
try:
transf = json.load(open('transformations.json'))
except:
transf = json.load(open('transformation.json'))
queue = {}
queue['job_name'] = label + '_' + transf[
'defect_type'] + '_' + str(transf['charge'])
queue['ntasks'] = 1
queue['vmem'] = '40000mb'
queue['walltime'] = '01:00:00'
fw_name = transf['defect_type'] + '_' + str(transf['charge'])
ftask = CommandRun()
fw = Firework(
[ftask],
spec={
'cmd': vasp_cmd,
'_launch_dir': os.path.join(work_dir, dir_end),
'_queueadapter': queue,
'_fworker': fworker
},
name=fw_name)
fws.append(fw)
njobs = njobs + 1
wf = Workflow(fws, name=label)
launchpad.add_wf(wf)
return njobs
def __init__(self,
neb_vasp_input_set,
spec,
neb_terminals,
relax_terminals=True,
n_insert=1,
n_nebs=3,
relax_vasp_input_set=None,
initial_neb_structures=None,
climbing_image=True):
user_incar_settings = {'NPAR': 4, 'ISIF': 0, 'SIGMA': 0.2, 'ISMEAR': 0}
if n_nebs < 1:
raise ValueError('Minimum one NEB ...')
if relax_terminals and initial_neb_structures is not None:
raise ValueError(
'Cannot relax terminals and start from initial NEB structures')
# Initializes fws list and links_dict
fws = []
links_dict = {}
if 'additional_controllers' in spec:
additional_controllers = spec['additional_controllers']
spec.pop('additional_controllers')
else:
additional_controllers = [
WalltimeController(),
MemoryController(),
VaspXMLValidatorController()
]
# Control procedure
control_procedure = ControlProcedure(
controllers=additional_controllers)
# First NEB
gen_neb_spec = spec.copy()
if relax_terminals:
gen_neb_spec['terminal_start'] = None
gen_neb_spec['terminal_end'] = None
else:
gen_neb_spec['terminal_start'] = neb_terminals[0]
gen_neb_spec['terminal_end'] = neb_terminals[1]
# gen_neb_spec['structures'] = neb_terminals
gen_neb_spec = set_short_single_core_to_spec(gen_neb_spec)
terminal_start_relax_task_type = 'MPRelaxVasp-start'
terminal_end_relax_task_type = 'MPRelaxVasp-end'
terminal_start_task_type = None
terminal_end_task_type = None
if relax_terminals:
terminal_start_task_type = terminal_start_relax_task_type
terminal_end_task_type = terminal_end_relax_task_type
gen_neb_task = GenerateNEBRelaxationTask(
n_insert=n_insert,
user_incar_settings=user_incar_settings,
climbing_image=climbing_image,
task_index='neb1',
terminal_start_task_type=terminal_start_task_type,
terminal_end_task_type=terminal_end_task_type)
gen_neb_fw = Firework([gen_neb_task],
spec=gen_neb_spec,
name='gen-neb1')
fws.append(gen_neb_fw)
if relax_terminals:
# Start terminal
relax_task_helper = MPRelaxTaskHelper()
vis_start = relax_vasp_input_set(
neb_terminals[0], user_incar_settings=user_incar_settings)
start_src_fws = createVaspSRCFireworks(
vasp_input_set=vis_start,
task_helper=relax_task_helper,
task_type=terminal_start_relax_task_type,
control_procedure=control_procedure,
custodian_handlers=[],
max_restarts=10,
src_cleaning=None,
task_index=None,
spec=None,
setup_spec_update=None,
run_spec_update=None)
fws.extend(start_src_fws['fws'])
links_dict_update(links_dict=links_dict,
links_update=start_src_fws['links_dict'])
linkupdate = {start_src_fws['control_fw'].fw_id: gen_neb_fw.fw_id}
links_dict_update(links_dict=links_dict, links_update=linkupdate)
# End terminal
vis_end = relax_vasp_input_set(
neb_terminals[1], user_incar_settings=user_incar_settings)
end_src_fws = createVaspSRCFireworks(
vasp_input_set=vis_end,
task_helper=relax_task_helper,
task_type=terminal_end_relax_task_type,
control_procedure=control_procedure,
custodian_handlers=[],
max_restarts=10,
src_cleaning=None,
task_index=None,
spec=None,
setup_spec_update=None,
run_spec_update=None)
fws.extend(end_src_fws['fws'])
links_dict_update(links_dict=links_dict,
links_update=end_src_fws['links_dict'])
linkupdate = {end_src_fws['control_fw'].fw_id: gen_neb_fw.fw_id}
links_dict_update(links_dict=links_dict, links_update=linkupdate)
if n_nebs > 1:
for ineb in range(2, n_nebs + 1):
prev_gen_neb_fw = gen_neb_fw
gen_neb_spec = spec.copy()
gen_neb_spec['structures'] = None
gen_neb_spec = set_short_single_core_to_spec(gen_neb_spec)
gen_neb_task = GenerateNEBRelaxationTask(
n_insert=n_insert,
user_incar_settings=user_incar_settings,
climbing_image=climbing_image,
task_index='neb{:d}'.format(ineb),
prev_neb_task_type='neb{:d}'.format(ineb - 1),
terminal_start_task_type=terminal_start_task_type,
terminal_end_task_type=terminal_end_task_type)
gen_neb_fw = Firework([gen_neb_task],
spec=gen_neb_spec,
name='gen-neb{:d}'.format(ineb))
fws.append(gen_neb_fw)
linkupdate = {prev_gen_neb_fw.fw_id: gen_neb_fw.fw_id}
links_dict_update(links_dict=links_dict,
links_update=linkupdate)
if relax_terminals:
linkupdate = {
start_src_fws['control_fw'].fw_id: gen_neb_fw.fw_id
}
links_dict_update(links_dict=links_dict,
links_update=linkupdate)
linkupdate = {
end_src_fws['control_fw'].fw_id: gen_neb_fw.fw_id
}
links_dict_update(links_dict=links_dict,
links_update=linkupdate)
if climbing_image:
wfname = "MPcNEBRelaxFWWorkflowSRC"
else:
wfname = "MPcNEBRelaxFWWorkflowSRC"
self.wf = Workflow(fireworks=fws,
links_dict=links_dict,
metadata={
'workflow_class': self.workflow_class,
'workflow_module': self.workflow_module
},
name=wfname)
def run_task(self, fw_spec):
if '_fizzled_parents' in fw_spec and not 'prev_vasp_dir' in fw_spec:
prev_dir = get_loc(
fw_spec['_fizzled_parents'][0]['launches'][0]['launch_dir'])
update_spec = {} # add this later when creating new FW
fizzled_parent = True
parse_dos = False
else:
prev_dir = get_loc(fw_spec['prev_vasp_dir'])
update_spec = {
'prev_vasp_dir': prev_dir,
'prev_task_type': fw_spec['prev_task_type'],
'run_tags': fw_spec['run_tags'],
'parameters': fw_spec.get('parameters')
}
fizzled_parent = False
parse_dos = 'Uniform' in fw_spec['prev_task_type']
if 'run_tags' in fw_spec:
self.additional_fields['run_tags'] = fw_spec['run_tags']
else:
self.additional_fields['run_tags'] = fw_spec['_fizzled_parents'][
0]['spec']['run_tags']
if MOVE_TO_GARDEN_DEV:
prev_dir = move_to_garden(prev_dir, prod=False)
elif MOVE_TO_GARDEN_PROD:
prev_dir = move_to_garden(prev_dir, prod=True)
# get the directory containing the db file
db_dir = os.environ['DB_LOC']
db_path = os.path.join(db_dir, 'tasks_db.json')
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('MPVaspDrone')
logger.setLevel(logging.INFO)
sh = logging.StreamHandler(stream=sys.stdout)
sh.setLevel(getattr(logging, 'INFO'))
logger.addHandler(sh)
with open(db_path) as f:
db_creds = json.load(f)
drone = MPVaspDrone(host=db_creds['host'],
port=db_creds['port'],
database=db_creds['database'],
user=db_creds['admin_user'],
password=db_creds['admin_password'],
collection=db_creds['collection'],
parse_dos=parse_dos,
additional_fields=self.additional_fields,
update_duplicates=self.update_duplicates)
t_id, d = drone.assimilate(
prev_dir, launches_coll=LaunchPad.auto_load().launches)
mpsnl = d['snl_final'] if 'snl_final' in d else d['snl']
snlgroup_id = d['snlgroup_id_final'] if 'snlgroup_id_final' in d else d[
'snlgroup_id']
update_spec.update({'mpsnl': mpsnl, 'snlgroup_id': snlgroup_id})
print 'ENTERED task id:', t_id
stored_data = {'task_id': t_id}
if d['state'] == 'successful':
update_spec['analysis'] = d['analysis']
update_spec['output'] = d['output']
update_spec['vasp'] = {
'incar': d['calculations'][-1]['input']['incar'],
'kpoints': d['calculations'][-1]['input']['kpoints']
}
update_spec["task_id"] = t_id
return FWAction(stored_data=stored_data, update_spec=update_spec)
# not successful - first test to see if UnconvergedHandler is needed
if not fizzled_parent:
unconverged_tag = 'unconverged_handler--{}'.format(
fw_spec['prev_task_type'])
output_dir = last_relax(os.path.join(prev_dir, 'vasprun.xml'))
ueh = UnconvergedErrorHandler(output_filename=output_dir)
# TODO: make this a little more flexible
if ueh.check() and unconverged_tag not in fw_spec['run_tags']:
print 'Unconverged run! Creating dynamic FW...'
spec = {
'prev_vasp_dir': prev_dir,
'prev_task_type': fw_spec['task_type'],
'mpsnl': mpsnl,
'snlgroup_id': snlgroup_id,
'task_type': fw_spec['prev_task_type'],
'run_tags': list(fw_spec['run_tags']),
'parameters': fw_spec.get('parameters'),
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': fw_spec['_priority']
}
# Pass elastic tensor spec
if 'deformation_matrix' in fw_spec.keys():
spec['deformation_matrix'] = fw_spec['deformation_matrix']
spec['original_task_id'] = fw_spec['original_task_id']
snl = StructureNL.from_dict(spec['mpsnl'])
spec['run_tags'].append(unconverged_tag)
spec['_queueadapter'] = QA_VASP
fws = []
connections = {}
f = Composition(snl.structure.composition.reduced_formula
).alphabetical_formula
fws.append(
Firework([
VaspCopyTask({
'files': [
'INCAR', 'KPOINTS', 'POSCAR', 'POTCAR',
'CONTCAR'
],
'use_CONTCAR':
False
}),
SetupUnconvergedHandlerTask(),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-2))
spec = {
'task_type': 'VASP db insertion',
'_allow_fizzled_parents': True,
'_priority': fw_spec['_priority'],
'_queueadapter': QA_DB,
'run_tags': list(fw_spec['run_tags'])
}
if 'deformation_matrix' in fw_spec.keys():
spec['deformation_matrix'] = fw_spec['deformation_matrix']
spec['original_task_id'] = fw_spec['original_task_id']
spec['run_tags'].append(unconverged_tag)
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-1))
connections[-2] = -1
wf = Workflow(fws, connections)
return FWAction(detours=wf)
# not successful and not due to convergence problem - FIZZLE
raise ValueError("DB insertion successful, but don't know how to \
fix this Firework! Can't continue with workflow...")
def mol_to_ipea_wf(mol, name, **kwargs):
fireworks, links_dict = multistep_ipea_fws(mol, name, **kwargs)
return Workflow(fireworks, links_dict, name)
def run_task(self, fw_spec):
print 'sleeping 10s for Mongo'
time.sleep(10)
print 'done sleeping'
print 'the gap is {}, the cutoff is {}'.format(
fw_spec['analysis']['bandgap'], self.gap_cutoff)
if fw_spec['analysis']['bandgap'] >= self.gap_cutoff:
static_dens = 90
uniform_dens = 1000
line_dens = 20
else:
static_dens = 450
uniform_dens = 1500
line_dens = 30
if fw_spec['analysis']['bandgap'] <= self.metal_cutoff:
user_incar_settings = {"ISMEAR": 1, "SIGMA": 0.2}
else:
user_incar_settings = {}
print 'Adding more runs...'
type_name = 'GGA+U' if 'GGA+U' in fw_spec['prev_task_type'] else 'GGA'
snl = StructureNL.from_dict(fw_spec['mpsnl'])
f = Composition(
snl.structure.composition.reduced_formula).alphabetical_formula
fws = []
connections = {}
priority = fw_spec['_priority']
trackers = [
Tracker('FW_job.out'),
Tracker('FW_job.error'),
Tracker('vasp.out'),
Tracker('OUTCAR'),
Tracker('OSZICAR')
]
trackers_db = [Tracker('FW_job.out'), Tracker('FW_job.error')]
# run GGA static
spec = fw_spec # pass all the items from the current spec to the new
spec.update({
'task_type': '{} static v2'.format(type_name),
'_queueadapter': QA_VASP_SMALL,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority,
'_trackers': trackers
})
fws.append(
Firework([
VaspCopyTask({
'use_CONTCAR': True,
'skip_CHGCAR': True
}),
SetupStaticRunTask({
"kpoints_density": static_dens,
'user_incar_settings': user_incar_settings
}),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-10))
# insert into DB - GGA static
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority * 2,
"_dupefinder": DupeFinderDB().to_dict(),
'_trackers': trackers_db
}
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-9))
connections[-10] = -9
# run GGA Uniform
spec = {
'task_type': '{} Uniform v2'.format(type_name),
'_queueadapter': QA_VASP,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority,
'_trackers': trackers
}
fws.append(
Firework([
VaspCopyTask({'use_CONTCAR': False}),
SetupNonSCFTask({
'mode': 'uniform',
"kpoints_density": uniform_dens
}),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-8))
connections[-9] = -8
# insert into DB - GGA Uniform
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority * 2,
"_dupefinder": DupeFinderDB().to_dict(),
'_trackers': trackers_db
}
fws.append(
Firework([VaspToDBTask({'parse_uniform': True})],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-7))
connections[-8] = -7
# run GGA Band structure
spec = {
'task_type': '{} band structure v2'.format(type_name),
'_queueadapter': QA_VASP,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority,
'_trackers': trackers
}
fws.append(
Firework([
VaspCopyTask({'use_CONTCAR': False}),
SetupNonSCFTask({
'mode': 'line',
"kpoints_line_density": line_dens
}),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-6))
connections[-7] = [-6]
# insert into DB - GGA Band structure
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority * 2,
"_dupefinder": DupeFinderDB().to_dict(),
'_trackers': trackers_db
}
fws.append(
Firework([VaspToDBTask({})],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-5))
connections[-6] = -5
if fw_spec.get('parameters') and fw_spec['parameters'].get(
'boltztrap'):
# run Boltztrap
from mpworks.firetasks.boltztrap_tasks import BoltztrapRunTask
spec = {
'task_type': '{} Boltztrap'.format(type_name),
'_queueadapter': QA_DB,
'_dupefinder': DupeFinderDB().to_dict(),
'_priority': priority
}
fws.append(
Firework([BoltztrapRunTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-4))
connections[-7].append(-4)
wf = Workflow(fws, connections)
print 'Done adding more runs...'
return FWAction(additions=wf)
def run_task(self, fw_spec):
print 'sleeping 10s for Mongo'
time.sleep(10)
print 'done sleeping'
print 'the gap is {}, the cutoff is {}'.format(
fw_spec['analysis']['bandgap'], self.gap_cutoff)
if fw_spec['analysis']['bandgap'] >= self.gap_cutoff:
print 'Adding more runs...'
type_name = 'GGA+U' if 'GGA+U' in fw_spec[
'prev_task_type'] else 'GGA'
snl = StructureNL.from_dict(fw_spec['mpsnl'])
f = Composition(
snl.structure.composition.reduced_formula).alphabetical_formula
fws = []
connections = {}
priority = fw_spec['_priority']
# run GGA static
spec = fw_spec # pass all the items from the current spec to the new
# one
spec.update({
'task_type': '{} static'.format(type_name),
'_queueadapter': QA_VASP,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority
})
fws.append(
Firework([
VaspCopyTask({'use_CONTCAR': True}),
SetupStaticRunTask(),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-10))
# insert into DB - GGA static
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority,
"_dupefinder": DupeFinderDB().to_dict()
}
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-9))
connections[-10] = -9
# run GGA Uniform
spec = {
'task_type': '{} Uniform'.format(type_name),
'_queueadapter': QA_VASP,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority
}
fws.append(
Firework([
VaspCopyTask({'use_CONTCAR': False}),
SetupNonSCFTask({'mode': 'uniform'}),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-8))
connections[-9] = -8
# insert into DB - GGA Uniform
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority,
"_dupefinder": DupeFinderDB().to_dict()
}
fws.append(
Firework([VaspToDBTask({'parse_uniform': True})],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-7))
connections[-8] = -7
# run GGA Band structure
spec = {
'task_type': '{} band structure'.format(type_name),
'_queueadapter': QA_VASP,
'_dupefinder': DupeFinderVasp().to_dict(),
'_priority': priority
}
fws.append(
Firework([
VaspCopyTask({'use_CONTCAR': False}),
SetupNonSCFTask({'mode': 'line'}),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-6))
connections[-7] = -6
# insert into DB - GGA Band structure
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority,
"_dupefinder": DupeFinderDB().to_dict()
}
fws.append(
Firework([VaspToDBTask({})],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-5))
connections[-6] = -5
wf = Workflow(fws, connections)
print 'Done adding more runs...'
return FWAction(additions=wf)
return FWAction()
def PBEsol_Relax_then_HSE_Gap_with_Vasp(material_id, vasp_cmd, struct,
is_spin_polarized):
"""
add the defect relax calculations(by Vasp) into the launchpad.
return the total calculation number
Args:
material_id: the material under consideration with id from materials project
vasp_cmd1: the vasp command for PBEsol relaxation, e.g. ['mpirun','vasp']
vasp_cmd2: the vasp command for HSE static run, e.g. ['mpirun', 'vasp']
hse: True means considering the hse during the vasp calculations. Default: False
"""
ftaska1 = Generate_VaspInputFiles_for_Relax_with_PBEsol()
ftaska2 = VaspRun()
ftaskb1 = Generate_VaspInputfiles_for_Static_Run()
ftaskb2 = VaspRun()
ftaskc1 = Generate_VaspInputfiles_for_BS()
ftaskc2 = VaspRun()
ftaskd1 = Generate_VaspInputFiles_for_HSE_certain_shots()
ftaskd2 = VaspRun()
ftaskf1 = Insert_Gap_into_monogdb()
queue1 = {} ### for PBE
queue2 = {} ### for HSE
queue1['job_name'] = material_id + '_PBEsol'
queue2['job_name'] = material_id + '_HSE'
nsites = struct.num_sites
if nsites <= 5:
queue1['ntasks'] = 6
queue1['walltime'] = '6:00:00'
queue2['ntasks'] = 24
queue2['walltime'] = '24:00:00'
elif 5 < nsites <= 10:
queue1['ntasks'] = 12
queue1['walltime'] = '12:00:00'
queue2['ntasks'] = 48
queue2['walltime'] = '48:00:00'
elif 10 < nsites <= 20:
queue1['ntasks'] = 24
queue1['walltime'] = '24:00:00'
queue2['ntasks'] = 60
queue2['walltime'] = '48:00:00'
elif 20 < nsites <= 50:
queue1['ntasks'] = 36
queue1['walltime'] = '24:00:00'
queue2['ntasks'] = 96
queue2['walltime'] = '72:00:00'
else:
queue1['ntasks'] = 48
queue1['walltime'] = '24:00:00'
queue2['ntasks'] = 96
queue2['walltime'] = '72:00:00'
##insert info to Mongodb
queue3 = {}
queue3['ntasks'] = 1
queue3['walltime'] = '01:00:00'
queue3['vmem'] = '1024mb'
queue3['job_name'] = material_id + '_Insert'
## PBEsol relax
fw1 = Firework(
[ftaska1, ftaska2],
spec={
'_pass_job_info': True,
'_preserve_fworker': True,
'_fworker': fworker,
'vasp_cmd': vasp_cmd,
'workdir': './',
'structure': struct,
'material_id': material_id,
'is_spin_polarized': is_spin_polarized,
'_queueadapter': queue1
},
name=material_id + '_PBEsol_Relax')
## PBEsol static run
fw2 = Firework(
[ftaskb1, ftaskb2],
parents=[fw1],
spec={
'_pass_job_info': True,
'vasp_cmd': vasp_cmd,
'workdir': './',
'material_id': material_id,
'_queueadapter': queue1
},
name=material_id + '_PBEsol_StaticRun')
## PBEsol band structure
fw3 = Firework(
[ftaskc1, ftaskc2],
parents=[fw2],
spec={
'_pass_job_info': True,
'vasp_cmd': vasp_cmd,
'workdir': './',
'material_id': material_id,
'_queueadapter': queue1
},
name=material_id + '_PBEsol_BS')
## HSE static run with PBEsol k_VBM and k_CBM
fw4 = Firework(
[ftaskd1, ftaskd2],
parents=[fw3],
spec={
'_pass_job_info': True,
'vasp_cmd': vasp_cmd,
'workdir': './',
'material_id': material_id,
'is_spin_polarized': is_spin_polarized,
'_queueadapter': queue2
},
name=material_id + '_HSE_scf')
## insert results into mongodb
fw5 = Firework([ftaskf1],
parents=[fw4],
spec={
'material_id': material_id,
'_queueadapter': queue3
},
name=material_id + '_Insert')
wf = Workflow([fw1, fw2, fw3, fw4, fw5], {
fw1: [fw2],
fw2: [fw3],
fw3: [fw4],
fw4: [fw5]
},
name=material_id + '_' + struct.composition.reduced_formula +
'_HSE_Gap')
launchpad.add_wf(wf)
def wavecar_get_for_localization_check(dir, vasp_cmd, label):
"""
Args:
dir: directory need to scan
vasp_cmd: vasp run command executed by subprocess.Popen, e.g. ['mpirun','vasp_std'] or ['srun','vasp_std']
label: a label for these jobs
"""
scan = subprocess.Popen(['find', dir, '-name', 'POSCAR'],
stdout=subprocess.PIPE)
scan.wait()
dir_coll = [os.path.split(dir)[0] for dir in scan.stdout.read().split()]
exclude = re.compile('.*charge0|.*charge_0|.*skip')
include = re.compile('.*subst|.*sub|.*vac|.*inter|.*as')
work_dirs = [
dir for dir in dir_coll if not exclude.match(dir)
and 'charge' in dir.split('/')[-1] and include.match(dir)
]
#work_dirs=[dir for dir in dir_coll
# if ('charge0' not in dir or 'charge_0' not in dir) and 'charge' in dir.split('/')[-1] and ('subst' in dir or 'vac' in dir)]
fws = []
njobs = 0
dir_end = 'wavecar'
for work_dir in work_dirs:
with cd(work_dir):
os.mkdir(dir_end)
incar = Incar.from_file('INCAR')
incar['LVHAR'] = True
incar['LWAVE'] = True
incar['IBRION'] = -1
incar['NSW'] = 0
incar['EDIFF'] = 0.000001
incar.write_file(os.path.join(dir_end, 'INCAR'))
shutil.copyfile('CONTCAR', os.path.join(dir_end, 'POSCAR'))
inputs_other = ['KPOINTS', 'POTCAR']
for input in inputs_other:
shutil.copy(input, dir_end)
try:
shutil.copy('transformations.json', dir_end)
transf = json.load(open('transformations.json'))
except:
shutil.copy('transformation.json', dir_end)
transf = json.load(open('transformation.json'))
queue = {}
queue['job_name'] = label + '_' + transf[
'defect_type'] + '_' + str(transf['charge']) + '_wavecar'
fw_name = transf['defect_type'] + '_' + str(transf['charge'])
ftask = VaspRun()
fw = Firework(
[ftask],
spec={
'vasp_cmd': vasp_cmd,
'_launch_dir': os.path.join(work_dir, dir_end),
'_queueadapter': queue,
'_fworker': fworker
},
name=fw_name)
fws.append(fw)
njobs = njobs + 1
wf = Workflow(fws, name=label)
launchpad.add_wf(wf)
return njobs
def run_task(self, fw_spec):
# Read structure from previous relaxation
relaxed_struct = fw_spec['output']['crystal']
# Generate deformed structures
d_struct_set = DeformedStructureSet(relaxed_struct, ns=0.06)
wf = []
for i, d_struct in enumerate(d_struct_set.def_structs):
fws = []
connections = {}
f = Composition(d_struct.formula).alphabetical_formula
snl = StructureNL(d_struct,
'Joseph Montoya <*****@*****.**>',
projects=["Elasticity"])
tasks = [AddSNLTask()]
snl_priority = fw_spec.get('priority', 1)
spec = {
'task_type': 'Add Deformed Struct to SNL database',
'snl': snl.as_dict(),
'_queueadapter': QA_DB,
'_priority': snl_priority
}
if 'snlgroup_id' in fw_spec and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.as_dict()
spec['force_snlgroup_id'] = fw_spec['snlgroup_id']
del spec['snl']
fws.append(
Firework(tasks,
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-1000 + i * 10))
connections[-1000 + i * 10] = [-999 + i * 10]
spec = snl_to_wf._snl_to_spec(snl,
parameters={'exact_structure': True})
spec = update_spec_force_convergence(spec)
spec['deformation_matrix'] = d_struct_set.deformations[i].tolist()
spec['original_task_id'] = fw_spec["task_id"]
spec['_priority'] = fw_spec['_priority'] * 2
#Turn off dupefinder for deformed structure
del spec['_dupefinder']
spec['task_type'] = "Optimize deformed structure"
fws.append(
Firework([
VaspWriterTask(),
SetupElastConstTask(),
get_custodian_task(spec)
],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-999 + i * 10))
priority = fw_spec['_priority'] * 3
spec = {
'task_type': 'VASP db insertion',
'_priority': priority,
'_allow_fizzled_parents': True,
'_queueadapter': QA_DB,
'elastic_constant': "deformed_structure",
'clean_task_doc': True,
'deformation_matrix': d_struct_set.deformations[i].tolist(),
'original_task_id': fw_spec["task_id"]
}
fws.append(
Firework(
[VaspToDBTask(), AddElasticDataToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=-998 + i * 10))
connections[-999 + i * 10] = [-998 + i * 10]
wf.append(Workflow(fws, connections))
return FWAction(additions=wf)
def HSE_Gap_with_Vasp_from_icsd_data(file, vasp_cmd):
fws = []
all = json.load(open(file))
njobs = 0
g = open('/SCRATCH/acad/htbase/yugd/fw_workplace/hse_gaps_icsd/ids')
ids = g.read().split()
f = open('wrong_list.dat', 'a+')
for task in all:
icsd_id = 'icsd-' + str(task['icsd_ids'][0])
if icsd_id not in ids:
continue
try:
struct = Structure.from_dict(task['structure'])
pbe_bs = BandStructureSymmLine.from_dict(
task['band_structures']['line'])
is_spin_polarized = pbe_bs.is_spin_polarized
k_vbm = pbe_bs.get_vbm()['kpoint']._fcoords
k_cbm = pbe_bs.get_cbm()['kpoint']._fcoords
except:
f.write('all[' + str(all.index(task)) + ']')
continue
##########################################################
njobs = njobs + 1
queue_hse = {}
queue_pbesol = {}
queue_hse['job_name'] = icsd_id + '_HSE'
queue_pbesol['job_name'] = icsd_id + '_PBEsol'
nsites = struct.num_sites
if nsites <= 5:
queue_pbesol['ntasks'] = 6
queue_pbesol['walltime'] = '6:00:00'
queue_hse['ntasks'] = 12
queue_hse['walltime'] = '24:00:00'
elif 5 < nsites <= 10:
queue_pbesol['ntasks'] = 12
queue_pbesol['walltime'] = '6:00:00'
queue_hse['ntasks'] = 24
queue_hse['walltime'] = '48:00:00'
elif 10 < nsites <= 20:
queue_pbesol['ntasks'] = 12
queue_pbesol['walltime'] = '24:00:00'
queue_hse['ntasks'] = 48
queue_hse['walltime'] = '48:00:00'
elif 20 < nsites <= 50:
queue_pbesol['ntasks'] = 24
queue_pbesol['walltime'] = '48:00:00'
queue_hse['ntasks'] = 60
queue_hse['walltime'] = '72:00:00'
else:
queue_pbesol['ntasks'] = 36
queue_pbesol['walltime'] = '48:00:00'
queue_hse['ntasks'] = 96
queue_hse['walltime'] = '72:00:00'
queue_insert = {}
queue_insert['ntasks'] = 1
queue_insert['walltime'] = '01:00:00'
queue_insert['vmem'] = '1024mb'
queue_insert['job_name'] = icsd_id + '_Insert'
##########################################################
if pbe_bs.get_band_gap()['direct']:
ks_add = [k_vbm]
else:
ks_add = [k_vbm, k_cbm]
ftask00 = Generate_VaspInputFiles_for_Relax_with_PBEsol_icsd()
ftask01 = VaspRun()
fw0 = Firework(
[ftask00, ftask01],
spec={
'_pass_job_info': True,
'_preserve_fworker': True,
'_fworker': fworker,
'vasp_cmd': vasp_cmd,
'workdir': './',
'structure': struct,
'icsd_id': icsd_id,
'is_spin_polarized': is_spin_polarized,
'_queueadapter': queue_pbesol
},
name=icsd_id + '_pbesol')
ftask10 = Generate_VaspInputFiles_for_HSE_scf_icsd()
ftask11 = VaspRun()
fw1 = Firework(
[ftask10, ftask11],
parents=[fw0],
spec={
'_pass_job_info': True,
'_preserve_fworker': True,
'_fworker': fworker,
'vasp_cmd': vasp_cmd,
'workdir': './',
'icsd_id': icsd_id,
'ks_add': ks_add,
'is_spin_polarized': is_spin_polarized,
'_queueadapter': queue_hse
},
name=icsd_id + '_HSE')
finsert = Insert_Gap_into_monogdb_icsd()
fw2 = Firework([finsert],
parents=[fw1],
spec={
'icsd_id': icsd_id,
'_queueadapter': queue_insert,
'pbe_bs': pbe_bs
},
name=icsd_id + '_Insert')
fws.append(fw0)
fws.append(fw1)
fws.append(fw2)
wf = Workflow(fws, name='HSE_Gap_for_icsds')
launchpad.add_wf(wf)
f.close()
return njobs
def snl_to_wf_phonon(snl, parameters=None):
fws = []
connections = {}
parameters = parameters if parameters else {}
snl_priority = parameters.get('priority', 1)
priority = snl_priority * 2 # once we start a job, keep going!
f = Composition(
snl.structure.composition.reduced_formula).alphabetical_formula
# add the SNL to the SNL DB and figure out duplicate group
tasks = [AddSNLTask()]
spec = {
'task_type': 'Add to SNL database',
'snl': snl.as_dict(),
'_queueadapter': QA_DB,
'_priority': snl_priority
}
if 'snlgroup_id' in parameters and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.as_dict()
spec['force_snlgroup_id'] = parameters['snlgroup_id']
del spec['snl']
fws.append(
Firework(tasks,
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=0))
connections[0] = [1]
# run GGA structure optimization for force convergence
spec = snl_to_wf._snl_to_spec(snl, parameters=parameters)
spec = update_spec_force_convergence(spec)
spec['run_tags'].append("origin")
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
spec['task_type'] = "Vasp force convergence"
tasks = [VaspWriterTask(), get_custodian_task(spec)]
fws.append(
Firework(tasks,
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=1))
# insert into DB - GGA structure optimization
spec = {
'task_type': 'VASP db insertion',
'_priority': priority,
'_allow_fizzled_parents': True,
'_queueadapter': QA_DB
}
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=2))
connections[1] = [2]
spec = {
'task_type': 'Setup Deformed Struct Task',
'_priority': priority,
'_queueadapter': QA_CONTROL
}
fws.append(
Firework([SetupDeformedStructTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=3))
connections[2] = [3]
wf_meta = get_meta_from_structure(snl.structure)
wf_meta['run_version'] = 'May 2013 (1)'
if '_materialsproject' in snl.data and 'submission_id' in snl.data[
'_materialsproject']:
wf_meta['submission_id'] = snl.data['_materialsproject'][
'submission_id']
return Workflow(
fws,
connections,
name=Composition(
snl.structure.composition.reduced_formula).alphabetical_formula,
metadata=wf_meta)
def test_writevaspfrominterpolatedposcar(self):
nimages = 5
this_image = 1
autosort_tol = 0.5
fw1 = Firework([
CopyVaspOutputs(calc_dir=self.static_outdir,
contcar_to_poscar=False,
additional_files=["CONTCAR"]),
PassCalcLocs(name="fw1")
],
name="fw1")
fw2 = Firework([
CopyVaspOutputs(calc_dir=self.opt_outdir,
contcar_to_poscar=False,
additional_files=["CONTCAR"]),
PassCalcLocs(name="fw2")
],
name="fw2")
fw3 = Firework([
WriteVaspFromIOSetFromInterpolatedPOSCAR(
start="fw1",
end="fw2",
this_image=this_image,
nimages=nimages,
autosort_tol=autosort_tol,
vasp_input_set="MPStaticSet"),
PassCalcLocs(name="fw3")
],
name="fw3",
parents=[fw1, fw2])
fw4 = Firework([PassCalcLocs(name="fw4")], name="fw4", parents=fw3)
wf = Workflow([fw1, fw2, fw3, fw4])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw4 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw4"})[0])
calc_locs = fw4.spec["calc_locs"]
print(get_calc_loc("fw3", calc_locs)["path"])
# Check existence of structure files.
self.assertTrue(
os.path.exists(get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR"))
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_0"))
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_1"))
self.assertTrue(
os.path.exists(get_calc_loc("fw3", calc_locs)["path"] + "/INCAR"))
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] + "/KPOINTS"))
self.assertTrue(
os.path.exists(get_calc_loc("fw3", calc_locs)["path"] + "/POTCAR"))
# Check interpolation.
struct_start = Structure.from_file(
get_calc_loc("fw3", calc_locs)["path"] + "/interpolate/CONTCAR_0")
struct_end = Structure.from_file(
get_calc_loc("fw3", calc_locs)["path"] + "/interpolate/CONTCAR_1")
struct_inter = Structure.from_file(
get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR")
structs = struct_start.interpolate(struct_end,
nimages,
interpolate_lattices=True,
autosort_tol=autosort_tol)
# Check x of 1st site.
self.assertAlmostEqual(structs[this_image][1].coords[0],
struct_inter[1].coords[0])
# Check c lattice parameter
self.assertAlmostEqual(structs[this_image].lattice.abc[0],
struct_inter.lattice.abc[0])
def snl_to_wf(snl, parameters=None):
fws = []
connections = defaultdict(list)
parameters = parameters if parameters else {}
snl_priority = parameters.get('priority', 1)
priority = snl_priority * 2 # once we start a job, keep going!
f = Composition(
snl.structure.composition.reduced_formula).alphabetical_formula
snl_spec = {}
if 'snlgroup_id' in parameters:
if 'mpsnl' in parameters:
snl_spec['mpsnl'] = parameters['mpsnl']
elif isinstance(snl, MPStructureNL):
snl_spec['mpsnl'] = snl.as_dict()
else:
raise ValueError("improper use of force SNL")
snl_spec['snlgroup_id'] = parameters['snlgroup_id']
else:
# add the SNL to the SNL DB and figure out duplicate group
tasks = [AddSNLTask()]
spec = {
'task_type': 'Add to SNL database',
'snl': snl.as_dict(),
'_queueadapter': QA_DB,
'_priority': snl_priority
}
fws.append(
Firework(tasks,
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=0))
connections[0] = [1]
trackers = [
Tracker('FW_job.out'),
Tracker('FW_job.error'),
Tracker('vasp.out'),
Tracker('OUTCAR'),
Tracker('OSZICAR'),
Tracker('OUTCAR.relax1'),
Tracker('OUTCAR.relax2')
]
trackers_db = [Tracker('FW_job.out'), Tracker('FW_job.error')]
# run GGA structure optimization
spec = _snl_to_spec(snl, enforce_gga=True, parameters=parameters)
spec.update(snl_spec)
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
spec['_trackers'] = trackers
tasks = [VaspWriterTask(), get_custodian_task(spec)]
fws.append(
Firework(tasks,
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=1))
# insert into DB - GGA structure optimization
spec = {
'task_type': 'VASP db insertion',
'_priority': priority * 2,
'_allow_fizzled_parents': True,
'_queueadapter': QA_DB,
"_dupefinder": DupeFinderDB().to_dict(),
'_trackers': trackers_db
}
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=2))
connections[1] = [2]
# determine if GGA+U FW is needed
incar = MPVaspInputSet().get_incar(snl.structure).as_dict()
ggau_compound = ('LDAU' in incar and incar['LDAU'])
if not parameters.get('skip_bandstructure', False) and (
not ggau_compound
or parameters.get('force_gga_bandstructure', False)):
spec = {
'task_type': 'Controller: add Electronic Structure v2',
'_priority': priority,
'_queueadapter': QA_CONTROL
}
fws.append(
Firework([AddEStructureTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=3))
connections[2] = [3]
if ggau_compound:
spec = _snl_to_spec(snl, enforce_gga=False, parameters=parameters)
del spec[
'vasp'] # we are stealing all VASP params and such from previous run
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
spec['_trackers'] = trackers
fws.append(
Firework(
[VaspCopyTask(),
SetupGGAUTask(),
get_custodian_task(spec)],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=10))
connections[2].append(10)
spec = {
'task_type': 'VASP db insertion',
'_queueadapter': QA_DB,
'_allow_fizzled_parents': True,
'_priority': priority,
"_dupefinder": DupeFinderDB().to_dict(),
'_trackers': trackers_db
}
fws.append(
Firework([VaspToDBTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=11))
connections[10] = [11]
if not parameters.get('skip_bandstructure', False):
spec = {
'task_type': 'Controller: add Electronic Structure v2',
'_priority': priority,
'_queueadapter': QA_CONTROL
}
fws.append(
Firework([AddEStructureTask()],
spec,
name=get_slug(f + '--' + spec['task_type']),
fw_id=12))
connections[11] = [12]
wf_meta = get_meta_from_structure(snl.structure)
wf_meta['run_version'] = 'May 2013 (1)'
if '_materialsproject' in snl.data and 'submission_id' in snl.data[
'_materialsproject']:
wf_meta['submission_id'] = snl.data['_materialsproject'][
'submission_id']
return Workflow(
fws,
connections,
name=Composition(
snl.structure.composition.reduced_formula).alphabetical_formula,
metadata=wf_meta)
