def __init__(
self,
parents=None,
prev_calc_dir=None,
structure=None,
mode="gap",
name=None,
vasp_cmd=VASP_CMD,
db_file=DB_FILE,
**kwargs,
):
"""
For getting a more accurate band gap or a full band structure with HSE - requires previous
calculation that gives VBM/CBM info or the high-symmetry kpoints.
Args:
parents (Firework): Parents of this particular Firework. FW or list of FWS.
prev_calc_dir (str): Path to a previous calculation to copy from
structure (Structure): Input structure - used only to set the name of the FW.
mode (string): options:
"line" to get a full band structure along symmetry lines or
"uniform" for uniform mesh band structure or
"gap" to get the energy at the CBM and VBM
name (str): Name for the Firework.
vasp_cmd (str): Command to run vasp.
db_file (str): Path to file specifying db credentials.
**kwargs: Other kwargs that are passed to Firework.__init__.
"""
name = name if name else "{} {}".format("hse", mode)
fw_name = "{}-{}".format(
structure.composition.reduced_formula if structure else "unknown",
name)
t = []
if prev_calc_dir:
t.append(
CopyVaspOutputs(calc_dir=prev_calc_dir,
additional_files=["CHGCAR"]))
elif parents:
t.append(
CopyVaspOutputs(calc_loc=True, additional_files=["CHGCAR"]))
else:
raise ValueError("Must specify a previous calculation for HSEBSFW")
t.append(WriteVaspHSEBSFromPrev(prev_calc_dir=".", mode=mode))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
t.append(PassCalcLocs(name=name))
parse_dos = True if mode == "uniform" else False
bandstructure_mode = mode if mode in ["line", "uniform"] else "line"
t.append(
VaspToDb(
db_file=db_file,
additional_fields={"task_label": name},
parse_dos=parse_dos,
bandstructure_mode=bandstructure_mode,
))
super().__init__(t, parents=parents, name=fw_name, **kwargs)
def __init__(self, structure=None, prev_calc_dir=None, name="static dielectric", vasp_cmd=VASP_CMD,
copy_vasp_outputs=True, lepsilon=True,
db_file=DB_FILE, parents=None, user_incar_settings=None,
pass_nm_results=False, **kwargs):
"""
Static DFPT calculation Firework
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
name (str): Name for the Firework.
lepsilon (bool): Turn on LEPSILON to calculate polar properties
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (str or bool): Whether to copy outputs from previous
run. Defaults to True.
prev_calc_dir (str): Path to a previous calculation to copy from
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
user_incar_settings (dict): Parameters in INCAR to override
pass_nm_results (bool): if true the normal mode eigen vals and vecs are passed so that
next firework can use it.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
name = "static dielectric" if lepsilon else "phonon"
fw_name = "{}-{}".format(structure.composition.reduced_formula if structure else "unknown", name)
user_incar_settings = user_incar_settings or {}
t = []
if prev_calc_dir:
t.append(CopyVaspOutputs(calc_dir=prev_calc_dir, contcar_to_poscar=True))
t.append(WriteVaspStaticFromPrev(lepsilon=lepsilon, other_params={
'user_incar_settings': user_incar_settings, 'force_gamma': True}))
elif parents and copy_vasp_outputs:
t.append(CopyVaspOutputs(calc_loc=True, contcar_to_poscar=True))
t.append(WriteVaspStaticFromPrev(lepsilon=lepsilon, other_params={
'user_incar_settings': user_incar_settings, 'force_gamma': True}))
elif structure:
vasp_input_set = MPStaticSet(structure, lepsilon=lepsilon, force_gamma=True,
user_incar_settings=user_incar_settings)
t.append(WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
else:
raise ValueError("Must specify structure or previous calculation")
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
if pass_nm_results:
t.append(pass_vasp_result({"structure": "a>>final_structure",
"eigenvals": "a>>normalmode_eigenvals",
"eigenvecs": "a>>normalmode_eigenvecs"},
parse_eigen=True,
mod_spec_key="normalmodes"))
t.append(PassCalcLocs(name=name))
t.append(VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(DFPTFW, self).__init__(t, parents=parents, name=fw_name, **kwargs)
def use_custodian(original_wf, fw_name_constraint=None, custodian_params=None):
"""
Replaces all tasks with "RunVasp*" (e.g. RunVaspDirect) to be RunVaspCustodian. Thus, this
powerup adds error correction into VASP runs if not originally present and/or modifies
the correction behavior.
Args:
original_wf (Workflow): original workflow
fw_name_constraint (str): Only apply changes to FWs where fw_name contains this substring.
For example, use custodian only for certain runs, or set job_type to
"double_relaxation_run" only for structure optimization run, or set different
handler_group for different runs.
custodian_params (dict): A dict of parameters for RunVaspCustodian. e.g., use it to set
a "scratch_dir" or "handler_group".
Returns:
Workflow
"""
custodian_params = custodian_params if custodian_params else {}
vasp_fws_and_tasks = get_fws_and_tasks(
original_wf,
fw_name_constraint=fw_name_constraint,
task_name_constraint="RunVasp")
for idx_fw, idx_t in vasp_fws_and_tasks:
if "vasp_cmd" not in custodian_params:
custodian_params["vasp_cmd"] = original_wf.fws[idx_fw].tasks[
idx_t]["vasp_cmd"]
original_wf.fws[idx_fw].tasks[idx_t] = \
RunVaspCustodian(**custodian_params)
return original_wf
def __init__(self,
structure,
name="structure optimization",
vasp_input_set=None,
vasp_cmd=VASP_CMD,
override_default_vasp_params=None,
ediffg=None,
db_file=DB_FILE,
force_gamma=True,
job_type="double_relaxation_run",
max_force_threshold=RELAX_MAX_FORCE,
auto_npar=">>auto_npar<<",
half_kpts_first_relax=HALF_KPOINTS_FIRST_RELAX,
parents=None,
**kwargs):
"""
Optimize the given structure.
Args:
structure (Structure): Input structure.
name (str): Name for the Firework.
vasp_input_set (VaspInputSet): input set to use. Defaults to MPRelaxSet() if None.
override_default_vasp_params (dict): If this is not None, these params are passed to
the default vasp_input_set, i.e., MPRelaxSet. This allows one to easily override
some settings, e.g., user_incar_settings, etc.
vasp_cmd (str): Command to run vasp.
ediffg (float): Shortcut to set ediffg in certain jobs
db_file (str): Path to file specifying db credentials to place output parsing.
force_gamma (bool): Force gamma centered kpoint generation
job_type (str): custodian job type (default "double_relaxation_run")
max_force_threshold (float): max force on a site allowed at end; otherwise, reject job
auto_npar (bool or str): whether to set auto_npar. defaults to env_chk: ">>auto_npar<<"
half_kpts_first_relax (bool): whether to use half the kpoints for the first relaxation
parents ([Firework]): Parents of this particular Firework.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or MPRelaxSet(
structure, force_gamma=force_gamma, **override_default_vasp_params)
t = []
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
job_type=job_type,
max_force_threshold=max_force_threshold,
ediffg=ediffg,
auto_npar=auto_npar,
half_kpts_first_relax=half_kpts_first_relax))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(OptimizeFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def run_task_ext(t, vasp_cmd, db_file, structure, tag,
override_default_vasp_params):
try:
store_raw_vasprunxml = override_default_vasp_params[
'user_incar_settings']['store_raw_vasprunxml']
except:
store_raw_vasprunxml = False
if type(store_raw_vasprunxml) == int: kmesh_factor = store_raw_vasprunxml
elif type(store_raw_vasprunxml) == bool:
if store_raw_vasprunxml: kmesh_factor = 2
else: kmesh_factor = 0
else: kmesh_factor = 0
# print ("eeeeeeeeeeeeeeee", store_raw_vasprunxml, kmesh_factor)
if kmesh_factor > 1:
t.append(nonscalc(kmesh_factor=kmesh_factor))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<",
gzip_output=False))
t.append(
InsertXMLToDb(db_file=db_file,
structure=structure,
tag=tag,
xml="vasprun.xml",
kmesh_factor=kmesh_factor))
elif kmesh_factor == 1:
t.append(
InsertXMLToDb(db_file=db_file,
structure=structure,
tag=tag,
xml="vasprun.xml",
kmesh_factor=1))
def __init__(self, structure, isif=2, scale_lattice=None, name="static", vasp_input_set=None,
vasp_cmd="vasp", metadata=None, prev_calc_loc=True, Prestatic=False, modify_incar=None,
db_file=None, parents=None, tag=None, override_default_vasp_params=None,
store_volumetric_data=False, **kwargs):
# TODO: @computron - I really don't like how you need to set the structure even for
# prev_calc_loc jobs. Sometimes it makes appending new FWs to an existing workflow
# difficult. Maybe think about how to remove this need? -computron
metadata = metadata or {}
tag = tag or metadata.get('tag')
# generate a tag with a warning
if tag is None:
tag = str(uuid4())
metadata['tag'] = tag
if isinstance(store_volumetric_data, (list, tuple)):
store_volumetric_data = store_volumetric_data
elif isinstance(store_volumetric_data, bool):
if store_volumetric_data:
store_volumetric_data = STORE_VOLUMETRIC_DATA
else:
store_volumetric_data = ()
else:
raise ValueError('The store_volumetric_data should be list or bool')
override_default_vasp_params = override_default_vasp_params or {}
self.override_default_vasp_params = override_default_vasp_params
vasp_input_set = vasp_input_set or StaticSet(structure, isif=isif, **override_default_vasp_params)
site_properties = deepcopy(structure).site_properties
# Avoids delivery (prev_calc_loc == '' (instead by True))
t = []
if type(prev_calc_loc) == str:
t.append(CopyVaspOutputs(calc_dir=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
elif parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
else:
t.append(WriteVaspFromIOSetPrevStructure(structure=structure, vasp_input_set=vasp_input_set, site_properties=site_properties))
if (scale_lattice is not None) and not Prestatic:
t.append(ScaleVolumeTransformation(scale_factor=scale_lattice, structure=structure))
t.append(ModifyIncar(incar_update=">>incar_update<<"))
if modify_incar != None:
t.append(ModifyIncar(incar_update=modify_incar))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<", gzip_output=False))
t.append(PassCalcLocs(name=name))
if Prestatic:
t.append(Record_PreStatic_result(db_file = ">>db_file<<", metadata = metadata, structure = structure, scale_lattice = scale_lattice))
else:
t.append(VaspToDb(db_file=">>db_file<<", parse_dos=True, additional_fields={"task_label": name, "metadata": metadata,
"version_atomate": atomate_ver, "version_dfttk": dfttk_ver, "adopted": True, "tag": tag},
store_volumetric_data=store_volumetric_data))
run_task_ext(t,vasp_cmd,">>db_file<<",structure,tag,self.override_default_vasp_params)
t.append(CheckSymmetryToDb(db_file=">>db_file<<", tag=tag, site_properties=site_properties))
super(StaticFW, self).__init__(t, parents=parents, name="{}-{}".format(
structure.composition.reduced_formula, name), **kwargs)
def __init__(self, mode, displacement, prev_calc_dir=None, structure=None, name="raman",
vasp_cmd=VASP_CMD, db_file=DB_FILE,
parents=None, user_incar_settings=None, **kwargs):
"""
Static calculation Firework that computes the DFPT dielectric constant for
structure displaced along the given normal mode direction.
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
mode (int): normal mode index.
displacement (float): displacement along the normal mode in Angstroms.
name (str): Name for the Firework.
prev_calc_dir (str): Path to a previous calculation to copy from
vasp_cmd (str): Command to run vasp.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
user_incar_settings (dict): Parameters in INCAR to override
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
name = "{}_{}_{}".format(name, str(mode), str(displacement))
fw_name = "{}-{}".format(structure.composition.reduced_formula if structure else "unknown", name)
user_incar_settings = user_incar_settings or {}
t = []
if prev_calc_dir:
t.append(CopyVaspOutputs(calc_dir=prev_calc_dir, contcar_to_poscar=True))
elif parents:
t.append(CopyVaspOutputs(calc_loc=True, contcar_to_poscar=True))
else:
raise ValueError("Must specify a previous calculation")
t.append(WriteVaspStaticFromPrev(lepsilon=True, other_params={
'user_incar_settings': user_incar_settings}))
t.append(WriteNormalmodeDisplacedPoscar(mode=mode,
displacement=displacement))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
key = "{}_{}".format(mode, displacement).replace('-', 'm').replace('.',
'd')
t.append(pass_vasp_result(pass_dict={"mode": mode,
"displacement": displacement,
"epsilon": "a>>epsilon_static"},
mod_spec_key="raman_epsilon->{}".format(key),
parse_eigen=True))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(RamanFW, self).__init__(t, parents=parents, name=fw_name, **kwargs)
def __init__(self,
structure,
scale_lattice=None,
name="static",
vasp_input_set=None,
vasp_cmd="vasp",
metadata=None,
prev_calc_loc=True,
db_file=None,
parents=None,
**kwargs):
# TODO: @computron - I really don't like how you need to set the structure even for
# prev_calc_loc jobs. Sometimes it makes appending new FWs to an existing workflow
# difficult. Maybe think about how to remove this need? -computron
metadata = metadata or {}
vasp_input_set = vasp_input_set or StaticSet(structure)
site_properties = deepcopy(structure).site_properties
t = []
if parents:
if prev_calc_loc:
t.append(
CopyVaspOutputs(calc_loc=prev_calc_loc,
contcar_to_poscar=True))
t.append(
WriteVaspFromIOSetPrevStructure(
vasp_input_set=vasp_input_set,
site_properties=site_properties))
else:
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
if scale_lattice is not None:
t.append(ScaleVolumeTransformation(scale_factor=scale_lattice))
t.append(ModifyIncar(incar_update=">>incar_update<<"))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<",
gzip_output=False))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(
db_file=db_file,
parse_dos=True,
additional_fields={
"task_label": name,
"metadata": metadata
},
))
super(StaticFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def __init__(self,
structure,
name="static",
vasp_input_set=None,
vasp_cmd="vasp",
prev_calc_loc=True,
db_file=None,
parents=None,
**kwargs):
"""
Standard static calculation Firework - either from a previous location or from a structure.
Args:
structure (Structure): Input structure. Note that for prev_calc_loc jobs, the structure
is only used to set the name of the FW and any structure with the same composition
can be used.
name (str): Name for the Firework.
vasp_input_set (VaspInputSet): input set to use (for jobs w/no parents)
Defaults to MPStaticSet() if None.
vasp_cmd (str): Command to run vasp.
prev_calc_loc (bool or str): If true (default), copies outputs from previous calc. If
a str value, grabs a previous calculation output by name. If False/None, will create
new static calculation using the provided structure.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
# TODO: @computron - I really don't like how you need to set the structure even for
# prev_calc_loc jobs. Sometimes it makes appending new FWs to an existing workflow
# difficult. Maybe think about how to remove this need? -computron
t = []
if parents:
if prev_calc_loc:
t.append(
CopyVaspOutputs(calc_loc=prev_calc_loc,
contcar_to_poscar=True))
t.append(WriteVaspStaticFromPrev())
else:
vasp_input_set = vasp_input_set or MPStaticSet(structure)
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<"))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(StaticFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def __init__(self,
structure,
name="nscf",
mode="uniform",
vasp_cmd="vasp",
copy_vasp_outputs=True,
db_file=None,
parents=None,
**kwargs):
"""
Standard NonSCF Calculation Firework supporting both
uniform and line modes.
Args:
structure (Structure): Input structure - used only to set the name of the FW.
name (str): Name for the Firework.
mode (str): "uniform" or "line" mode.
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous
run. Defaults to True.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
t = []
if copy_vasp_outputs:
t.append(
CopyVaspOutputs(calc_loc=True, additional_files=["CHGCAR"]))
mode = mode.lower()
if mode == "uniform":
t.append(
WriteVaspNSCFFromPrev(prev_calc_dir=".",
mode="uniform",
reciprocal_density=1000))
else:
t.append(
WriteVaspNSCFFromPrev(prev_calc_dir=".",
mode="line",
reciprocal_density=20))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<"))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file,
additional_fields={"task_label": name + " " + mode},
parse_dos=(mode == "uniform"),
bandstructure_mode=mode))
super(NonSCFFW, self).__init__(
t,
parents=parents,
name="%s-%s %s" %
(structure.composition.reduced_formula, name, mode),
**kwargs)
def __init__(self, structure, scale_lattice=None, isif=4, override_symmetry_tolerances=None,
name="structure optimization", vasp_input_set=None, job_type="normal", vasp_cmd="vasp",
metadata=None, override_default_vasp_params=None, db_file=None, record_path=False,
prev_calc_loc=True, parents=None, db_insert=False, tag=None,
run_isif2=False, pass_isif4=False, force_gamma=True, store_volumetric_data=False,
modify_incar=None, modify_incar_params={}, modify_kpoints_params={}, **kwargs):
metadata = metadata or {}
tag = tag or metadata.get('tag')
# generate a tag with a warning
if tag is None:
tag = str(uuid4())
metadata['tag'] = tag
metadata.update({'tag': tag})
if isinstance(store_volumetric_data, (list, tuple)):
store_volumetric_data = store_volumetric_data
elif isinstance(store_volumetric_data, bool):
if store_volumetric_data:
store_volumetric_data = STORE_VOLUMETRIC_DATA
else:
store_volumetric_data = ()
else:
raise ValueError('The store_volumetric_data should be list or bool')
override_default_vasp_params = override_default_vasp_params or {}
override_symmetry_tolerances = override_symmetry_tolerances or {}
vasp_input_set = vasp_input_set or RelaxSet(structure, isif=isif, force_gamma=force_gamma,
**override_default_vasp_params)
site_properties = deepcopy(structure).site_properties
t = []
# Avoids delivery (prev_calc_loc == '' (instead by True))
if type(prev_calc_loc) == str:
t.append(CopyVaspOutputs(calc_dir=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
elif parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
else:
#vasp_input_set = vasp_input_set or RelaxSet(structure) # ??
t.append(WriteVaspFromIOSetPrevStructure(structure=structure, vasp_input_set=vasp_input_set, site_properties=site_properties))
if scale_lattice is not None:
t.append(ScaleVolumeTransformation(scale_factor=scale_lattice, structure=structure))
t.append(ModifyIncar(incar_update=">>incar_update<<"))
if modify_incar != None:
t.append(ModifyIncar(incar_update=modify_incar))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, job_type=job_type, gzip_output=False))
t.append(PassCalcLocs(name=name))
if record_path:
t.append(Record_relax_running_path(db_file = db_file, metadata = metadata, run_isif2=run_isif2, pass_isif4=pass_isif4))
if db_insert:
t.append(VaspToDb(db_file=db_file, additional_fields={"task_label": name, "metadata": metadata}, store_volumetric_data=store_volumetric_data))
t.append(CheckSymmetryToDb(db_file=db_file, tag=tag, override_symmetry_tolerances=override_symmetry_tolerances, site_properties=site_properties))
super(OptimizeFW, self).__init__(t, parents=parents, name="{}-{}".format(structure.composition.reduced_formula, name), **kwargs)
def __init__(self,
structure,
name="structure optimization",
vasp_input_set=None,
job_type="normal",
vasp_cmd="vasp",
isif=None,
metadata=None,
override_default_vasp_params=None,
db_file=None,
force_gamma=True,
parents=None,
**kwargs):
"""
Optimize the given structure.
Args:
structure (Structure): Input structure.
name (str): Name for the Firework.
vasp_input_set (VaspInputSet): input set to use. Defaults to MPRelaxSet() if None.
override_default_vasp_params (dict): If this is not None, these params are passed to
the default vasp_input_set, i.e., MPRelaxSet. This allows one to easily override
some settings, e.g., user_incar_settings, etc.
isif : int
Shortcut to override the ISIF parameter. Defaults to None.
Will take precedent over override_default_vasp_params
vasp_cmd (str): Command to run vasp.
db_file (str): Path to file specifying db credentials to place output parsing.
force_gamma (bool): Force gamma centered kpoint generation
parents ([Firework]): Parents of this particular Firework.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
metadata = metadata or {}
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or PRLRelaxSet(
structure, force_gamma=force_gamma, **override_default_vasp_params)
t = []
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
if isif:
t.append(ModifyIncar(incar_update={'ISIF': isif}))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, job_type=job_type))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file,
additional_fields={
"task_label": name,
"metadata": metadata
}))
super(OptimizeFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def run_task(self, fw_spec):
prev_checkpoint_dirs = fw_spec.get(
"checkpoint_dirs",
[]) # If this is the first spawn, have no prev dirs
prev_checkpoint_dirs.append(os.getcwd(
)) # add the current directory to the list of checkpoints
vasp_cmd = self["vasp_cmd"]
wall_time = self["wall_time"]
db_file = self.get("db_file", None)
spawn_count = self["spawn_count"]
production = self['production']
num_checkpoints = production.get('num_checkpoints', 1)
incar_update = production.get('incar_update', None)
if spawn_count > num_checkpoints:
logger.info(
"LOGGER: Production run completed. Took {} spawns total".
format(spawn_count))
return FWAction(stored_data={'production_run_completed': True})
else:
name = ("ProductionRun" + str(abs(spawn_count)))
logger.info("LOGGER: Starting spawn {} of production run".format(
spawn_count))
t = []
t.append(
CopyVaspOutputs(calc_dir=os.getcwd(), contcar_to_poscar=True))
if incar_update:
t.append(ModifyIncar(incar_update=incar_update))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
gamma_vasp_cmd=">>vasp_gam<<",
handler_group="md",
wall_time=wall_time))
t.append(
ProductionSpawnTask(wall_time=wall_time,
vasp_cmd=vasp_cmd,
db_file=db_file,
spawn_count=spawn_count + 1,
production=production))
new_fw = Firework(t,
name=name,
spec={'checkpoint_dirs': prev_checkpoint_dirs})
return FWAction(
stored_data={'production_run_completed': False},
update_spec={'checkpoint_dirs': prev_checkpoint_dirs},
detours=[new_fw])
def __init__(self, structure, start_temp, end_temp, nsteps,
name="molecular dynamics",
vasp_input_set=None, vasp_cmd=VASP_CMD,
override_default_vasp_params=None,
wall_time=19200, db_file=DB_FILE, parents=None,
copy_vasp_outputs=True, **kwargs):
"""
Standard firework for a single MD run.
Args:
structure (Structure): Input structure.
start_temp (float): Start temperature of MD run.
end_temp (float): End temperature of MD run.
nsteps (int): Number of MD steps
name (string): Name for the Firework.
vasp_input_set (string): string name for the VASP input set (e.g.,
"MITMDVaspInputSet").
vasp_cmd (string): Command to run vasp.
override_default_vasp_params (dict): If this is not None,
these params are passed to the default vasp_input_set, i.e.,
MITMDSet. This allows one to easily override some
settings, e.g., user_incar_settings, etc. Particular to MD,
one can control time_step and all other settings of the input set.
wall_time (int): Total wall time in seconds before writing STOPCAR.
copy_vasp_outputs (bool): Whether to copy outputs from previous run. Defaults to True.
db_file (string): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or MITMDSet(structure,
start_temp=start_temp,
end_temp=end_temp,
nsteps=nsteps,
**override_default_vasp_params)
t = []
if copy_vasp_outputs:
t.append(CopyVaspOutputs(calc_loc=True, additional_files=["CHGCAR"],
contcar_to_poscar=True))
t.append(WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd,
gamma_vasp_cmd=">>gamma_vasp_cmd<<",
handler_group="md", wall_time=wall_time))
t.append(PassCalcLocs(name=name))
t.append(VaspToDb(db_file=db_file,
additional_fields={"task_label": name},
defuse_unsuccessful=False))
super(MDFW, self).__init__(t, parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula,
name),
**kwargs)
def __init__(self, structure=None, name="static", vasp_input_set=None, vasp_input_set_params=None,
vasp_cmd=VASP_CMD, prev_calc_loc=True, prev_calc_dir=None, db_file=DB_FILE, vasptodb_kwargs=None,
parents=None, **kwargs):
"""
Standard static calculation Firework - either from a previous location or from a structure.
Args:
structure (Structure): Input structure. Note that for prev_calc_loc jobs, the structure
is only used to set the name of the FW and any structure with the same composition
can be used.
name (str): Name for the Firework.
vasp_input_set (VaspInputSet): input set to use (for jobs w/no parents)
Defaults to MPStaticSet() if None.
vasp_input_set_params (dict): Dict of vasp_input_set kwargs.
vasp_cmd (str): Command to run vasp.
prev_calc_loc (bool or str): If true (default), copies outputs from previous calc. If
a str value, retrieves a previous calculation output by name. If False/None, will create
new static calculation using the provided structure.
prev_calc_dir (str): Path to a previous calculation to copy from
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
vasptodb_kwargs (dict): kwargs to pass to VaspToDb
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
t = []
vasp_input_set_params = vasp_input_set_params or {}
vasptodb_kwargs = vasptodb_kwargs or {}
if "additional_fields" not in vasptodb_kwargs:
vasptodb_kwargs["additional_fields"] = {}
vasptodb_kwargs["additional_fields"]["task_label"] = name
fw_name = "{}-{}".format(structure.composition.reduced_formula if structure else "unknown", name)
if prev_calc_dir:
t.append(CopyVaspOutputs(calc_dir=prev_calc_dir, contcar_to_poscar=True))
t.append(WriteVaspStaticFromPrev(other_params=vasp_input_set_params))
elif parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc,
contcar_to_poscar=True))
t.append(WriteVaspStaticFromPrev(other_params=vasp_input_set_params))
elif structure:
vasp_input_set = vasp_input_set or MPStaticSet(structure, **vasp_input_set_params)
t.append(WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
else:
raise ValueError("Must specify structure or previous calculation")
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<"))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, **vasptodb_kwargs))
super(StaticFW, self).__init__(t, parents=parents, name=fw_name, **kwargs)
def __init__(self,
structure,
magmom,
name="spin-orbit coupling",
saxis=(0, 0, 1),
vasp_cmd="vasp_ncl",
copy_vasp_outputs=True,
db_file=None,
parents=None,
**kwargs):
"""
Firework for spin orbit coupling calculation.
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
name (str): Name for the Firework.
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous
run. Defaults to True.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
t = []
if copy_vasp_outputs:
t.append(
CopyVaspOutputs(calc_loc=True,
additional_files=["CHGCAR"],
contcar_to_poscar=True))
t.append(
WriteVaspSOCFromPrev(prev_calc_dir=".",
magmom=magmom,
saxis=saxis))
else:
vasp_input_set = MPSOCSet(structure)
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
t.extend([
RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<"),
PassCalcLocs(name=name),
VaspToDb(db_file=db_file, additional_fields={"task_label": name})
])
super(SOCFW, self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula,
name),
**kwargs)
def __init__(self,
structure,
name="static",
previous_structure=False,
vasp_input_set=None,
vasp_cmd="vasp",
db_file=None,
parents=None,
override_default_vasp_params=None,
pass_structure=True,
prev_calc_loc=False,
**kwargs):
"""
This Firework is modified from atomate.vasp.fireworks.core.StaticFW to fit the needs of mpmorph
Standard static calculation Firework - either from a previous location or from a structure.
Args:
structure (Structure): Input structure. Note that for prev_calc_loc jobs, the structure
is only used to set the name of the FW and any structure with the same composition
can be used.
name (str): Name for the Firework.
vasp_input_set (VaspInputSet): input set to use (for jobs w/no parents)
Defaults to MPStaticSet() if None.
vasp_cmd (str): Command to run vasp.
prev_calc_loc (bool or str): If true (default), copies outputs from previous calc. If
a str value, grabs a previous calculation output by name. If False/None, will create
new static calculation using the provided structure.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
t = []
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or MPStaticSet(
structure, **override_default_vasp_params)
if prev_calc_loc:
t.append(
CopyVaspOutputs(calc_loc=prev_calc_loc,
contcar_to_poscar=True))
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
if previous_structure:
t.append(PreviousStructureTask())
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<"))
t.append(SaveStructureTask())
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
name = f'{structure.composition.reduced_formula}-{name}'
super(StaticFW, self).__init__(t, parents=parents, name=name, **kwargs)
def __init__(self, structure, isif=7, name="structure optimization", isif4=False, level=1,
override_symmetry_tolerances=None, job_type="normal", vasp_input_set=None,
vasp_cmd="vasp", metadata=None, override_default_vasp_params=None, db_file=None,
prev_calc_loc=True, parents=None, db_insert=False, tag=None, modify_incar_params={},
modify_kpoints_params={}, energy_with_isif={}, store_volumetric_data=False,
**kwargs):
metadata = metadata or {}
tag = tag or metadata.get('tag')
# generate a tag with a warning
if tag is None:
tag = str(uuid4())
metadata['tag'] = tag
if isinstance(store_volumetric_data, (list, tuple)):
store_volumetric_data = store_volumetric_data
elif isinstance(store_volumetric_data, bool):
if store_volumetric_data:
store_volumetric_data = STORE_VOLUMETRIC_DATA
else:
store_volumetric_data = ()
else:
raise ValueError('The store_volumetric_data should be list or bool')
override_default_vasp_params = override_default_vasp_params or {}
override_symmetry_tolerances = override_symmetry_tolerances or {}
vasp_input_set = vasp_input_set or RelaxSet(structure, isif=isif, **override_default_vasp_params)
site_properties = deepcopy(structure).site_properties
t = []
if parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
else:
t.append(WriteVaspFromIOSetPrevStructure(structure=structure, vasp_input_set=vasp_input_set, site_properties=site_properties))
t.append(ModifyIncar(incar_update=">>incar_update<<"))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, job_type=job_type, gzip_output=False))
t.append(PassCalcLocs(name=name))
if db_insert:
t.append(VaspToDb(db_file=">>db_file<<", additional_fields={"task_label": name, "metadata": metadata}, store_volumetric_data=store_volumetric_data))
t.append(CheckSymmetryToDb(db_file=">>db_file<<", tag=tag, site_properties=site_properties))
common_kwargs = {'vasp_cmd': vasp_cmd, 'db_file': ">>db_file<<", "metadata": metadata, "tag": tag,
'override_default_vasp_params': override_default_vasp_params}
static_kwargs = {}
relax_kwargs = {}
t.append(CheckRelaxation(db_file=">>db_file<<", metadata=metadata, tag=tag, isif4=isif4, level=level, energy_with_isif=energy_with_isif,
common_kwargs=common_kwargs, relax_kwargs=relax_kwargs, static_kwargs=static_kwargs, site_properties=site_properties,
store_volumetric_data=store_volumetric_data,
**override_symmetry_tolerances))
super().__init__(t, parents=parents, name="{}-{}".format(structure.composition.reduced_formula, name), **kwargs)
def __init__(self, spec, label, user_incar_settings=None,
user_kpoints_settings=None,
additional_cust_args=None, **kwargs):
"""
Args:
spec (dict): Specification of the job to run.
label (str): "parent", "ep0" or "ep1"
vasp_input_set (VaspInputSet): Input set to use.
user_kpoints_settings (dict): Additional KPOINTS settings.
additional_cust_args (dict): Other kwargs that are passed to RunVaspCustodian.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
# Get structure from spec
assert label in ["parent", "ep0", "ep1"]
structure_dict = spec[label]
structure = Structure.from_dict(structure_dict)
user_incar_settings = user_incar_settings or {}
user_kpoints_settings = user_kpoints_settings or {}
additional_cust_args = additional_cust_args or {}
# Task 1: Write input sets
if label == 'parent':
vasp_input_set = MITRelaxSet(structure,
user_incar_settings=user_incar_settings,
user_kpoints_settings=user_kpoints_settings)
else: # label == "ep0" or "ep1"
from pymatgen_diffusion.neb.io import MVLCINEBEndPointSet
vasp_input_set = MVLCINEBEndPointSet(structure,
user_incar_settings=user_incar_settings,
user_kpoints_settings=user_kpoints_settings)
write_ep_task = WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set)
# Task 2: Run VASP using Custodian
cust_args = {"job_type": "normal", "gzip_output": False,
"handler_group": "no_handler"}
cust_args.update(additional_cust_args)
run_vasp = RunVaspCustodian(vasp_cmd=">>vasp_cmd<<",
gamma_vasp_cmd=">>gamma_vasp_cmd<<",
**cust_args)
# Task 3, 4: Transfer and PassCalLocs
tasks = [write_ep_task, run_vasp, TransferNEBTask(label=label),
PassCalcLocs(name=label)]
super(NEBRelaxationFW, self).__init__(tasks, spec=spec, name=label,
**kwargs)
def __init__(self, spec, neb_label, from_images=True,
user_incar_settings=None,
user_kpoints_settings=None, additional_cust_args=None,
**kwargs):
"""
Args:
spec (dict): Specification of the job to run.
neb_label (str): "1", "2"..., label neb run.
from_images (bool): Set True to initialize from image structures, False starting
from relaxed endpoint structures.
user_incar_settings (dict): Additional INCAR settings.
user_kpoints_settings (dict): Additional KPOINTS settings.
additional_cust_args (dict): Other kwargs that are passed to RunVaspCustodian.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
assert neb_label.isdigit() and int(neb_label) >= 1
label = "neb{}".format(neb_label)
sort_tol = spec["sort_tol"]
d_img = spec["d_img"]
interpolation_type = spec["interpolation_type"]
# Task 1: Write NEB input sets
user_incar_settings = user_incar_settings or {}
user_kpoints_settings = user_kpoints_settings or {}
additional_cust_args = additional_cust_args or {}
if from_images:
write_neb_task = WriteNEBFromImages(neb_label=neb_label,
user_incar_settings=user_incar_settings,
user_kpoints_settings=user_kpoints_settings)
else: # from endpoints
write_neb_task = WriteNEBFromEndpoints(
user_incar_settings=user_incar_settings,
user_kpoints_settings=user_kpoints_settings,
sort_tol=sort_tol, d_img=d_img,
interpolation_type=interpolation_type)
# Task 2: Run NEB using Custodian
cust_args = {"job_type": "neb", "gzip_output": False,
"handler_group": "no_handler"}
cust_args.update(additional_cust_args)
run_neb_task = RunVaspCustodian(vasp_cmd=">>vasp_cmd<<",
gamma_vasp_cmd=">>gamma_vasp_cmd<<",
**cust_args)
# Task 3, 4: Transfer and PassCalcLocs
tasks = [write_neb_task, run_neb_task, TransferNEBTask(label=label),
PassCalcLocs(name=label)]
super(NEBFW, self).__init__(tasks, spec=spec, name=label, **kwargs)
def __init__(self,
structure,
name="structure optimization",
vasp_input_set=None,
job_type="normal",
vasp_cmd="vasp",
metadata=None,
override_default_vasp_params=None,
db_file=None,
force_gamma=True,
prev_calc_loc=True,
parents=None,
db_insert=False,
**kwargs):
metadata = metadata or {}
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or PRLRelaxSet(
structure, force_gamma=force_gamma, **override_default_vasp_params)
t = []
if parents:
if prev_calc_loc:
t.append(
CopyVaspOutputs(calc_loc=prev_calc_loc,
contcar_to_poscar=True))
t.append(
WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set))
else:
vasp_input_set = vasp_input_set or PRLRelaxSet(structure)
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
job_type=job_type,
gzip_output=False))
t.append(PassCalcLocs(name=name))
if db_insert:
t.append(
VaspToDb(db_file=db_file,
additional_fields={
"task_label": name,
"metadata": metadata
}))
super(PRLOptimizeFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def __init__(self, structure, isif=2, scale_lattice=None, name="born charge", vasp_input_set=None,
vasp_cmd="vasp", metadata=None, override_default_vasp_params=None, tag=None,
prev_calc_loc=True, modify_incar=None, db_file=None, parents=None, **kwargs):
metadata = metadata or {}
tag = tag or metadata.get('tag')
# generate a tag with a warning
if tag is None:
tag = str(uuid4())
metadata['tag'] = tag
override_default_vasp_params = override_default_vasp_params or {}
vasp_input_set = vasp_input_set or BornChargeSet(structure, isif=isif, **override_default_vasp_params)
site_properties = deepcopy(structure).site_properties
# Avoids delivery (prev_calc_loc == '' (instead by True))
t = []
if type(prev_calc_loc) == str:
t.append(CopyVaspOutputs(calc_dir=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
elif parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=True))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=site_properties))
else:
t.append(WriteVaspFromIOSetPrevStructure(structure=structure, vasp_input_set=vasp_input_set, site_properties=site_properties))
if (scale_lattice is not None):
t.append(ScaleVolumeTransformation(scale_factor=scale_lattice, structure=structure))
#the following statement may not correct to Born effective charge calculation, so be commented.
"""
t.append(ModifyIncar(incar_update=">>incar_update<<"))
if modify_incar != None:
t.append(ModifyIncar(incar_update=modify_incar))
"""
#t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<", gzip_output=False))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=False, gzip_output=False))
t.append(PassCalcLocs(name=name))
t.append(BornChargeToDb(db_file=">>db_file<<", tag=tag))
#t.append(CheckSymmetryToDb(db_file=db_file, tag=tag))
super(BornChargeFW, self).__init__(t, parents=parents, name="{}-{}".format(
structure.composition.reduced_formula, name), **kwargs)
def __init__(self,
structure,
parents,
mode="gap",
name=None,
vasp_cmd="vasp",
db_file=None,
**kwargs):
"""
For getting a more accurate band gap or a full band structure with HSE - requires previous
calculation that gives VBM/CBM info or the high-symmetry kpoints.
Args:
structure (Structure): Input structure - used only to set the name of the FW.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
mode (string): options:
"line" to get a full band structure along symmetry lines or
"uniform" for uniform mesh band structure or
"gap" to get the energy at the CBM and VBM
name (str): Name for the Firework.
vasp_cmd (str): Command to run vasp.
db_file (str): Path to file specifying db credentials.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
name = name if name else "{} {}".format("hse", mode)
t = []
t.append(CopyVaspOutputs(calc_loc=True, additional_files=["CHGCAR"]))
t.append(WriteVaspHSEBSFromPrev(prev_calc_dir='.', mode=mode))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(HSEBSFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
def __init__(self, structure, start, end, name="static", vasp_input_set="MPStaticSet",
vasp_input_set_params=None, vasp_cmd=VASP_CMD, db_file=DB_FILE,
parents=None, this_image=None, nimages=None, autosort_tol=0, **kwargs):
"""
Standard static calculation Firework that interpolates structures from two previous calculations.
Args:
structure (Structure): Input structure used to name FireWork.
start (str): PassCalcLoc name of StaticFW or RelaxFW run of starting structure.
end (str): PassCalcLoc name of StaticFW or RelaxFW run of ending structure.
name (str): Name for the Firework.
vasp_input_set (str): Input set to use. Defaults to MPStaticSet.
vasp_input_set_params (dict): Dict of vasp_input_set_kwargs.
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous run. Defaults to True.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
this_image (int): which interpolation to use for this run
nimages (int): number of interpolations
autosort_tol (float): a distance tolerance in angstrom in which
to automatically sort end_structure to match to the closest
points in this particular structure.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
t = []
vasp_input_set_params = vasp_input_set_params or {}
t.append(WriteVaspFromIOSetFromInterpolatedPOSCAR(
start=start, end=end, this_image=this_image, nimages=nimages,
autosort_tol=autosort_tol, vasp_input_set=vasp_input_set,
vasp_input_params=vasp_input_set_params))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<"))
t.append(PassCalcLocs(name=name))
t.append(VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(StaticInterpolateFW, self).__init__(t, parents=parents, name="{}-{}".format(
structure.composition.reduced_formula, name), **kwargs)
def run_task(self, fw_spec):
vasp_cmd = self.get("vasp_cmd")
wall_time = self.get("wall_time")
db_file = self.get("db_file")
max_rescales = self.get("max_rescales")
pressure_threshold = self.get("pressure_threshold")
spawn_count = self.get("spawn_count")
production = self.get('production', {})
p_v = self.get('p_v', [])
if spawn_count > max_rescales:
logger.info(
"WARNING: The max number of rescales has been reached... stopping density search."
)
return FWAction(defuse_workflow=True)
name = ("spawnrun" + str(spawn_count))
current_dir = os.getcwd()
averaging_fraction = self.get("averaging_fraction", 0.5)
data = MD_Data()
data.parse_md_data(current_dir)
pressure = data.get_md_data()['pressure']
v = data.get_volume
p = np.mean(pressure[int(averaging_fraction * (len(pressure) - 1)):])
p_v.append([p, v])
logger.info("LOGGER: Current pressure is {}".format(p))
if np.fabs(p) > pressure_threshold:
logger.info(
"LOGGER: Pressure is outside of threshold: Spawning another MD Task"
)
t = []
t.append(
CopyVaspOutputs(calc_dir=current_dir, contcar_to_poscar=True))
t.append(
RescaleVolumeTask(initial_pressure=p * 1000.0,
initial_temperature=1,
p_v=p_v))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
gamma_vasp_cmd=">>vasp_gam<<",
handler_group="md",
wall_time=wall_time))
t.append(
SpawnMDFWTask(pressure_threshold=pressure_threshold,
max_rescales=max_rescales,
wall_time=wall_time,
vasp_cmd=vasp_cmd,
db_file=db_file,
spawn_count=spawn_count + 1,
averaging_fraction=averaging_fraction,
production=production))
new_fw = Firework(t, name=name, spec={'p_v': p_v})
return FWAction(stored_data={'pressure': p}, detours=[new_fw])
elif production:
logger.info(
"LOGGER: Pressure is within the threshold: Moving to production runs..."
)
t = []
t.append(
CopyVaspOutputs(calc_dir=current_dir, contcar_to_poscar=True))
t.append(
RunVaspCustodian(vasp_cmd=vasp_cmd,
gamma_vasp_cmd=">>vasp_gam<<",
handler_group="md",
wall_time=wall_time))
t.append(
ProductionSpawnTask(vasp_cmd=vasp_cmd,
wall_time=wall_time,
db_file=db_file,
spawn_count=1,
production=production))
production_fw = Firework(t, name="ProductionRun1")
return FWAction(stored_data={
'pressure': p,
'density_calculated': True
},
detours=[production_fw])
else:
return FWAction(stored_data={
'pressure': p,
'density_calculated': True
})
def __init__(self,
structure,
transformations,
transformation_params=None,
vasp_input_set=None,
prev_calc_dir=None,
name="structure transmuter",
vasp_cmd=VASP_CMD,
copy_vasp_outputs=True,
db_file=DB_FILE,
parents=None,
override_default_vasp_params=None,
**kwargs):
"""
Apply the transformations to the input structure, write the input set corresponding
to the transformed structure, and run vasp on them. Note that if a transformation yields
many structures from one, only the last structure in the list is used.
Args:
structure (Structure): Input structure.
transformations (list): list of names of transformation classes as defined in
the modules in pymatgen.transformations.
eg: transformations=['DeformStructureTransformation', 'SupercellTransformation']
transformation_params (list): list of dicts where each dict specify the input
parameters to instantiate the transformation class in the transformations list.
vasp_input_set (VaspInputSet): VASP input set, used to write the input set for the
transmuted structure.
name (string): Name for the Firework.
vasp_cmd (string): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous run. Defaults to True.
prev_calc_dir (str): Path to a previous calculation to copy from
db_file (string): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework. FW or list of FWS.
override_default_vasp_params (dict): additional user input settings for vasp_input_set.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
fw_name = "{}-{}".format(structure.composition.reduced_formula, name)
override_default_vasp_params = override_default_vasp_params or {}
t = []
vasp_input_set = vasp_input_set or MPStaticSet(
structure, force_gamma=True, **override_default_vasp_params)
if prev_calc_dir:
t.append(
CopyVaspOutputs(calc_dir=prev_calc_dir,
contcar_to_poscar=True))
t.append(
WriteTransmutedStructureIOSet(
transformations=transformations,
transformation_params=transformation_params,
vasp_input_set=vasp_input_set,
override_default_vasp_params=override_default_vasp_params,
prev_calc_dir="."))
elif copy_vasp_outputs:
t.append(CopyVaspOutputs(calc_loc=True, contcar_to_poscar=True))
t.append(
WriteTransmutedStructureIOSet(
structure=structure,
transformations=transformations,
transformation_params=transformation_params,
vasp_input_set=vasp_input_set,
override_default_vasp_params=override_default_vasp_params,
prev_calc_dir="."))
elif structure:
t.append(
WriteTransmutedStructureIOSet(
structure=structure,
transformations=transformations,
transformation_params=transformation_params,
vasp_input_set=vasp_input_set,
override_default_vasp_params=override_default_vasp_params))
else:
raise ValueError("Must specify structure or previous calculation")
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file,
additional_fields={
"task_label": name,
"transmuter": {
"transformations": transformations,
"transformation_params": transformation_params
}
}))
super(TransmuterFW, self).__init__(t,
parents=parents,
name=fw_name,
**kwargs)
def __init__(self,
structure,
name="static dielectric",
vasp_cmd=VASP_CMD,
copy_vasp_outputs=True,
db_file=DB_FILE,
parents=None,
phonon=False,
mode=None,
displacement=None,
user_incar_settings=None,
**kwargs):
"""
Standard static calculation Firework for dielectric constants using DFPT.
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
name (str): Name for the Firework.
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous
run. Defaults to True.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
phonon (bool): Whether or not to extract normal modes and pass it. This argument along
with the mode and displacement arguments must be set for the calculation of
dielectric constant in the Raman tensor workflow.
mode (int): normal mode index.
displacement (float): displacement along the normal mode in Angstroms.
user_incar_settings (dict): Parameters in INCAR to override
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
warnings.warn(
"This firework will be removed soon. Use DFPTFW and/or RamanFW fireworks."
)
user_incar_settings = user_incar_settings or {}
t = []
if copy_vasp_outputs:
t.append(
CopyVaspOutputs(calc_loc=True,
additional_files=["CHGCAR"],
contcar_to_poscar=True))
t.append(
WriteVaspStaticFromPrev(
lepsilon=True,
other_params={'user_incar_settings': user_incar_settings}))
else:
vasp_input_set = MPStaticSet(
structure,
lepsilon=True,
user_incar_settings=user_incar_settings)
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
if phonon:
if mode is None and displacement is None:
name = "{} {}".format("phonon", name)
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
t.append(
pass_vasp_result(
{
"structure": "a>>final_structure",
"eigenvals": "a>>normalmode_eigenvals",
"eigenvecs": "a>>normalmode_eigenvecs"
},
parse_eigen=True,
mod_spec_key="normalmodes"))
else:
name = "raman_{}_{} {}".format(str(mode), str(displacement),
name)
key = "{}_{}".format(mode, displacement).replace('-',
'm').replace(
'.', 'd')
pass_fw = pass_vasp_result(pass_dict={
"mode": mode,
"displacement": displacement,
"epsilon": "a>>epsilon_static"
},
mod_spec_key="raman_epsilon->" +
key,
parse_eigen=True)
t.extend([
WriteNormalmodeDisplacedPoscar(mode=mode,
displacement=displacement),
RunVaspCustodian(vasp_cmd=vasp_cmd), pass_fw
])
else:
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
t.extend([
PassCalcLocs(name=name),
VaspToDb(db_file=db_file, additional_fields={"task_label": name})
])
super(LepsFW, self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula,
name),
**kwargs)
def __init__(self,
parents=None,
prev_calc_dir=None,
structure=None,
name="nscf",
mode="uniform",
vasp_cmd=VASP_CMD,
copy_vasp_outputs=True,
db_file=DB_FILE,
input_set_overrides=None,
**kwargs):
"""
Standard NonSCF Calculation Firework supporting uniform and line modes.
Args:
structure (Structure): Input structure - used only to set the name
of the FW.
name (str): Name for the Firework.
mode (str): "uniform" or "line" mode.
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous
run. Defaults to True.
prev_calc_dir (str): Path to a previous calculation to copy from
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
input_set_overrides (dict): Arguments passed to the
"from_prev_calc" method of the MPNonSCFSet. This parameter
allows a user to modify the default values of the input set.
For example, passing the key value pair
{'reciprocal_density': 1000}
will override default k-point meshes for uniform calculations.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
input_set_overrides = input_set_overrides or {}
fw_name = "{}-{} {}".format(
structure.composition.reduced_formula if structure else "unknown",
name, mode)
t = []
if prev_calc_dir:
t.append(
CopyVaspOutputs(calc_dir=prev_calc_dir,
additional_files=["CHGCAR"]))
elif parents:
t.append(
CopyVaspOutputs(calc_loc=True, additional_files=["CHGCAR"]))
else:
raise ValueError("Must specify previous calculation for NonSCFFW")
mode = mode.lower()
if mode == "uniform":
t.append(
WriteVaspNSCFFromPrev(prev_calc_dir=".",
mode="uniform",
**input_set_overrides))
else:
t.append(
WriteVaspNSCFFromPrev(prev_calc_dir=".",
mode="line",
**input_set_overrides))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd,
auto_npar=">>auto_npar<<"))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file,
additional_fields={"task_label": name + " " + mode},
parse_dos=(mode == "uniform"),
bandstructure_mode=mode))
super(NonSCFFW, self).__init__(t,
parents=parents,
name=fw_name,
**kwargs)
def __init__(self,
structure,
mode,
displacement,
name="raman",
vasp_cmd="vasp",
db_file=None,
parents=None,
user_incar_settings=None,
**kwargs):
"""
Static calculation Firework that computes the DFPT dielectric constant for
structure displaced along the given normal mode direction.
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
mode (int): normal mode index.
displacement (float): displacement along the normal mode in Angstroms.
name (str): Name for the Firework.
vasp_cmd (str): Command to run vasp.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
user_incar_settings (dict): Parameters in INCAR to override
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
name = "{}_{}_{} static dielectric".format(name, str(mode),
str(displacement))
user_incar_settings = user_incar_settings or {}
spec = kwargs.pop("spec", {})
spec.update({
"_files_in": {
"POSCAR": "POSCAR",
"OUTCAR": "OUTCAR",
"vasprunxml": "vasprun.xml"
}
})
t = []
t.append(
WriteVaspStaticFromPrev(
lepsilon=True,
other_params={'user_incar_settings': user_incar_settings}))
t.append(
WriteNormalmodeDisplacedPoscar(mode=mode,
displacement=displacement))
t.append(RunVaspCustodian(vasp_cmd=vasp_cmd))
key = "{}_{}".format(mode,
displacement).replace('-', 'm').replace('.', 'd')
t.append(
pass_vasp_result(pass_dict={
"mode": mode,
"displacement": displacement,
"epsilon": "a>>epsilon_static"
},
mod_spec_key="raman_epsilon->{}".format(key),
parse_eigen=True))
t.append(PassCalcLocs(name=name))
t.append(
VaspToDb(db_file=db_file, additional_fields={"task_label": name}))
super(RamanFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
spec=spec,
**kwargs)
def __init__(self,
structure=None,
mode="cs",
isotopes=None,
name="nmr tensor",
prev_calc_dir=None,
vasp_cmd="vasp",
copy_vasp_outputs=True,
db_file=None,
parents=None,
**kwargs):
"""
Firework for NMR tensor calculations
Args:
structure (Structure): Input structure. If copy_vasp_outputs, used only to set the
name of the FW.
mode (str): the NMR calculation type: cs or efg, default is cs
isotopes (list): list of isotopes to include, default is to include the
lowest mass quadrupolar isotope for all applicable elements
name (str): Name for the Firework.
prev_calc_dir (str): Path to a previous calculation to copy from
vasp_cmd (str): Command to run vasp.
copy_vasp_outputs (bool): Whether to copy outputs from previous
run. Defaults to True.
db_file (str): Path to file specifying db credentials.
parents (Firework): Parents of this particular Firework.
FW or list of FWS.
kwargs: Other kwargs that are passed to Firework.__init__.
"""
fw_name = "{}-{}".format(
structure.composition.reduced_formula if structure else "unknown",
name)
isotopes = isotopes.split() if isinstance(isotopes, str) else isotopes
t = []
if prev_calc_dir:
t.append(
CopyVaspOutputs(calc_dir=prev_calc_dir,
contcar_to_poscar=True))
t.append(
WriteVaspNMRFromPrev(prev_calc_dir=".",
mode=mode,
isotopes=isotopes))
elif parents and copy_vasp_outputs:
t.append(CopyVaspOutputs(calc_loc=True, contcar_to_poscar=True))
t.append(
WriteVaspNMRFromPrev(prev_calc_dir=".",
mode=mode,
isotopes=isotopes))
elif structure:
vasp_input_set = MPNMRSet(structure, mode=mode, isotopes=isotopes)
t.append(
WriteVaspFromIOSet(structure=structure,
vasp_input_set=vasp_input_set))
else:
raise ValueError("Must specify structure or previous calculation.")
t.extend([
RunVaspCustodian(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<"),
PassCalcLocs(name=name),
VaspToDb(db_file=db_file, additional_fields={"task_label": name})
])
super(NMRFW, self).__init__(t, parents=parents, name=fw_name, **kwargs)
