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.from_formula(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.to_dict, '_queueadapter': QA_DB, '_priority': snl_priority}
if 'snlgroup_id' in parameters and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.to_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)
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.from_formula(
snl.structure.composition.reduced_formula).alphabetical_formula, metadata=wf_meta)
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.from_formula(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.to_dict, '_queueadapter': QA_DB, '_priority': snl_priority}
if 'snlgroup_id' in parameters and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.to_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.from_formula(
snl.structure.composition.reduced_formula).alphabetical_formula, metadata=wf_meta)
def test_get_atoms(self):
if not aio.ase_loaded:
raise SkipTest("ASE not present. Skipping...")
p = Poscar.from_file(os.path.join(test_dir, 'POSCAR'))
structure = p.structure
atoms = aio.AseAtomsAdaptor.get_atoms(structure)
ase_composition = Composition.from_formula(atoms.get_name())
self.assertEqual(ase_composition, structure.composition)
def test_get_atoms(self):
if not aio.ase_loaded:
raise SkipTest("ASE not present. Skipping...")
p = Poscar.from_file(os.path.join(test_dir, 'POSCAR'))
structure = p.structure
atoms = aio.AseAtomsAdaptor.get_atoms(structure)
ase_composition = Composition.from_formula(atoms.get_name())
self.assertEqual(ase_composition, structure.composition)
def test_init(self):
filepath = os.path.join(test_dir, 'POSCAR')
poscar = Poscar.from_file(filepath)
comp = poscar.structure.composition
self.assertEqual(comp, Composition.from_formula("Fe4P4O16"))
#Vasp 4 type with symbols at the end.
poscar_string = """Test1
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
direct
0.000000 0.000000 0.000000 Si
0.750000 0.500000 0.750000 F"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.structure.composition, Composition.from_formula("SiF"))
#Vasp 4 tyle file with default names, i.e. no element symbol found.
poscar_string = """Test2
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
direct
0.000000 0.000000 0.000000
0.750000 0.500000 0.750000"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.structure.composition, Composition.from_formula("HHe"))
#Vasp 4 tyle file with default names, i.e. no element symbol found.
poscar_string = """Test3
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
Selective dynamics
direct
0.000000 0.000000 0.000000 T T T Si
0.750000 0.500000 0.750000 F F F O"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.selective_dynamics, [[True, True, True], [False, False, False]])
self.selective_poscar = poscar
def snl_to_wf(snl, do_bandstructure=True):
# TODO: clean this up once we're out of testing mode
# TODO: add WF metadata
fws = []
connections = {}
# add the SNL to the SNL DB and figure out duplicate group
tasks = [AddSNLTask()]
spec = {'task_type': 'Add to SNL database', 'snl': snl.to_dict}
fws.append(FireWork(tasks, spec, name=spec['task_type'], fw_id=0))
connections[0] = 1
# run GGA structure optimization
spec = _snl_to_spec(snl, enforce_gga=True)
tasks = [VaspWriterTask(), _get_custodian_task(spec)]
fws.append(FireWork(tasks, spec, name=spec['task_type'], fw_id=1))
# insert into DB - GGA structure optimization
spec = {'task_type': 'VASP db insertion', '_priority': 2,
'_allow_fizzled_parents': True}
spec.update(_get_metadata(snl))
fws.append(FireWork([VaspToDBTask()], spec, name=spec['task_type'], fw_id=2))
connections[1] = 2
if do_bandstructure:
spec = {'task_type': 'Controller: add Electronic Structure'}
spec.update(_get_metadata(snl))
fws.append(
FireWork([AddEStructureTask()], spec, name=spec['task_type'], fw_id=3))
connections[2] = 3
# determine if GGA+U FW is needed
incar = MPVaspInputSet().get_incar(snl.structure).to_dict
if 'LDAU' in incar and incar['LDAU']:
spec = {'task_type': 'GGA+U optimize structure (2x)',
'_dupefinder': DupeFinderVasp().to_dict()}
spec.update(_get_metadata(snl))
fws.append(FireWork(
[VaspCopyTask({'extension': '.relax2'}), SetupGGAUTask(),
_get_custodian_task(spec)], spec, name=spec['task_type'], fw_id=10))
connections[2].append(10)
spec = {'task_type': 'VASP db insertion',
'_allow_fizzled_parents': True}
spec.update(_get_metadata(snl))
fws.append(
FireWork([VaspToDBTask()], spec, name=spec['task_type'], fw_id=11))
connections[10] = 11
if do_bandstructure:
spec = {'task_type': 'Controller: add Electronic Structure'}
spec.update(_get_metadata(snl))
fws.append(FireWork([AddEStructureTask()], spec, name=spec['task_type'], fw_id=12))
connections[11] = 12
return Workflow(fws, connections, name=Composition.from_formula(snl.structure.composition.reduced_formula).alphabetical_formula)
def test_init(self):
filepath = os.path.join(test_dir, 'POSCAR')
poscar = Poscar.from_file(filepath)
comp = poscar.structure.composition
self.assertEqual(comp, Composition.from_formula("Fe4P4O16"))
#Vasp 4 type with symbols at the end.
poscar_string = """Test1
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
direct
0.000000 0.000000 0.000000 Si
0.750000 0.500000 0.750000 F
"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.structure.composition, Composition("SiF"))
#Vasp 4 tyle file with default names, i.e. no element symbol found.
poscar_string = """Test2
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
direct
0.000000 0.000000 0.000000
0.750000 0.500000 0.750000
"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.structure.composition, Composition("HHe"))
#Vasp 4 tyle file with default names, i.e. no element symbol found.
poscar_string = """Test3
1.0
3.840198 0.000000 0.000000
1.920099 3.325710 0.000000
0.000000 -2.217138 3.135509
1 1
Selective dynamics
direct
0.000000 0.000000 0.000000 T T T Si
0.750000 0.500000 0.750000 F F F O
"""
poscar = Poscar.from_string(poscar_string)
self.assertEqual(poscar.selective_dynamics, [[True, True, True],
[False, False, False]])
self.selective_poscar = poscar
def task_dict_to_wf(task_dict, launchpad):
fw_id = launchpad.get_new_fw_id()
l_id = launchpad.get_new_launch_id()
spec = {'task_type': task_dict['task_type'], 'run_tags': task_dict['run_tags'],
'vaspinputset_name': None, 'vasp': None, 'mpsnl': task_dict['snl'],
'snlgroup_id': task_dict['snlgroup_id']}
tasks = [DummyLegacyTask()]
launch_dir = task_dict['dir_name_full']
stored_data = {'error_list': []}
update_spec = {'prev_vasp_dir': task_dict['dir_name'],
'prev_task_type': spec['task_type'],
'mpsnl': spec['mpsnl'], 'snlgroup_id': spec['snlgroup_id'],
'run_tags': spec['run_tags']}
fwaction = FWAction(stored_data=stored_data, update_spec=update_spec)
if task_dict['completed_at']:
complete_date = datetime.datetime.strptime(task_dict['completed_at'], "%Y-%m-%d %H:%M:%S")
state_history = [{"created_on": complete_date, 'state': 'COMPLETED'}]
else:
state_history = []
launches = [Launch('COMPLETED', launch_dir, fworker=None, host=None, ip=None, action=fwaction,
state_history=state_history, launch_id=l_id, fw_id=fw_id)]
f = Composition.from_formula(task_dict['pretty_formula']).alphabetical_formula
fw = FireWork(tasks, spec, name=get_slug(f + '--' + spec['task_type']), launches=launches, state='COMPLETED', created_on=None,
fw_id=fw_id)
wf_meta = get_meta_from_structure(Structure.from_dict(task_dict['snl']))
wf_meta['run_version'] = 'preproduction (0)'
wf = Workflow.from_FireWork(fw, name=f, metadata=wf_meta)
launchpad.add_wf(wf, reassign_all=False)
launchpad._upsert_launch(launches[0])
print 'ADDED', fw_id
# return fw_id
return fw_id
def get_meta_from_structure(structure):
# TODO: this won't work for molecules
meta = {}
meta['nsites'] = len(structure.sites)
meta['elements'] = list(set([el.symbol for el in structure.composition.elements]))
meta['nelements'] = len(meta['elements'])
meta['formula'] = structure.composition.formula
meta['formula_red'] = structure.composition.reduced_formula
meta['formula_abc_red'] = Composition.from_formula(structure.composition.reduced_formula).alphabetical_formula
meta['composition_dict'] = structure.composition.to_dict
meta['anonymized_formula'] = structure.composition.anonymized_formula
meta['chemsystem'] = '-'.join(sorted(list(set([e.symbol for e in structure.composition.elements])))) # the complex logic set/list is to prevent duplicates if there are multiple oxidation states
meta['is_ordered'] = structure.is_ordered
#promixity warning:
meta['proximity_warning'] = False
for (s1, s2) in itertools.combinations(structure._sites, 2):
if s1.distance(s2) < Structure.DISTANCE_TOLERANCE:
meta['proximity_warning'] = True
return meta
def test_init(self):
filepath = os.path.join(test_dir, 'input/23221-ZDsSsJoEW14.res')
res = Res.from_file(filepath)
comp = res.structure.composition
self.assertEqual(comp, Composition.from_formula("C194H60"))
#print res
res_string = """TITL
CELL 1.0 1.0 1.0 1.0 90.0 90.0 90.0
LATT -1
SFAC Si F
Si 1 0.000000 0.000000 0.000000 1.0
F 2 0.750000 0.500000 0.750000 1.0"""
res = Res.from_string(res_string)
self.assertEqual(res.structure.composition, Composition("SiF"))
self.assertEquals(res.structure.num_sites, 2)
#print res
struct = Structure(Lattice.orthorhombic(2.5, 3.5, 7.0), ['Na', 'Cl'], [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
res = Res(struct)
res_string = str(res)
lines = res_string.splitlines()
self.assertEqual(lines[1], "CELL 1.0 2.5 3.5 7.0 90.0 90.0 90.0")
def snl_to_wf_ggau(snl):
# TODO: add WF meta
fws = []
connections = {}
# add the root FW (GGA+U)
spec = _snl_to_spec(snl, enforce_gga=False)
tasks = [VaspWriterTask(), _get_custodian_task(spec)]
fws.append(FireWork(tasks, spec, fw_id=1))
# add GGA insertion to DB
spec = {'task_type': 'VASP db insertion', '_priority': 2,
'_category': 'VASP'}
spec.update(_get_metadata(snl))
fws.append(FireWork([VaspToDBTask()], spec, fw_id=2))
connections[1] = 2
mpvis = MPVaspInputSet()
spec['vaspinputset_name'] = mpvis.__class__.__name__
return Workflow(fws, connections, name=Composition.from_formula(snl.structure.composition.reduced_formula).alphabetical_formula)
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.from_formula(
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(),
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'}),
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'}),
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
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)
return FWAction()
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']
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)
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']}
snl = StructureNL.from_dict(spec['mpsnl'])
spec['run_tags'].append(unconverged_tag)
spec['_queueadapter'] = QA_VASP
fws = []
connections = {}
f = Composition.from_formula(
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'])}
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 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.from_formula(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}
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}
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}
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 snl_to_wf(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.from_formula(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.to_dict, '_queueadapter': QA_DB, '_priority': snl_priority}
if 'snlgroup_id' in parameters and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.to_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
spec = _snl_to_spec(snl, enforce_gga=True)
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
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]
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=3))
connections[2] = [3]
# determine if GGA+U FW is needed
incar = MPVaspInputSet().get_incar(snl.structure).to_dict
if 'LDAU' in incar and incar['LDAU']:
spec = _snl_to_spec(snl, enforce_gga=False)
del spec['vasp'] # we are stealing all VASP params and such from previous run
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
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}
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.from_formula(
snl.structure.composition.reduced_formula).alphabetical_formula, metadata=wf_meta)
def test_to_from_dict(self):
d = self.vinput.to_dict
vinput = VaspInput.from_dict(d)
comp = vinput["POSCAR"].structure.composition
self.assertEqual(comp, Composition.from_formula("Fe4P4O16"))
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']
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)
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']
}
snl = StructureNL.from_dict(spec['mpsnl'])
spec['run_tags'].append(unconverged_tag)
spec['_queueadapter'] = QA_VASP
fws = []
connections = {}
f = Composition.from_formula(
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'])
}
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 test_to_from_dict(self):
d = self.vinput.to_dict
vinput = VaspInput.from_dict(d)
comp = vinput["POSCAR"].structure.composition
self.assertEqual(comp, Composition.from_formula("Fe4P4O16"))
def snl_to_wf(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.from_formula(
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.to_dict,
'_queueadapter': QA_DB,
'_priority': snl_priority
}
if 'snlgroup_id' in parameters and isinstance(snl, MPStructureNL):
spec['force_mpsnl'] = snl.to_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
spec = _snl_to_spec(snl, enforce_gga=True)
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
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]
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=3))
connections[2] = [3]
# determine if GGA+U FW is needed
incar = MPVaspInputSet().get_incar(snl.structure).to_dict
if 'LDAU' in incar and incar['LDAU']:
spec = _snl_to_spec(snl, enforce_gga=False)
del spec[
'vasp'] # we are stealing all VASP params and such from previous run
spec['_priority'] = priority
spec['_queueadapter'] = QA_VASP
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
}
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.from_formula(
snl.structure.composition.reduced_formula).alphabetical_formula,
metadata=wf_meta)
