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 __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 __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 __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)