add initial draft of resubmission approach

Author: dbroberg

atomate/vasp/firetasks/defects.py

@@ -235,7 +235,6 @@ def run_task(self, fw_spec):
                     charges = [v.charge for v in SCG]
 
                 def_structs.append({'charges': charges, 'defect': vac.copy()})
-
         else:
             #only create vacancies of interest...
             for elt_type in vacancies:
@@ -345,55 +344,80 @@ def get_charges_from_inter( inter_elt):
                     charges = get_charges_from_inter( elt_val)
                     def_structs.append({'charges': charges, 'defect': elt_val.copy()})
 
-        stdrd_defect_incar_settings = {"EDIFF": 0.0001, "EDIFFG": 0.001, "IBRION":2, "ISMEAR":0, "SIGMA":0.05,
-                                       "ISPIN":2,  "ISYM":2, "LVHAR":True, "LVTOT":True, "NSW": 100,
-                                       "NELM": 60, "ISIF": 2, "LAECHG":False, "LWAVE": True}
-        stdrd_defect_incar_settings.update( user_incar_settings)
 
         # now that def_structs is assembled, set up Transformation FW for all defect + charge combinations
         for defcalc in def_structs:
-            #get defect supercell and defect site for parsing purposes
-            defect = defcalc['defect'].copy()
-            defect_sc = defect.generate_defect_structure( supercell = supercell_size)
-            struct_for_defect_site = Structure(defect.bulk_structure.copy().lattice,
-                                               [defect.site.specie],
-                                               [defect.site.frac_coords],
-                                               to_unit_cell=True, coords_are_cartesian=False)
-            struct_for_defect_site.make_supercell(supercell_size)
-            defect_site = struct_for_defect_site[0]
-
             #iterate over all charges to be run
             for charge in defcalc['charges']:
-                chgdstruct = defect_sc.copy()
-                chgdstruct.set_charge(charge)  #NOTE that the charge will be reflected in NELECT of INCAR because use_structure_charge=True
-
-                reciprocal_density = 100
-                kpoints_settings = user_kpoints_settings if user_kpoints_settings else {"reciprocal_density": reciprocal_density}
-                defect_input_set = MPRelaxSet( chgdstruct,
-                                               user_incar_settings=stdrd_defect_incar_settings.copy(),
-                                               user_kpoints_settings=kpoints_settings,
-                                               use_structure_charge=True)
-
-                defect_for_trans_param = defect.copy()
-                defect_for_trans_param.set_charge(charge)
-                chgdef_trans = ["DefectTransformation"]
-                chgdef_trans_params = [{"scaling_matrix": supercell_size,
-                                        "defect": defect_for_trans_param}]
-                if structure != defect_for_trans_param.bulk_structure:
-                    raise ValueError("Defect bulk_structure is not the same as input structure.")
-
-                def_tag = "{}:{}_{}_{}atoms".format(structure.composition.reduced_formula,
-                                                      defect.name, charge, num_atoms)
-                fw = TransmuterFW( name = def_tag, structure=structure,
-                                   transformations=chgdef_trans,
-                                   transformation_params=chgdef_trans_params,
-                                   vasp_input_set=defect_input_set,
-                                   vasp_cmd=self.get("vasp_cmd", ">>vasp_cmd<<"),
-                                   copy_vasp_outputs=False,
-                                   db_file=self.get("db_file", ">>db_file<<"),
-                                   bandstructure_mode="auto",
-                                   defect_wf_parsing=defect_site)
+                defect = defcalc['defect'].copy()
+                defect.set_charge(charge)
+
+                fw = get_fw_from_defect( defect, supercell_size,
+                                         user_kpoints_settings = user_kpoints_settings,
+                                         user_incar_settings = user_incar_settings
+                                         )
 
                 fws.append(fw)
 
         return FWAction(detours=fws)
