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 __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,
parents=None,
structure=None,
name="vasp2trace",
db_file=None,
prev_calc_dir=None,
vasp2trace_out=None,
vasp_cmd=None,
**kwargs
):
"""
Run Vasp2Trace on a spin-polarized calculation and parse the output data.
Assumes you have a previous FW with the calc_locs passed into the current FW.
Args:
structure (Structure): - only used for setting name of FW
name (str): name of this FW
db_file (str): path to the db file
parents (Firework): Parents of this particular Firework. FW or list of FWS.
prev_calc_dir (str): Path to a previous calculation to copy from
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
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", "WAVECAR", "PROCAR"],
contcar_to_poscar=True,
)
)
elif parents:
t.append(
CopyVaspOutputs(
calc_loc=True,
additional_files=["CHGCAR", "WAVECAR", "PROCAR"],
contcar_to_poscar=True,
)
)
else:
raise ValueError("Must specify structure or previous calculation")
t.extend(
[
RunVasp2TraceMagnetic(),
PassCalcLocs(name=name),
Vasp2TraceToDb(db_file=db_file, vasp2trace_out=vasp2trace_out),
]
)
super(Vasp2TraceMagneticFW, self).__init__(
t, parents=parents, name=fw_name, **kwargs
)
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 test_getinterpolatedposcar(self):
nimages = 5
this_image = 1
autosort_tol = 0.5
fw1 = Firework([CopyVaspOutputs(calc_dir=self.static_outdir,
contcar_to_poscar=False,
additional_files=["CONTCAR"]),
PassCalcLocs(name="fw1")], name="fw1")
fw2 = Firework([CopyVaspOutputs(calc_dir=self.opt_outdir,
contcar_to_poscar=False,
additional_files=["CONTCAR"]),
PassCalcLocs(name="fw2")], name="fw2")
fw3 = Firework([GetInterpolatedPOSCAR(start="fw1",
end="fw2",
this_image=this_image,
nimages=nimages,
autosort_tol=autosort_tol),
PassCalcLocs(name="fw3")],
name="fw3", parents=[fw1, fw2])
fw4 = Firework([PassCalcLocs(name="fw4")], name="fw4", parents=fw3)
wf = Workflow([fw1, fw2, fw3, fw4])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw4 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw4"})[0])
calc_locs = fw4.spec["calc_locs"]
self.assertTrue(os.path.exists(get_calc_loc("fw3", calc_locs)["path"] +
"/POSCAR"))
self.assertTrue(os.path.exists(get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_0"))
self.assertTrue(os.path.exists(get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_1"))
struct_start = Structure.from_file(get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_0")
struct_end = Structure.from_file(get_calc_loc("fw3", calc_locs)["path"] +
"/interpolate/CONTCAR_1")
struct_inter = Structure.from_file(get_calc_loc("fw3", calc_locs)["path"] +
"/POSCAR")
structs = struct_start.interpolate(struct_end,
nimages,
interpolate_lattices=True,
autosort_tol=autosort_tol)
# Check x of 1st site.
self.assertAlmostEqual(structs[this_image][1].coords[0],
struct_inter[1].coords[0])
# Check c lattice parameter
self.assertAlmostEqual(structs[this_image].lattice.abc[0],
struct_inter.lattice.abc[0])
def __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 test_missing_kpoints_copy(self):
ct = CopyVaspOutputs(calc_dir=self.nokpts_outdir)
ct.run_task({})
files = ["INCAR", "POTCAR", "POSCAR"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL", "KPOINTS"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
def test_relax2_copy(self):
ct = CopyVaspOutputs(calc_dir=self.relax2_outdir, additional_files=["IBZKPT"])
ct.run_task({})
files = ["INCAR", "KPOINTS", "POTCAR", "POSCAR", "IBZKPT"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
def test_gzip_copy(self):
ct = CopyVaspOutputs(calc_dir=self.gzip_outdir)
ct.run_task({})
files = ["INCAR", "KPOINTS", "POTCAR", "POSCAR"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(scratch_dir, f)))
def test_relax2_copy(self):
ct = CopyVaspOutputs(calc_dir=self.relax2_outdir,
additional_files=["IBZKPT"])
ct.run_task({})
files = ["INCAR", "KPOINTS", "POTCAR", "POSCAR", "IBZKPT"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
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,
parents=None,
structure=None,
name="standardize",
db_file=None,
prev_calc_dir=None,
vasp_cmd=None,
**kwargs
):
"""
Standardize the structure with spglib.
Args:
structure (Structure): pmg structure.
name (str): name of this FW
db_file (str): path to the db file
parents (Firework): Parents of this particular Firework. FW or list of FWS.
prev_calc_dir (str): Path to a previous calculation to copy from
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
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,
contcar_to_poscar=True,
)
)
elif parents:
t.append(
CopyVaspOutputs(
calc_loc=True,
contcar_to_poscar=True,
)
)
else:
raise ValueError("Must specify structure or previous calculation")
t.extend(
[
StandardizeCell(),
PassCalcLocs(name=name),
]
)
super(StandardizeFW, self).__init__(t, parents=parents, name=fw_name, **kwargs)
def test_copyfilesfromcalcloc(self):
fw1 = Firework(
[
CopyVaspOutputs(calc_dir=self.plain_outdir),
PassCalcLocs(name="fw1")
],
name="fw1",
)
fw2 = Firework(
[
CopyVaspOutputs(calc_dir=self.relax2_outdir),
PassCalcLocs(name="fw2")
],
name="fw2",
)
fw3 = Firework(
[
CopyFilesFromCalcLoc(
calc_loc="fw1",
filenames=["POSCAR"],
name_prepend="",
name_append="_0",
),
CopyFilesFromCalcLoc(
calc_loc="fw2",
filenames=["POSCAR"],
name_prepend="",
name_append="_1",
),
PassCalcLocs(name="fw3"),
],
name="fw3",
parents=[fw1, fw2],
)
fw4 = Firework([PassCalcLocs(name="fw4")], name="fw4", parents=fw3)
wf = Workflow([fw1, fw2, fw3, fw4])
self.lp.add_wf(wf)
rapidfire(self.lp)
fw4 = self.lp.get_fw_by_id(self.lp.get_fw_ids({"name": "fw4"})[0])
calc_locs = fw4.spec["calc_locs"]
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR_0"))
self.assertTrue(
os.path.exists(
get_calc_loc("fw3", calc_locs)["path"] + "/POSCAR_1"))
def test_plain_copy(self):
ct = CopyVaspOutputs(calc_dir=self.plain_outdir)
ct.run_task({})
files = ["INCAR", "KPOINTS", "POSCAR", "POTCAR", "OUTCAR"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL", "IBZKPT"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
# make sure CONTCAR was copied properly
with open(os.path.join(self.plain_outdir, "CONTCAR")) as f1:
with open(os.path.join(self.scratch_dir, "POSCAR")) as f2:
self.assertEqual(f1.read(), f2.read())
def test_plain_copy(self):
ct = CopyVaspOutputs(calc_dir=self.plain_outdir)
ct.run_task({})
files = ["INCAR", "KPOINTS", "POSCAR", "POTCAR", "OUTCAR"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL", "IBZKPT"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
# make sure CONTCAR was copied properly
with open(os.path.join(self.plain_outdir, "CONTCAR")) as f1:
with open(os.path.join(self.scratch_dir, "POSCAR")) as f2:
self.assertEqual(f1.read(), f2.read())
def __init__(self, structure, supercell_matrix, t_min=5, t_max=2000, t_step=5,
name="phonon", vasp_input_set=None, override_default_vasp_params=None,
vasp_cmd="vasp", metadata=None, tag=None, qpoint_mesh=(50, 50, 50),
prev_calc_loc=True, db_file=None, parents=None, stable_tor=0.01,
**kwargs):
metadata = metadata or {}
tag = tag or metadata.get('tag')
# generate a tag with a warning
if tag is None:
tag = str(uuid4())
warnings.warn('No ``tag`` was passed explicitly or in ``metadata`` to PhononFW. In order to find this Firework later, you should assign one. This was assigned: {}'.format(tag))
metadata['tag'] = tag
override_default_vasp_params = override_default_vasp_params or {}
ncell = int(0.5+np.linalg.det(supercell_matrix))
tmp = copy.deepcopy(override_default_vasp_params)
if 'user_incar_settings' in tmp:
if 'magmom' in tmp['user_incar_settings']:
mag = tmp['user_incar_settings']['magmom']
supermag = []
for site in mag:
n = str(site).split('*')
if len(n)==1:
supermag.append('{}*{}'.format(ncell,float(n[0])))
else:
supermag.append('{}*{}'.format(ncell*int(n[0]),float(n[1])))
tmp['user_incar_settings']['magmom']=supermag
print("phonon setting", tmp)
vasp_input_set = vasp_input_set or ForceConstantsSet(structure, **tmp)
supercell_structure = deepcopy(structure)
supercell_structure.make_supercell(supercell_matrix)
supercell_site_properties = deepcopy(supercell_structure.site_properties)
t = []
# We need to get the POSCAR from the previous run or from the passed Structure
# so it can be transformed to a supercell in the next step
if parents:
if prev_calc_loc:
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=True))
else:
# write the input set first, just to get the POSCAR file in the directory
# the other inputs will get overridden by WriteVaspFromIOSetPrevStructure
t.append(WriteVaspFromIOSetPrevStructure(structure=structure, vasp_input_set=vasp_input_set, site_properties=site_properties))
t.append(SupercellTransformation(supercell_matrix=supercell_matrix))
t.append(WriteVaspFromIOSetPrevStructure(vasp_input_set=vasp_input_set, site_properties=supercell_site_properties))
t.append(RunVaspCustodianNoValidate(vasp_cmd=vasp_cmd, auto_npar=">>auto_npar<<", gzip_output=False))
# we skipped the validation so we can potentially fix the vasprun.xml file.
# Fix and validate here.
t.append(PyTask(func='dfttk.vasprun_fix.fix_vasprun', args=['vasprun.xml']))
t.append(PassCalcLocs(name=name))
t.append(CalculatePhononThermalProperties(supercell_matrix=supercell_matrix, t_min=t_min, t_max=t_max, t_step=t_step, db_file=">>db_file<<", tag=tag, metadata=metadata))
t.append(PhononStable(supercell_matrix=supercell_matrix, db_file=">>db_file<<", tag=tag, metadata=metadata, qpoint_mesh=qpoint_mesh, stable_tor=stable_tor))
super(PhononFW, 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",
copy_vasp_outputs=True, db_file=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.
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.
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
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",
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=fw_name, **kwargs)
def test_plain_copy_more(self):
ct = CopyVaspOutputs(calc_dir=self.plain_outdir,
contcar_to_poscar=False,
additional_files=["IBZKPT"])
ct.run_task({})
files = ["INCAR", "KPOINTS", "POSCAR", "POTCAR", "IBZKPT"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
# make sure CONTCAR was NOT copied and POSCAR was instead copied
with open(os.path.join(self.plain_outdir, "POSCAR")) as f1:
with open(os.path.join(self.scratch_dir, "POSCAR")) as f2:
self.assertEqual(f1.read(), f2.read())
def test_plain_copy_more(self):
ct = CopyVaspOutputs(calc_dir=self.plain_outdir,
contcar_to_poscar=False,
additional_files=["IBZKPT"])
ct.run_task({})
files = ["INCAR", "KPOINTS", "POSCAR", "POTCAR", "IBZKPT"]
for f in files:
self.assertTrue(os.path.exists(os.path.join(self.scratch_dir, f)))
no_files = ["CONTCAR", "EIGENVAL"]
for f in no_files:
self.assertFalse(os.path.exists(os.path.join(self.scratch_dir, f)))
# make sure CONTCAR was NOT copied and POSCAR was instead copied
with open(os.path.join(self.plain_outdir, "POSCAR")) as f1:
with open(os.path.join(self.scratch_dir, "POSCAR")) as f2:
self.assertEqual(f1.read(), f2.read())
def __init__(self,
parents=None,
structure=None,
name="pyzfs",
prev_calc_dir=None,
pyzfs_cmd=">>pyzfs_cmd<<",
db_file=DB_FILE,
pyzfstodb_kwargs=None,
**kwargs):
fw_name = "{}-{}".format(
structure.composition.reduced_formula if structure else "unknown",
name)
pyzfstodb_kwargs = pyzfstodb_kwargs or {}
if "additional_fields" not in pyzfstodb_kwargs:
pyzfstodb_kwargs["additional_fields"] = {}
pyzfstodb_kwargs["additional_fields"]["task_label"] = name
t = []
if prev_calc_dir:
t.append(
CopyVaspOutputs(
calc_dir=prev_calc_dir,
additional_files=["WAVECAR"],
contcar_to_poscar=True,
))
elif parents:
t.append(
CopyVaspOutputs(
calc_loc=True,
additional_files=["WAVECAR"],
contcar_to_poscar=True,
))
else:
raise ValueError("Must specify structure or previous calculation")
t.append(RunPyzfs(pyzfs_cmd=pyzfs_cmd))
t.append(PassCalcLocs(name=name))
t.append(PyzfsToDb(db_file=db_file, **pyzfstodb_kwargs))
super(PyzfsFW, self).__init__(t,
parents=parents,
name=fw_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,
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, magmom, structure=None, name="spin-orbit coupling",
saxis=(0, 0, 1), prev_calc_dir=None,
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.
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)
t = []
if prev_calc_dir:
t.append(CopyVaspOutputs(calc_dir=prev_calc_dir, additional_files=["CHGCAR"], contcar_to_poscar=True))
t.append(WriteVaspSOCFromPrev(prev_calc_dir=".", magmom=magmom,
saxis=saxis))
elif parents and 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))
elif structure:
vasp_input_set = MPSOCSet(structure)
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(SOCFW, self).__init__(t, parents=parents, name=fw_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, 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 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, name="infdet", input_set=None, metadata=None, prev_calc_loc=True,
db_file=None, parents=None, continuation=False, run_isif2=False, pass_isif4=False, **kwargs):
metadata = metadata or {}
input_set = input_set or ATATIDSet(structure)
t = []
if not continuation:
# Copy the volume relax CONTCAR to POSCAR and the full relax CONTCAR as CONTCAR. Get the CHGCAR and WAVECAR from the fully relaxed structure
# There are other ways to do this, but it's important to pay attention
# to the order so that work is not destoryed because CopyVaspOutputs
# will always give back a POSCAR (or CONTCAR as POSCAR), KPOINTS, INCAR, POTCAR, OUTCAR, and
# vasprun.xml.
# What we do here ensures that
# 1. We get the the WAVECAR and CHGCAR from the full relax
# 2. We do not overwrite the structure that we took from the full relax when we copy the volume relax
t.append(CopyVaspOutputs(calc_loc='Full relax', contcar_to_poscar=False, additional_files=["CONTCAR"]))
t.append(CopyVaspOutputs(calc_loc='Volume relax', contcar_to_poscar=True))
# Move the volume relaxed POSCAR to str_beg.out
t.append(TransmuteStructureFile(input_fname='POSCAR', output_fname='str_beg.out'))
# Move the fully relaxed CONTCAR to str_end.out
t.append(TransmuteStructureFile(input_fname='CONTCAR', output_fname='str_end.out'))
# write the vaspid.wrap file
t.append(WriteATATFromIOSet(input_set=input_set))
else:
# Copy all the files from the previous run.
files_needed = ['CONTCAR', 'str_beg.out', 'str_end.out', 'str_relax.out', 'epipos.out', 'epidir.out',
'epipos.out', 'infdet.log', 'str_current.out']
t.append(CopyVaspOutputs(calc_loc=prev_calc_loc, contcar_to_poscar=False, additional_files=files_needed))
# Unfortunately, it seems that PassCalcLocs must happen before
# running ATAT because it can return a FW action that is dynamic and will
# skip the remaining Firetasks. We don't really want to do this (I think)
# because if this fizzles, the calc_locs will still be changed if this is rerun.
t.append(PassCalcLocs(name=name))
# Run ATAT's inflection detection
t.append(RunATATCustodian(continuation=continuation, name=name))
t.append(Record_relax_running_path(db_file = ">>db_file<<", metadata = metadata, run_isif2=run_isif2, pass_isif4=pass_isif4))
super(InflectionDetectionFW, self).__init__(t, parents=parents,
name="{}-{}".format(structure.composition.reduced_formula, name), **kwargs)
def __init__(self, parents=None, structure=None, name="boltztrap", db_file=None,
scissor=0.0, doping=None, tmax=1300, tgrid=50, prev_calc_dir=None,
soc=False, additional_fields=None, **kwargs):
"""
Run Boltztrap (which includes writing bolztrap input files and parsing outputs). Assumes
you have a previous FW with the calc_locs passed into the current FW.
Args:
structure (Structure): - only used for setting name of FW
name (str): name of this FW
db_file (str): path to the db file
parents (Firework): Parents of this particular Firework. FW or list of FWS.
prev_calc_dir (str): Path to a previous calculation to copy from
scissor (float): if scissor > 0, apply scissor on the band structure so that new
band gap = scissor (in eV)
doping: ([float]) doping levels you want to compute
tmax: (float) max temperature to evaluate
tgrid: (float) temperature interval
soc (bool): whether the band structure is calculated with spin-orbit coupling
additional_fields (dict): fields added to the document such as user-defined tags or name, ids, etc
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
fw_name = "{}-{}".format(structure.composition.reduced_formula if structure else "unknown", name)
additional_fields = additional_fields 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 structure or previous calculation")
t.extend([RunBoltztrap(scissor=scissor, soc=soc, doping=doping, tmax=tmax, tgrid=tgrid),
BoltztrapToDb(db_file=db_file, additional_fields=additional_fields),
PassCalcLocs(name=name)])
super(BoltztrapFW, self).__init__(t, parents=parents, name=fw_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,
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,
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,
name="boltztrap",
db_file=None,
parents=None,
scissor=0.0,
soc=False,
additional_fields=None,
**kwargs):
"""
Run Boltztrap (which includes writing bolztrap input files and parsing outputs). Assumes
you have a previous FW with the calc_locs passed into the current FW.
Args:
structure (Structure): - only used for setting name of FW
name (str): name of this FW
db_file (str): path to the db file
parents (Firework): Parents of this particular Firework. FW or list of FWS.
scissor (float): if scissor > 0, apply scissor on the band structure so that new
band gap = scissor (in eV)
soc (bool): whether the band structure is calculated with spin-orbit coupling
additional_fields (dict): fields added to the document such as user-defined tags or name, ids, etc
\*\*kwargs: Other kwargs that are passed to Firework.__init__.
"""
additional_fields = additional_fields or {}
t = [
CopyVaspOutputs(calc_loc=True, contcar_to_poscar=True),
RunBoltztrap(scissor=scissor, soc=soc),
BoltztrapToDb(db_file=db_file,
additional_fields=additional_fields),
PassCalcLocs(name=name)
]
super(BoltztrapFW,
self).__init__(t,
parents=parents,
name="{}-{}".format(
structure.composition.reduced_formula, name),
**kwargs)
