def static(structure_file, functional, directory, write_chgcar, in_custodian,
number_nodes, launchpad_file, lpad_name):
"""
Set up an static calculation workflow.
"""
from pybat.workflow.workflows import get_wf_static
# Process the input options
if number_nodes == 0:
number_nodes = None
functional = string_to_functional(functional)
# Set up the calculation directory
directory = set_up_directory(directory, functional, "static")
cat = Cathode.from_file(structure_file)
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
lpad.add_wf(
get_wf_static(structure=cat,
functional=functional,
directory=directory,
write_chgcar=write_chgcar,
in_custodian=in_custodian,
number_nodes=number_nodes))
def optimize(structure_file, functional, directory, is_metal, in_custodian,
number_nodes, launchpad_file, lpad_name):
"""
Set up a geometry optimization workflow.
"""
from pybat.workflow.workflows import get_wf_optimize
cat = Cathode.from_file(structure_file)
# Process the input options
if number_nodes == 0:
number_nodes = None
functional = string_to_functional(functional)
# Set up the calculation directory
directory = set_up_directory(directory, functional, "optimize")
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
lpad.add_wf(
get_wf_optimize(structure=cat,
functional=functional,
directory=directory,
is_metal=is_metal,
in_custodian=in_custodian,
number_nodes=number_nodes))
def _get_launchpad(submission_script='FW_submit.script'):
'''
This function assumes that you're in a directory where a "FW_submit.script"
exists and contains the location of your launchpad.yaml file. It then uses
this yaml file to instantiate a LaunchPad object for you.
Arg:
submission_script String indicating the path of the job submission
script used to launch this firework. It should
contain an `rlaunch` command in it.
Returns:
lpad A configured and authenticated `fireworks.LaunchPad` object
'''
# Look for the line in the submission script that has `rlaunch`
with open(submission_script, 'r') as file_handle:
for line in file_handle.readlines():
if line.startswith('rlaunch'):
break
# The line with `rlaunch` should also have the location of the launchpad
words = line.split(' ')
for i, word in enumerate(words):
if word == '-l':
lpad_file = words[i + 1]
break
# Instantiate the lpad with the yaml and return it
lpad = LaunchPad.from_file(lpad_file)
return lpad
def setUp(self, lpad=True):
"""
Create scratch directory(removes the old one if there is one) and change to it.
Also initialize launchpad.
"""
if not SETTINGS.get("PMG_VASP_PSP_DIR"):
SETTINGS["PMG_VASP_PSP_DIR"] = os.path.abspath(
os.path.join(MODULE_DIR, "..", "vasp", "test_files"))
print(
'This system is not set up to run VASP jobs. '
'Please set PMG_VASP_PSP_DIR variable in your ~/.pmgrc.yaml file.'
)
self.scratch_dir = os.path.join(MODULE_DIR, "scratch")
if os.path.exists(self.scratch_dir):
shutil.rmtree(self.scratch_dir)
os.makedirs(self.scratch_dir)
os.chdir(self.scratch_dir)
if lpad:
try:
self.lp = LaunchPad.from_file(
os.path.join(DB_DIR, "my_launchpad.yaml"))
self.lp.reset("", require_password=False)
except:
raise unittest.SkipTest(
'Cannot connect to MongoDB! Is the database server running? '
'Are the credentials correct?')
def __init__(self, *args, **kwargs):
'''
:param args: (VaspFirework objects) objects to create Workflow from. No limit
on the amount of VaspInputInterface objects to be given. Entered as just
comma separated objects passed to class.
:param deps_dict: (dict) specifies the dependency of the VaspInputInterface objects given.
If no dependency is given, Firworks are assumed to be
sequentially dependent.
:param name (str) Name given to Workflow
'''
self.fws = []
self.name = kwargs.get('name', 'Sequential WF')
self.deps_dict = kwargs.get('deps_dict', {})
self.dependency = {}
if self.deps_dict:
for i in self.deps_dict.keys():
fw_deps = []
for j in self.deps_dict[i]:
fw_deps.append(j.Firework)
self.dependency[i.Firework]=fw_deps
self.deps = True if self.dependency else False
for id, fw_task in enumerate(args):
self.fws.append(fw_task.Firework)
if not self.deps and id != 0:
self.dependency[self.fws[id-1]]=[fw_task.Firework]
self.wf = Workflow(self.fws, self.dependency, name=self.name)
# Try to establish connection with Launchpad
try:
self.LaunchPad=LaunchPad.from_file(os.path.join(os.environ["HOME"], ".fireworks", "my_launchpad.yaml"))
except:
self.LaunchPad = None
def dimer(structure_file, dimer_indices, distance, functional, is_metal,
in_custodian, number_nodes, launchpad_file, lpad_name):
"""
Set up dimer calculation workflows.
"""
from pybat.workflow.workflows import get_wf_dimer
cat = LiRichCathode.from_file(structure_file)
# Process the input options
if number_nodes == 0:
number_nodes = None
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
lpad.add_wf(
get_wf_dimer(structure=cat,
dimer_indices=dimer_indices,
distance=distance,
functional=string_to_functional(functional),
is_metal=is_metal,
in_custodian=in_custodian,
number_nodes=number_nodes))
def __init__(self,vasp_task=None,name='vaspfw',handlers=None, handler_params=None, config_file=None):
self.name = name
self.handlers=handlers if handlers else []
self.handler_params=handler_params if handler_params else {}
if config_file:
config_dict = loadfn(config_file)
elif os.path.exists(os.path.join(os.environ['HOME'], 'vasp_interface_defaults.yaml')):
config_dict = loadfn(os.path.join(os.environ['HOME'], 'vasp_interface_defaults.yaml'))
else:
config_dict = {}
if config_dict:
self.custodian_opts = config_dict.get('CUSTODIAN_PARAMS', {})
if self.custodian_opts.get('handlers', []):
self.handlers.extend(self.custodian_opts.get('handlers', []))
self.handler_params.update(self.custodian_opts.get('handler_params', {}))
self.tasks=[vasp_task.input,RunCustodianTask(handlers=self.handlers,
handler_params=self.handler_params)] if isinstance(vasp_task,
VaspInputInterface) else [vasp_task]
self.Firework=Firework(self.tasks,name=self.name)
# Try to establish connection with Launchpad
try:
self.LaunchPad=LaunchPad.from_file(os.path.join(os.environ["HOME"], ".fireworks", "my_launchpad.yaml"))
except:
self.LaunchPad = None
def load_config(config, name="base"):
"""
Load a LaunchPad, FWorker of QueueAdapter from the configuration files.
Args:
config (str): Type of configuration file to load. Either "launchpad", "fworker"
or "qadapter".
name (str): Name of the configuration. Defaults to "base".
Returns:
Either a LaunchPad, FWorker or QueuAdapter, depending on the "config" argument.
"""
try:
if config == "launchpad":
return LaunchPad.from_file(
os.path.join(os.path.expanduser("~"), ".workflow_config",
"launchpad", name + "_launchpad.yaml"))
if config == "fworker":
return FWorker.from_file(
os.path.join(os.path.expanduser("~"), ".workflow_config",
"fworker", name + "_fworker.yaml"))
if config == "qadapter":
return CommonAdapter.from_file(
os.path.join(os.path.expanduser("~"), ".workflow_config",
"fworker", name + "_qadapter.yaml"))
except FileNotFoundError:
raise FileNotFoundError(
"Did not find the corresponding configuration file in " +
os.path.join(os.path.expanduser("~"), ".workflow_config") +
". Use 'vsc config " + config + "' to set up the " + name +
" configuration for the " + config + ".")
def get_launchpad(launchpad_file=None):
"""
Returns a LaunchPad object. If the launchpad_file is None, then try to auto load from environment
Args:
launchpad_file (File-like): A file-like or file path to the LaunchPad file.
Returns:
LaunchPad
"""
if launchpad_file:
if isinstance(launchpad_file, file):
# a file object was found
ext = launchpad_file.name.split('.')[-1]
if ext == 'yaml':
launchpad = LaunchPad.from_format(launchpad_file.read(),
f_format='yaml')
else:
# assume json
launchpad = LaunchPad.from_format(launchpad_file.read())
else:
# assume launchpad_file is a path
launchpad = LaunchPad.from_file(launchpad_file)
else:
launchpad = LaunchPad.auto_load()
return launchpad
def launch():
descr = "Smart rocket launcher."\
"Uses the execution termination emails send by the batch system to "\
"launch fireworks that depend on other fireworks i.e fireworks that "\
"have 'cal_objs' in their spec."\
"Takes in fw_ids of fireworks to be launched. "\
"Range specification of fw_ids is also supported."\
"All the jobs are launched to hipergator remotely using fabric."\
"Note: Ensure that the submit scripts have the appropriate email settings and "\
"that the mail daemon is fetching emails to the folder polled by this script."\
"Note: All rocket launches take place in the home directory. If "\
"_launch_dir spec is set for the firework the job files will be written to "\
"that folder and jobs to the batch system will be done from there."
parser = ArgumentParser(description=descr)
parser.add_argument('-f', '--fw_ids', help='one or more of fw_ids to run',
default=None, type=int, nargs='+')
parser.add_argument('-r', '--r_fw_ids',
help='start and end fw_ids of the range of fw_ids to run',
default=None, type=int, nargs=2)
args = parser.parse_args()
fw_ids = args.fw_ids
if args.r_fw_ids is not None:
fw_ids += range(args.r_fw_ids[0], args.r_fw_ids[1])
job_ids = None
lp = LaunchPad.from_file(LAUNCHPAD_LOC)
print('Firework ids: ',fw_ids)
if fw_ids is None:
print('No fw ids given')
return
for fid in fw_ids:
m_fw = lp._get_a_fw_to_run(fw_id=fid, checkout=False)
if m_fw is None:
print('No firework with that id')
return
fw_spec = dict(m_fw.spec)
done = []
if fw_spec.get('cal_objs',None) is not None:
for calparams in fw_spec['cal_objs']:
if calparams.get('job_ids', None) is not None:
job_ids = calparams.get('job_ids', None)
print(fid,' depends on jobs with ids : ',job_ids)
if job_ids is not None:
for jid in job_ids:
done.append(check_done(jid))
else:
print('job_ids not set')
else:
print('This firework doesnt depend on any other fireworks.')
done.append(True)
if done and all(done):
print('Launching ', fid, ' ...')
with settings(host_string='*****@*****.**'):
run("ssh dev1 rlaunch singleshot -f "+str(fid))
else:
print("Haven't recieved execution termination confirmation for the jobs in the firework from hipergator resource manager")
time.sleep(3)
return
def no_connection(self):
"""Check for connection to local MongoDB."""
try:
lp = LaunchPad.from_file(os.path.join(DB_DIR, "my_launchpad.yaml"))
lp.reset("", require_password=False)
return False
except:
return True
def setUp(self):
if os.path.exists(self.scratch_dir):
shutil.rmtree(self.scratch_dir)
os.makedirs(self.scratch_dir)
os.chdir(self.scratch_dir)
try:
self.lp = LaunchPad.from_file(os.path.join(db_dir, "my_launchpad.yaml"))
self.lp.reset("", require_password=False)
except:
raise unittest.SkipTest(
'Cannot connect to MongoDB! Is the database server running? '
'Are the credentials correct?')
def launchpad(launchpad_file=None, lpad_name="base"):
"""
Script to set up the configuration of the launchpad for accessing the workflow
server.
Args:
launchpad_file (str): my_launchpad.yaml file from which to load the
mongoDB database details.
lpad_name (str): Name to give to the database in the configuration setup.
Returns:
None
"""
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
host = input("Please provide the server host: ")
port = int(input("Please provide the port number: "))
name = input("Please provide the server name: ")
username = input("Please provide your username: "******"Please provide your password: "******"admin")
# Test the launchpad
print("\nAttempting connection to mongoDB database...")
_ = lpad.get_fw_ids()
print("Connection successful!\n")
config_lpad_file = os.path.join(os.path.expanduser("~"),
".workflow_config", "launchpad",
lpad_name + "_launchpad.yaml")
try:
os.makedirs(
os.path.join(os.path.expanduser("~"), ".workflow_config",
"launchpad"))
except FileExistsError:
pass
lpad.to_file(config_lpad_file)
print("Launchpad file written to " + config_lpad_file + "\n")
def neb(directory, nimages, functional, is_metal, in_custodian, number_nodes,
launchpad_file, lpad_name):
"""
Set up dimer calculation workflows.
"""
from pybat.workflow.workflows import get_wf_neb
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
lpad.add_wf(
get_wf_neb(directory=directory,
nimages=nimages,
functional=string_to_functional(functional),
is_metal=is_metal,
in_custodian=in_custodian,
number_nodes=number_nodes))
def noneq_dimers(structure_file, distance, functional, is_metal, in_custodian,
number_nodes, launchpad_file, lpad_name):
"""
Set up dimer calculations for all nonequivalent dimers in a structure.
"""
from pybat.workflow.workflows import get_wfs_noneq_dimers
cat = LiRichCathode.from_file(structure_file)
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
for wf in get_wfs_noneq_dimers(structure=cat,
distance=distance,
functional=string_to_functional(functional),
is_metal=is_metal,
in_custodian=in_custodian,
number_nodes=number_nodes):
lpad.add_wf(wf)
def setUp(self, lpad=True):
"""
Create scratch directory(removes the old one if there is one) and change to it.
Also initialize launchpad.
"""
if not SETTINGS.get("PMG_VASP_PSP_DIR"):
SETTINGS["PMG_VASP_PSP_DIR"] = os.path.abspath(os.path.join(MODULE_DIR, "..", "vasp", "test_files"))
print('This system is not set up to run VASP jobs. '
'Please set PMG_VASP_PSP_DIR variable in your ~/.pmgrc.yaml file.')
self.scratch_dir = os.path.join(MODULE_DIR, "scratch")
if os.path.exists(self.scratch_dir):
shutil.rmtree(self.scratch_dir)
os.makedirs(self.scratch_dir)
os.chdir(self.scratch_dir)
if lpad:
try:
self.lp = LaunchPad.from_file(os.path.join(DB_DIR, "my_launchpad.yaml"))
self.lp.reset("", require_password=False)
except:
raise unittest.SkipTest('Cannot connect to MongoDB! Is the database server running? '
'Are the credentials correct?')
def launch():
descr = "Smart rocket launcher."\
"Uses the execution termination emails send by the batch system to "\
"launch fireworks that depend on other fireworks i.e fireworks that "\
"have 'cal_objs' in their spec."\
"Takes in fw_ids of fireworks to be launched. "\
"Range specification of fw_ids is also supported."\
"All the jobs are launched to hipergator remotely using fabric."\
"Note: Ensure that the submit scripts have the appropriate email settings and "\
"that the mail daemon is fetching emails to the folder polled by this script."\
"Note: All rocket launches take place in the home directory. If "\
"_launch_dir spec is set for the firework the job files will be written to "\
"that folder and jobs to the batch system will be done from there."
parser = ArgumentParser(description=descr)
parser.add_argument('-f',
'--fw_ids',
help='one or more of fw_ids to run',
default=None,
type=int,
nargs='+')
parser.add_argument(
'-r',
'--r_fw_ids',
help='start and end fw_ids of the range of fw_ids to run',
default=None,
type=int,
nargs=2)
args = parser.parse_args()
fw_ids = args.fw_ids
if args.r_fw_ids is not None:
fw_ids += range(args.r_fw_ids[0], args.r_fw_ids[1])
job_ids = None
lp = LaunchPad.from_file(LAUNCHPAD_LOC)
print('Firework ids: ', fw_ids)
if fw_ids is None:
print('No fw ids given')
return
for fid in fw_ids:
m_fw = lp._get_a_fw_to_run(fw_id=fid, checkout=False)
if m_fw is None:
print('No firework with that id')
return
fw_spec = dict(m_fw.spec)
done = []
if fw_spec.get('cal_objs', None) is not None:
for calparams in fw_spec['cal_objs']:
if calparams.get('job_ids', None) is not None:
job_ids = calparams.get('job_ids', None)
print(fid, ' depends on jobs with ids : ', job_ids)
if job_ids is not None:
for jid in job_ids:
done.append(check_done(jid))
else:
print('job_ids not set')
else:
print('This firework doesnt depend on any other fireworks.')
done.append(True)
if done and all(done):
print('Launching ', fid, ' ...')
with settings(host_string='*****@*****.**'):
run("ssh dev1 rlaunch singleshot -f " + str(fid))
else:
print(
"Haven't recieved execution termination confirmation for the jobs in the firework from hipergator resource manager"
)
time.sleep(3)
return
def configuration(structure_file, functional, sub_sites, element_list, sizes,
directory, include_existing, conc_restrict, max_conf,
in_custodian, number_nodes, launchpad_file, lpad_name):
"""
Set up a workflow for a set of configurations.
Calculate the geometry and total energy of a set of configurations. The
configurations can be specified using the various options. In case some required
input is not specified during command execution, it will be requested from the user.
"""
from pybat.workflow.workflows import get_wf_configurations
cat = Cathode.from_file(structure_file)
# Set up the directory
if directory == "":
directory = os.getcwd()
directory = os.path.abspath(directory)
# Process the option input
try:
substitution_sites = eval(sub_sites)
except SyntaxError:
substitution_sites = [int(site) for site in sub_sites.split(" ")]
try:
element_list = eval(element_list)
except SyntaxError:
element_list = [el for el in element_list.split(" ")]
try:
sizes = [int(i) for i in sizes.strip("[]").split(",")]
except ValueError:
sizes = eval(sizes)
try:
conc_restrict = eval(conc_restrict)
except TypeError:
conc_restrict = None
# In case some required settings are missing, request them
if not substitution_sites:
print(cat)
print()
substitution_sites = [
int(i) for i in input(
"Please provide the substitution site indices, separated by a space: "
).split(" ")
]
if not element_list:
element_list = [
i for i in input(
"Please provide the substitution elements, separated by a space: "
).split(" ")
]
if not sizes:
sizes = [
int(i) for i in input(
"Please provide the possible unit cell sizes, separated by a space: "
).split(" ")
]
if launchpad_file:
lpad = LaunchPad.from_file(launchpad_file)
else:
lpad = _load_launchpad(lpad_name)
lpad.add_wf(
get_wf_configurations(structure=cat,
substitution_sites=substitution_sites,
element_list=element_list,
sizes=sizes,
concentration_restrictions=conc_restrict,
max_configurations=max_conf,
functional=string_to_functional(functional),
directory=directory,
include_existing=include_existing,
in_custodian=in_custodian,
number_nodes=number_nodes))
def test_dict_from_file(self):
lp = LaunchPad.from_file(self.LP_LOC)
lp_dict = lp.to_dict()
new_lp = LaunchPad.from_dict(lp_dict)
self.assertIsInstance(new_lp, LaunchPad)
from MultiFil_edu.settings.environ import FIREWORKS_LAUNCHPAD_FILE
__author__ = 'Ziqin (Shaun) Rong'
__version__ = '0.1'
__maintainer__ = 'Ziqin (Shaun) Rong'
__email__ = '*****@*****.**'
if __name__ == '__main__':
# Parameters
moving_cation = Element('Mg')
calculated_images = [0, 4] # This is 1st phase screening
# calculated_images = range(0, 9) # This is 2nd phase MEP calculation
input_file = 'Mg_approx_neb_example.txt'
collection_name = 'Mg_MV'
lp = LaunchPad.from_file(FIREWORKS_LAUNCHPAD_FILE)
wf_idx = []
with open(input_file, 'r') as f:
data = f.readlines()
for i, content in enumerate(data):
data[i] = content.split()
for doc in data:
wf_idx.append((
doc[0],
int(doc[1]),
))
'KPOINTS': [k for k in range(20, 30, 10)]
}
job_dir = 'calBulk'
job_cmd = ['mpirun', '/home/km468/Software/VASP/vasp.5.3.5/vasp']
qparams= dict(nnodes='1', ppnode='16',
job_name='vasp_job', pmem='1000mb',
walltime='24:00:00',
rocket_launch=''.join(job_cmd))
# set qadapter to None to launch via qlaunch
# reserve and launch offline
# qlaunch -r singleshot
# lpad recover_offline
qadapter = None #CommonAdapter(q_type="PBS",**qparams)
cal = Calibrate(incar, poscar, potcar, kpoints,
turn_knobs = turn_knobs,
qadapter = qadapter,
job_dir = job_dir, job_cmd=job_cmd)
caltask = MPINTCalibrateTask(cal.as_dict())
#firework with launch directory set to $FW_JOB_DIR, an environment variable
#spec={'_launch_dir':'$FW_JOB_DIR'},
fw_calibrate = Firework([caltask],
name="fw_test")
wf = Workflow([fw_calibrate], name="mpint_wf_test")
lp = LaunchPad.from_file(LAUNCHPAD_LOC)
print('fireworks in the database before adding the workflow: \n',
lp.get_fw_ids())
lp.add_wf(wf)
print('fireworks in the database: \n', lp.get_fw_ids())
.. codeauthor:: Michele Galasso <*****@*****.**>
"""
import numpy as np
from copy import copy
from ase.io import read
from typing import Union
from itertools import product
from fireworks import LaunchPad, Firework, Workflow
from common.utilities import atoms_to_encode, VaspCalculationTask, WriteOutputTask, WriteChargesTask
# substitute with your launchpad file
launchpad = LaunchPad.from_file('/home/mgalasso/.fireworks/my_launchpad.yaml')
class SubmitFirework(object):
def __init__(self,
poscar_file: str,
mode: str,
fix_params: dict,
magmoms: list,
encut_values: Union[list, range] = None,
sigma_values: Union[list, range] = None,
kpts_values: Union[list, range] = None,
pert_values: Union[list, range] = None,
setting: int = None,
dummy_atom: str = None,
dummy_position: int = None):
def test_dict_from_file(self):
lp = LaunchPad.from_file(self.LP_LOC)
lp_dict = lp.to_dict()
new_lp = LaunchPad.from_dict(lp_dict)
self.assertIsInstance(new_lp, LaunchPad)
structure (Structure): input structure to be optimized and run
vasp_cmd (str): command to run
db_file (str): path to file containing the database credentials.
Returns:
Workflow
"""
fws = []
fws.append(StaticFW(structure=structure, vasp_cmd=vasp_cmd, db_file=db_file))
fws.append(NonSCFFW(structure=structure, vasp_cmd=vasp_cmd, db_file=db_file, parents=fws[0]))
fws.append(BandGapCheckFW(structure=structure, parents=fws[1]))
fws.append(InterpolateFW(structure=structure, parents=fws[2]))
wfname = "{}:{}".format(structure.composition.reduced_formula, "dipole_moment")
return Workflow(fws, name=wfname)
if __name__ == "__main__":
from pymatgen.util.testing import PymatgenTest
from matmethods.vasp.workflows.presets.core import wf_ferroelectric
structure = PymatgenTest.get_structure("Si")
# wf = get_wf_ferroelectric(structure)
my_wf = wf_ferroelectric(structure)
# lp = LaunchPad()
lp = LaunchPad.from_file(os.path.join("/global/homes/s/sbajaj/mm_installdir/config", "my_launchpad.yaml"))
lp.reset('', require_password=False)
lp.add_wf(my_wf)