+
+
+
+def get_fw_from_defect( defect, supercell_size, user_kpoints_settings = {},
+                        user_incar_settings = {},
+                        db_file='>>db_file<<', vasp_cmd='>>vasp_cmd<<'):
+    """
+    Simple function for grabbing fireworks for a defect, given a supercell_size
+    :param defect:
+    :param supercell_size:
+    :param user_kpoints_settings:
+    :param db_file:
+    :param vasp_cmd:
+    :return:
+    """
+    chgd_sc_struct = defect.generate_defect_structure(supercell=supercell_size)
+
+    reciprocal_density = 100
+
+    kpoints_settings = user_kpoints_settings if user_kpoints_settings else {"reciprocal_density": reciprocal_density}
+
+    # NOTE that the charge will be reflected in NELECT of INCAR because use_structure_charge=True
+    stdrd_defect_incar_settings = {"EDIFF": 0.0001, "EDIFFG": 0.001, "IBRION": 2, "ISMEAR": 0, "SIGMA": 0.05,
+                                   "ISPIN": 2, "ISYM": 2, "LVHAR": True, "LVTOT": True, "NSW": 100,
+                                   "NELM": 60, "ISIF": 2, "LAECHG": False, "LWAVE": True}
+    stdrd_defect_incar_settings.update(user_incar_settings)
+    defect_input_set = MPRelaxSet(chgd_sc_struct,
+                                  user_incar_settings=stdrd_defect_incar_settings.copy(),
+                                  user_kpoints_settings=kpoints_settings,
+                                  use_structure_charge=True)
+
+    # get defect site for parsing purposes
+    struct_for_defect_site = Structure(defect.bulk_structure.copy().lattice,
+                                       [defect.site.specie],
+                                       [defect.site.frac_coords],
+                                       to_unit_cell=True, coords_are_cartesian=False)
+    struct_for_defect_site.make_supercell(supercell_size)
+    defect_site = struct_for_defect_site[0]
+
+    bulk_sc = defect.bulk_structure.copy()
+    bulk_sc.make_supercell( supercell_size)
+    num_atoms = len(bulk_sc)
+
+    chgdef_trans = ["DefectTransformation"]
+    chgdef_trans_params = [{"scaling_matrix": supercell_size,
+                            "defect": defect.copy()}]
+
+    def_tag = "{}:{}_{}_{}atoms".format(defect.bulk_structure.composition.reduced_formula,
+                                        defect.name, defect.charge, num_atoms)
+    fw = TransmuterFW(name=def_tag, structure=defect.bulk_structure,
+                      transformations=chgdef_trans,
+                      transformation_params=chgdef_trans_params,
+                      vasp_input_set=defect_input_set,
+                      vasp_cmd=vasp_cmd,
+                      copy_vasp_outputs=False,
+                      db_file=db_file,
+                      bandstructure_mode="auto",
+                      defect_wf_parsing=defect_site)
+
+    return fw
+

atomate/vasp/workflows/base/defects.py

@@ -20,17 +20,17 @@
 from atomate.vasp.fireworks.core import OptimizeFW, StaticFW, HSEBSFW, DFPTFW
 from atomate.vasp.firetasks.glue_tasks import CopyVaspOutputs
 
-from atomate.vasp.firetasks.defects import DefectSetupFiretask
+from atomate.vasp.firetasks.defects import DefectSetupFiretask, get_fw_from_defect
 
 logger = get_logger(__name__)
 
 
-def get_wf_chg_defects(structure, mpid=None, name="chg_defect_wf", user_incar_settings={},
+def get_wf_chg_defects(structure, name="chg_defect_wf", user_incar_settings={},
                         vasp_cmd=">>vasp_cmd<<", db_file=">>db_file<<",
                         conventional=True, diel_flag=True, n_max=128,
                         vacancies=[], substitutions={}, interstitials={},
                         initial_charges={}, rerelax_flag=False, hybrid_run_for_gap_corr=True,
-                        run_analysis=False, user_kpoints_settings={}):
+                        user_kpoints_settings={}):
     """
     Returns a charged defect workflow
 
@@ -45,7 +45,6 @@ def get_wf_chg_defects(structure, mpid=None, name="chg_defect_wf", user_incar_se
 
     Args:
         structure (Structure): input structure to have defects run on
-        mpid (str): Materials Project id number to be used (for storage in metadata).
         name (str): some appropriate name for the workflow.
         user_incar_settings (dict):
             a dictionary of incar settings specified by user for both bulk and defect supercells
@@ -176,3 +175,96 @@ def get_wf_chg_defects(structure, mpid=None, name="chg_defect_wf", user_incar_se
 
     return final_wf
 
+
+def run_defect_resubmissions( dpd, name="chg_defect_wf", consider_charges=True,
+                              consider_supercells=False, user_incar_settings={},
+                              vasp_cmd=">>vasp_cmd<<", db_file=">>db_file<<",
+                              n_max=400, hybrid_run_for_gap_corr=False,
+                              user_kpoints_settings={}):
+    """
+    This takes a DefectPhaseDiagram object and resubmits additional Defect calculations as needed.
+    Also useful for resubmitting a hybrid calculation and band edge considerations.
+
+    It can do this in two ways:
+        (a) Extra Charge submissions: run any charges suggested for followup by DefectPhaseDiagram
+        (b) Larger supercell submissions: run larger supercells for certain charges as suggested by DefectPhaseDiagram
+
+    Args:
+        dpd (DefectPhaseDiagram): phase diagram to consider for analysis of resubmission jobs
+        name (str): some appropriate name for the workflow.
+        consider_charges (bool): Whether to consider rerunning additional charge states
+            Defaults to True (fireworks generated for additional charge states)
+        consider_supercells (bool): Whether to consider submitting additional supercell sizes
+            Note that when this is True, if there is no bulk_supercell that matches the supercell sizes
+            being submitted, a bulk supercell calculation is also submitted.
+            Defaults to False (will not generate fireworks for additional supercell sizes)
+        user_incar_settings (dict):
+            a dictionary of incar settings specified by user for both bulk and defect supercells
+        vasp_cmd (str): Command to run vasp.
+        db_file (str): path to file containing the database credentials.
+        n_max (int): maximum supercell size to consider for consider_supercells supercell routine
+        hybrid_run_for_gap_corr (bool):
+            Flag to run a single small hybrid bulk structure for band edge shifting correction.
+            Useful if you forgot to run the hybrid in your first
+            Default is False (Hybrid will be calculated)
+        user_kpoints_settings (dict or Kpoints pmg object):
+            a dictionary of kpoint settings specific by user OR an Actual Kpoint set to be used for the
+            supercell calculations
+
+    Returns:
+        Workflow
+    :return:
+    """
+    if not consider_charges and not consider_supercells and not hybrid_run_for_gap_corr:
+        raise ValueError("Ony makes since to run get_defect_resubmissions for resubmissions of "
+                         "charges, supercells or hybrids.")
+
+    fws = []
+
+    if consider_charges:
+        rec_dict = dpd.suggest_charges()
+        for defname, charge_list in rec_dict.items():
+            defect_template = dpd.finished_charges[ defname][0].defect.copy()
+            if "scaling_matrix" in dpd.finished_charges[defname][0].parameters:
+                supercell_size = dpd.finished_charges[defname][0].parameters['scaling_matrix']
+            else:
+                raise ValueError("No scaling_matrix available in {} defect entry! "
+                                 "Cannot submit additional charged defects.".format( defname))
+
+            for charge in charge_list:
+                defect = defect_template.copy()
+                defect.set_charge( charge)
+
+                fw = get_fw_from_defect( defect, supercell_size,
+                                         user_kpoints_settings = user_kpoints_settings,
+                                         user_incar_settings = user_incar_settings,
+                                         db_file=db_file, vasp_cmd=vasp_cmd)
+                fws.append( fw)
+
+    if consider_supercells:
+        rec_dict = dpd.suggest_larger_supercells()
+        for defname, charge_list in rec_dict.items():
+            defect_template = dpd.finished_charges[ defname][0].defect.copy()
+
+            #TODO -> consider next sized supercell size..
+            supercell_size = ?
+
+            for charge in charge_list:
+                defect = defect_template.copy()
+                defect.set_charge( charge)
+
+                fw = get_fw_from_defect( defect, supercell_size,
+                                         user_kpoints_settings = user_kpoints_settings,
+                                         user_incar_settings = user_incar_settings,
+                                         db_file=db_file, vasp_cmd=vasp_cmd)
+                fws.append( fw)
+
+    if not len(fws):
+        print("No fireworks generated from defect resubmission scheme")
+        return None
+    else:
+        bs_struct = dpd.entries[0].defect.bulk_structure.copy()
+        wfname = "{}:{}".format(bs_struct.composition.reduced_formula, name)
+        final_wf = Workflow(fws, name=wfname)
+
+        return final_wf