예제 #1
0
 def test_runs_assimilate(self):
     drone = VaspDrone(runs=["relax1", "relax2"])
     doc = drone.assimilate(self.relax2)
     oszicar2 = Oszicar(os.path.join(self.relax2, "OSZICAR.relax2.gz"))
     outcar1 = Outcar(os.path.join(self.relax2, "OUTCAR.relax1.gz"))
     outcar2 = Outcar(os.path.join(self.relax2, "OUTCAR.relax2.gz"))
     outcar1 = outcar1.as_dict()
     outcar2 = outcar2.as_dict()
     run_stats1 = outcar1.pop("run_stats")
     run_stats2 = outcar2.pop("run_stats")
     self.assertEqual(len(doc["calcs_reversed"]), 2)
     self.assertEqual(doc["composition_reduced"], {"Si": 1.0})
     self.assertEqual(doc["composition_unit_cell"], {"Si": 2.0})
     self.assertAlmostEqual(doc["output"]["energy"], oszicar2.ionic_steps[-1]["E0"])
     self.assertEqual(doc["formula_pretty"], "Si")
     self.assertEqual(doc["formula_anonymous"], "A")
     self.assertEqual(
         list(doc["calcs_reversed"][0]["input"].keys()),
         list(doc["calcs_reversed"][1]["input"].keys()),
     )
     self.assertEqual(
         list(doc["calcs_reversed"][0]["output"].keys()),
         list(doc["calcs_reversed"][1]["output"].keys()),
     )
     self.assertEqual(
         doc["calcs_reversed"][0]["output"]["energy"], doc["output"]["energy"]
     )
     self.assertEqual(
         doc["run_stats"][doc["calcs_reversed"][0]["task"]["name"]], run_stats2
     )
     self.assertEqual(
         doc["run_stats"][doc["calcs_reversed"][1]["task"]["name"]], run_stats1
     )
     self.assertEqual(doc["calcs_reversed"][0]["output"]["outcar"], outcar2)
     self.assertEqual(doc["calcs_reversed"][1]["output"]["outcar"], outcar1)
예제 #2
0
 def check(self):
     try:
         oszicar = Oszicar(self.output_filename)
         if oszicar.final_energy > 0:
             return True
     except:
         pass
     return False
예제 #3
0
 def check(self):
     try:
         oszicar = Oszicar(self.output_filename)
         n = len(Poscar.from_file(self.input_filename).structure)
         max_dE = max([s['dE'] for s in oszicar.ionic_steps[1:]]) / n
         if max_dE > self.dE_threshold:
             return True
     except:
         return False
예제 #4
0
def prep_ml_formation_energy(fileroot="."):
    """
    writes .poscar and .energy files with index information for use in model training

    Parameters
    ----------
    """
    n = 100  # number of steps to sample
    i = 0
    for a in os.walk("."):
        directory = a[0]
        s_extension = "poscar"
        e_extension = "energy"
        prefix = ""  # prefix for files, e.g. name of structure
        # e.g. "[root]/[prefix][i].[poscar]" where i=1,2,...,n
        try:
            s_list = Xdatcar(directory + "/XDATCAR").structures
            e_list = [
                step["E0"]
                for step in Oszicar(directory + "/OSZICAR").ionic_steps
            ]
            if n < len(s_list) - 1:
                # the idea here is to obtain a subset of n energies
                # such that the energies are as evenly-spaced as possible
                # we do this in energy-space not in relaxation-space
                # because energies drop fast and then level off
                idx_to_keep = []
                fitting_data = np.array(
                    e_list)[:, np.newaxis]  # kmeans expects 2D
                kmeans_model = KMeans(n_clusters=n)
                kmeans_model.fit(fitting_data)
                cluster_centers = sorted(
                    kmeans_model.cluster_centers_.flatten())
                for centroid in cluster_centers:
                    closest_idx = np.argmin(np.subtract(e_list, centroid)**2)
                    idx_to_keep.append(closest_idx)
                idx_to_keep[-1] = len(e_list) - 1  # replace the last
                idx_list = np.arange(len(s_list))
                idx_batched = np.array_split(idx_list[:-1], n)
                idx_kept = [batch[0] for batch in idx_batched]
                idx_kept.append(idx_list[-1])
            else:
                idx_kept = np.arange(len(e_list))

            for j, idx in enumerate(idx_kept):
                filestem = str(j)
                i2 = str(i)
                s_filename = "{}/{}{}_{}.{}".format(fileroot, prefix, i2,
                                                    filestem, s_extension)
                e_filename = "{}/{}{}_{}.{}".format(fileroot, prefix, i2,
                                                    filestem, e_extension)
                s_list[idx].to(fmt="poscar", filename=s_filename)
                with open(e_filename, "w") as f:
                    f.write(str(e_list[idx]))
            i = i + 1
        except:
            print("noFile")
예제 #5
0
def prep_ml_formation_energy(calculation, fileroot='.'):
    os.mkdir('formation_energy')
    os.chdir('formation_energy')
    urlo = ('http://2d' + calculation['path'][9:21] + '.org/' +
            calculation['path'][22:] + '/OSZICAR')
    fileo = urllib.request.urlopen(urlo)
    urlx = ('http://2d' + calculation['path'][9:21] + '.org/' +
            calculation['path'][22:] + '/XDATCAR')
    filex = urllib.request.urlopen(urlx)
    with open('OsZICAR', 'a') as oszicar:
        for line in fileo:
            decoded_line = line.decode("utf-8")
            oszicar.write(decoded_line)

    with open('XdATCAR', 'a') as xdatcar:
        for line in filex:
            decoded_line = line.decode("utf-8")
            xdatcar.write(decoded_line)

    n = 100  # number of steps to sample
    s_extension = 'poscar'
    e_extension = 'energy'
    prefix = ''  # prefix for files, e.g. name of structure
    # e.g. "[root]/[prefix][i].[poscar]" where i=1,2,...,n
    s_list = Xdatcar('XdATCAR').structures
    e_list = [step['E0'] for step in Oszicar('OsZICAR').ionic_steps]
    if n < len(s_list) - 1:
        # the idea here is to obtain a subset of n energies
        # such that the energies are as evenly-spaced as possible
        # we do this in energy-space not in relaxation-space
        # because energies drop fast and then level off
        idx_to_keep = []
        fitting_data = np.array(e_list)[:, np.newaxis]  # kmeans expects 2D
        kmeans_model = KMeans(n_clusters=n)
        kmeans_model.fit(fitting_data)
        cluster_centers = sorted(kmeans_model.cluster_centers_.flatten())
        for centroid in cluster_centers:
            closest_idx = np.argmin(np.subtract(e_list, centroid)**2)
            idx_to_keep.append(closest_idx)
        idx_to_keep[-1] = len(e_list) - 1  # replace the last
        idx_list = np.arange(len(s_list))
        idx_batched = np.array_split(idx_list[:-1], n)
        idx_kept = [batch[0] for batch in idx_batched]
        idx_kept.append(idx_list[-1])
    else:
        idx_kept = np.arange(len(e_list))

    for j, idx in enumerate(idx_kept):
        filestem = str(j)
        s_filename = '{}/{}{}.{}'.format(fileroot, prefix, filestem,
                                         s_extension)
        e_filename = '{}/{}{}.{}'.format(fileroot, prefix, filestem,
                                         e_extension)
        s_list[idx].to(fmt='poscar', filename=s_filename)
        with open(e_filename, 'w') as f:
            f.write(str(e_list[idx]))
예제 #6
0
    def check(self):
        if self.wall_time:
            run_time = datetime.datetime.now() - self.start_time
            total_secs = run_time.total_seconds()
            if not self.electronic_step_stop:
                try:
                    # Intelligently determine time per ionic step.
                    o = Oszicar("OSZICAR")
                    nsteps = len(o.ionic_steps)
                    time_per_step = total_secs / nsteps
                except Exception:
                    time_per_step = 0
            else:
                try:
                    # Intelligently determine approximate time per electronic
                    # step.
                    o = Oszicar("OSZICAR")
                    if len(o.ionic_steps) == 0:
                        nsteps = 0
                    else:
                        nsteps = sum(map(len, o.electronic_steps))
                    if nsteps > self.prev_check_nscf_steps:
                        steps_time = datetime.datetime.now() - \
                            self.prev_check_time
                        steps_secs = steps_time.total_seconds()
                        step_timing = self.buffer_time * ceil(
                            (steps_secs /
                             (nsteps - self.prev_check_nscf_steps)) /
                            self.buffer_time)
                        self.electronic_steps_timings.append(step_timing)
                        self.prev_check_nscf_steps = nsteps
                        self.prev_check_time = datetime.datetime.now()
                    time_per_step = max(self.electronic_steps_timings)
                except Exception as ex:
                    time_per_step = 0

            # If the remaining time is less than average time for 3 ionic
            # steps or buffer_time.
            time_left = self.wall_time - total_secs
            if time_left < max(time_per_step * 3, self.buffer_time):
                return True

        return False
예제 #7
0
 def check(self):
     vi = VaspInput.from_directory(".")
     nelm = vi["INCAR"].get("NELM", 60)
     try:
         oszicar = Oszicar(self.output_filename)
         esteps = oszicar.electronic_steps
         if len(esteps) > self.nionic_steps:
             return all([len(e) == nelm
                         for e in esteps[-(self.nionic_steps + 1):-1]])
     except:
         pass
     return False
예제 #8
0
def make_energy_mag_yamls():

    filename_e = "../mp_atom_energy.yaml"
    filename_m = "../mp_atom_mag.yaml"
    try:
        os.remove(filename_e)
    except FileNotFoundError:
        pass
    try:
        os.remove(filename_m)
    except FileNotFoundError:
        pass

    energies = []
    mags = []
    for e in Element:
        # Z(Pr) = 59, Z(Yb) = 70, Z(Pa) = 91, Z(No) = 102
        if 59 <= e.Z <= 70 or 84 <= e.Z:
            continue

        if e == Element.Ti:
            d = "algo_n/Ti_mag2"
        elif e == Element.La:
            d = "algo_n/La_mag1"
        elif str(e) in [
                "B", "P", "Ce", "Co", "Fe", "Ni", "Sb", "Si", "Tc", "Th"
        ]:
            d = f"algo_n/{e}"
        else:
            d = f"algo_d/{e}"

        o = Oszicar(Path(d) / "OSZICAR")

        s = str(e) + ':'
        energies.append(f"{s:<3} {o.final_energy:11.8f}")
        mags.append(f"{s:<3} {abs(o.ionic_steps[-1]['mag']):5.2f}")

    Path(filename_e).write_text("\n".join(energies))
    Path(filename_m).write_text("\n".join(mags))
예제 #9
0
    def correct(self):
        backup(VASP_BACKUP_FILES | {self.output_filename})
        actions = []
        vi = VaspInput.from_directory(".")

        if self.errors.intersection(["tet", "dentet"]):
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"ISMEAR": 0}}})

        if "inv_rot_mat" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"SYMPREC": 1e-8}}})

        if "brmix" in self.errors:
            # If there is not a valid OUTCAR already, increment
            # error count to 1 to skip first fix
            if self.error_count['brmix'] == 0:
                try:
                    assert (Outcar(zpath(os.path.join(
                        os.getcwd(), "OUTCAR"))).is_stopped is False)
                except:
                    self.error_count['brmix'] += 1

            if self.error_count['brmix'] == 0:
                # Valid OUTCAR - simply rerun the job and increment
                # error count for next time
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ISTART": 1}}})
                self.error_count['brmix'] += 1

            elif self.error_count['brmix'] == 1:
                # Use Kerker mixing w/default values for other parameters
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"IMIX": 1}}})
                self.error_count['brmix'] += 1

            elif self.error_count['brmix'] == 2 and vi["KPOINTS"].style \
                    == Kpoints.supported_modes.Gamma:
                actions.append({"dict": "KPOINTS",
                                "action": {"_set": {"generation_style":
                                                        "Monkhorst"}}})
                actions.append({"dict": "INCAR",
                                "action": {"_unset": {"IMIX": 1}}})
                self.error_count['brmix'] += 1

            elif self.error_count['brmix'] in [2, 3] and vi["KPOINTS"].style \
                    == Kpoints.supported_modes.Monkhorst:
                actions.append({"dict": "KPOINTS",
                                "action": {"_set": {"generation_style":
                                                        "Gamma"}}})
                actions.append({"dict": "INCAR",
                                "action": {"_unset": {"IMIX": 1}}})
                self.error_count['brmix'] += 1

                if vi["KPOINTS"].num_kpts < 1:
                    all_kpts_even = all([
                        bool(n % 2 == 0) for n in vi["KPOINTS"].kpts[0]
                    ])
                    print("all_kpts_even = {}".format(all_kpts_even))
                    if all_kpts_even:
                        new_kpts = (
                            tuple(n + 1 for n in vi["KPOINTS"].kpts[0]),)
                        print("new_kpts = {}".format(new_kpts))
                        actions.append({"dict": "KPOINTS", "action": {"_set": {
                            "kpoints": new_kpts
                        }}})

            else:
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ISYM": 0}}})

                if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                    actions.append({"dict": "KPOINTS",
                                    "action": {
                                        "_set": {"generation_style": "Gamma"}}})

                # Based on VASP forum's recommendation, you should delete the
                # CHGCAR and WAVECAR when dealing with this error.
                if vi["INCAR"].get("ICHARG", 0) < 10:
                    actions.append({"file": "CHGCAR",
                                    "action": {
                                        "_file_delete": {'mode': "actual"}}})
                    actions.append({"file": "WAVECAR",
                                    "action": {
                                        "_file_delete": {'mode': "actual"}}})

        if "zpotrf" in self.errors:
            # Usually caused by short bond distances. If on the first step,
            # volume needs to be increased. Otherwise, it was due to a step
            # being too big and POTIM should be decreased.  If a static run
            # try turning off symmetry.
            try:
                oszicar = Oszicar("OSZICAR")
                nsteps = len(oszicar.ionic_steps)
            except:
                nsteps = 0

            if nsteps >= 1:
                potim = float(vi["INCAR"].get("POTIM", 0.5)) / 2.0
                actions.append(
                    {"dict": "INCAR",
                     "action": {"_set": {"ISYM": 0, "POTIM": potim}}})
            elif vi["INCAR"].get("NSW", 0) == 0 \
                    or vi["INCAR"].get("ISIF", 0) in range(3):
                actions.append(
                    {"dict": "INCAR", "action": {"_set": {"ISYM": 0}}})
            else:
                s = vi["POSCAR"].structure
                s.apply_strain(0.2)
                actions.append({"dict": "POSCAR",
                                "action": {"_set": {"structure": s.as_dict()}}})

            # Based on VASP forum's recommendation, you should delete the
            # CHGCAR and WAVECAR when dealing with this error.
            if vi["INCAR"].get("ICHARG", 0) < 10:
                actions.append({"file": "CHGCAR",
                                "action": {"_file_delete": {'mode': "actual"}}})
                actions.append({"file": "WAVECAR",
                                "action": {"_file_delete": {'mode': "actual"}}})

        if self.errors.intersection(["subspacematrix", "rspher",
                                     "real_optlay", "nicht_konv"]):
            s = vi["POSCAR"].structure
            if len(s) < self.natoms_large_cell:
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"LREAL": False}}})
            else:
                # for large supercell, try an in-between option LREAL = True
                # prior to LREAL = False
                if self.error_count['real_optlay'] == 0:
                    # use real space projectors generated by pot
                    actions.append({"dict": "INCAR",
                                    "action": {"_set": {"LREAL": True}}})
                    self.error_count['real_optlay'] += 1
                elif self.error_count['real_optlay'] == 1:
                    actions.append({"dict": "INCAR",
                                    "action": {"_set": {"LREAL": False}}})
                    self.error_count['real_optlay'] += 1

        if self.errors.intersection(["tetirr", "incorrect_shift"]):

            if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                actions.append({"dict": "KPOINTS",
                                "action": {
                                    "_set": {"generation_style": "Gamma"}}})

        if "rot_matrix" in self.errors:
            if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                actions.append({"dict": "KPOINTS",
                                "action": {
                                    "_set": {"generation_style": "Gamma"}}})
            else:
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ISYM": 0}}})

        if "amin" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"AMIN": "0.01"}}})

        if "triple_product" in self.errors:
            s = vi["POSCAR"].structure
            trans = SupercellTransformation(((1, 0, 0), (0, 0, 1), (0, 1, 0)))
            new_s = trans.apply_transformation(s)
            actions.append({"dict": "POSCAR",
                            "action": {"_set": {"structure": new_s.as_dict()}},
                            "transformation": trans.as_dict()})

        if "pricel" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"SYMPREC": 1e-8, "ISYM": 0}}})

        if "brions" in self.errors:
            potim = float(vi["INCAR"].get("POTIM", 0.5)) + 0.1
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"POTIM": potim}}})

        if "zbrent" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"IBRION": 1}}})
            actions.append({"file": "CONTCAR",
                            "action": {"_file_copy": {"dest": "POSCAR"}}})

        if "too_few_bands" in self.errors:
            if "NBANDS" in vi["INCAR"]:
                nbands = int(vi["INCAR"]["NBANDS"])
            else:
                with open("OUTCAR") as f:
                    for line in f:
                        if "NBANDS" in line:
                            try:
                                d = line.split("=")
                                nbands = int(d[-1].strip())
                                break
                            except (IndexError, ValueError):
                                pass
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"NBANDS": int(1.1 * nbands)}}})

        if "pssyevx" in self.errors:
            actions.append({"dict": "INCAR", "action":
                {"_set": {"ALGO": "Normal"}}})
        if "eddrmm" in self.errors:
            # RMM algorithm is not stable for this calculation
            if vi["INCAR"].get("ALGO", "Normal") in ["Fast", "VeryFast"]:
                actions.append({"dict": "INCAR", "action":
                    {"_set": {"ALGO": "Normal"}}})
            else:
                potim = float(vi["INCAR"].get("POTIM", 0.5)) / 2.0
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"POTIM": potim}}})
            if vi["INCAR"].get("ICHARG", 0) < 10:
                actions.append({"file": "CHGCAR",
                                "action": {"_file_delete": {'mode': "actual"}}})
                actions.append({"file": "WAVECAR",
                                "action": {"_file_delete": {'mode': "actual"}}})

        if "edddav" in self.errors:
            if vi["INCAR"].get("ICHARG", 0) < 10:
                actions.append({"file": "CHGCAR",
                                "action": {"_file_delete": {'mode': "actual"}}})
            actions.append({"dict": "INCAR", "action":
                {"_set": {"ALGO": "All"}}})

        if "grad_not_orth" in self.errors:
            if vi["INCAR"].get("ISMEAR", 1) < 0:
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ISMEAR": "0"}}})

        if "zheev" in self.errors:
            if vi["INCAR"].get("ALGO", "Fast").lower() != "exact":
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ALGO": "Exact"}}})
        if "elf_kpar" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"KPAR": 1}}})

        if "rhosyg" in self.errors:
            if vi["INCAR"].get("SYMPREC", 1e-4) == 1e-4:
                actions.append({"dict": "INCAR",
                                "action": {"_set": {"ISYM": 0}}})
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"SYMPREC": 1e-4}}})

        if "posmap" in self.errors:
            actions.append({"dict": "INCAR",
                            "action": {"_set": {"SYMPREC": 1e-6}}})

        VaspModder(vi=vi).apply_actions(actions)
        return {"errors": list(self.errors), "actions": actions}
예제 #10
0
    def correct(self):
        backup(VASP_BACKUP_FILES | {self.output_filename})
        actions = []
        vi = VaspInput.from_directory(".")

        if self.errors.intersection(["tet", "dentet"]):
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "ISMEAR": 0
                    }
                }
            })

        if "inv_rot_mat" in self.errors:
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "SYMPREC": 1e-8
                    }
                }
            })

        if "brmix" in self.errors:

            if self.error_count['brmix'] == 0 and vi[
                    "KPOINTS"].style == Kpoints.supported_modes.Gamma:
                actions.append({
                    "dict": "KPOINTS",
                    "action": {
                        "_set": {
                            "generation_style": "Monkhorst"
                        }
                    }
                })
                self.error_count['brmix'] += 1

            elif self.error_count['brmix'] <= 1 and vi[
                    "KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                actions.append({
                    "dict": "KPOINTS",
                    "action": {
                        "_set": {
                            "generation_style": "Gamma"
                        }
                    }
                })
                self.error_count['brmix'] += 1

                if vi["KPOINTS"].num_kpts < 1:
                    all_kpts_even = all(
                        [bool(n % 2 == 0) for n in vi["KPOINTS"].kpts[0]])
                    print("all_kpts_even = {}".format(all_kpts_even))
                    if all_kpts_even:
                        new_kpts = (tuple(n + 1
                                          for n in vi["KPOINTS"].kpts[0]), )
                        print("new_kpts = {}".format(new_kpts))
                        actions.append({
                            "dict": "KPOINTS",
                            "action": {
                                "_set": {
                                    "kpoints": new_kpts
                                }
                            }
                        })

            else:
                actions.append({
                    "dict": "INCAR",
                    "action": {
                        "_set": {
                            "ISYM": 0
                        }
                    }
                })

                if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                    actions.append({
                        "dict": "KPOINTS",
                        "action": {
                            "_set": {
                                "generation_style": "Gamma"
                            }
                        }
                    })

                # Based on VASP forum's recommendation, you should delete the
                # CHGCAR and WAVECAR when dealing with this error.
                actions.append({
                    "file": "CHGCAR",
                    "action": {
                        "_file_delete": {
                            'mode': "actual"
                        }
                    }
                })
                actions.append({
                    "file": "WAVECAR",
                    "action": {
                        "_file_delete": {
                            'mode': "actual"
                        }
                    }
                })

        if "zpotrf" in self.errors:
            # Usually caused by short bond distances. If on the first step,
            # volume needs to be increased. Otherwise, it was due to a step
            # being too big and POTIM should be decreased.
            try:
                oszicar = Oszicar("OSZICAR")
                nsteps = len(oszicar.ionic_steps)
            except:
                nsteps = 0

            if nsteps >= 1:
                potim = float(vi["INCAR"].get("POTIM", 0.5)) / 2.0
                actions.append({
                    "dict": "INCAR",
                    "action": {
                        "_set": {
                            "ISYM": 0,
                            "POTIM": potim
                        }
                    }
                })
            else:
                s = vi["POSCAR"].structure
                s.apply_strain(0.2)
                actions.append({
                    "dict": "POSCAR",
                    "action": {
                        "_set": {
                            "structure": s.as_dict()
                        }
                    }
                })

            # Based on VASP forum's recommendation, you should delete the
            # CHGCAR and WAVECAR when dealing with this error.

            actions.append({
                "file": "CHGCAR",
                "action": {
                    "_file_delete": {
                        'mode': "actual"
                    }
                }
            })
            actions.append({
                "file": "WAVECAR",
                "action": {
                    "_file_delete": {
                        'mode': "actual"
                    }
                }
            })

        if self.errors.intersection(
            ["subspacematrix", "rspher", "real_optlay"]):
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "LREAL": False
                    }
                }
            })

        if self.errors.intersection(["tetirr", "incorrect_shift"]):

            if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                actions.append({
                    "dict": "KPOINTS",
                    "action": {
                        "_set": {
                            "generation_style": "Gamma"
                        }
                    }
                })

        if "rot_matrix" in self.errors:
            if vi["KPOINTS"].style == Kpoints.supported_modes.Monkhorst:
                actions.append({
                    "dict": "KPOINTS",
                    "action": {
                        "_set": {
                            "generation_style": "Gamma"
                        }
                    }
                })
            else:
                actions.append({
                    "dict": "INCAR",
                    "action": {
                        "_set": {
                            "ISYM": 0
                        }
                    }
                })

        if "amin" in self.errors:
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "AMIN": "0.01"
                    }
                }
            })

        if "triple_product" in self.errors:
            s = vi["POSCAR"].structure
            trans = SupercellTransformation(((1, 0, 0), (0, 0, 1), (0, 1, 0)))
            new_s = trans.apply_transformation(s)
            actions.append({
                "dict": "POSCAR",
                "action": {
                    "_set": {
                        "structure": new_s.as_dict()
                    }
                },
                "transformation": trans.as_dict()
            })

        if "pricel" in self.errors:
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "SYMPREC": 1e-8,
                        "ISYM": 0
                    }
                }
            })

        if "brions" in self.errors:
            potim = float(vi["INCAR"].get("POTIM", 0.5)) + 0.1
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "POTIM": potim
                    }
                }
            })

        if "zbrent" in self.errors:
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "IBRION": 1
                    }
                }
            })

        if "too_few_bands" in self.errors:
            if "NBANDS" in vi["INCAR"]:
                nbands = int(vi["INCAR"]["NBANDS"])
            else:
                with open("OUTCAR") as f:
                    for line in f:
                        if "NBANDS" in line:
                            try:
                                d = line.split("=")
                                nbands = int(d[-1].strip())
                                break
                            except (IndexError, ValueError):
                                pass
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "NBANDS": int(1.1 * nbands)
                    }
                }
            })

        if "pssyevx" in self.errors:
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "ALGO": "Normal"
                    }
                }
            })
        if "eddrmm" in self.errors:
            #RMM algorithm is not stable for this calculation
            if vi["INCAR"].get("ALGO", "Normal") in ["Fast", "VeryFast"]:
                actions.append({
                    "dict": "INCAR",
                    "action": {
                        "_set": {
                            "ALGO": "Normal"
                        }
                    }
                })
            else:
                potim = float(vi["INCAR"].get("POTIM", 0.5)) / 2.0
                actions.append({
                    "dict": "INCAR",
                    "action": {
                        "_set": {
                            "POTIM": potim
                        }
                    }
                })

            actions.append({
                "file": "CHGCAR",
                "action": {
                    "_file_delete": {
                        'mode': "actual"
                    }
                }
            })
            actions.append({
                "file": "WAVECAR",
                "action": {
                    "_file_delete": {
                        'mode': "actual"
                    }
                }
            })
        if "edddav" in self.errors:
            actions.append({
                "file": "CHGCAR",
                "action": {
                    "_file_delete": {
                        'mode': "actual"
                    }
                }
            })
            actions.append({
                "dict": "INCAR",
                "action": {
                    "_set": {
                        "ALGO": "All"
                    }
                }
            })

        VaspModder(vi=vi).apply_actions(actions)
        return {"errors": list(self.errors), "actions": actions}
예제 #11
0
    def process_killed_run(self, dir_name):
        """
        Process a killed vasp run.
        """
        fullpath = os.path.abspath(dir_name)
        logger.info("Processing Killed run " + fullpath)
        d = {"dir_name": fullpath, "state": "killed", "oszicar": {}}

        for f in os.listdir(dir_name):
            filename = os.path.join(dir_name, f)
            if fnmatch(f, "INCAR*"):
                try:
                    incar = Incar.from_file(filename)
                    d["incar"] = incar.as_dict()
                    d["is_hubbard"] = incar.get("LDAU", False)
                    if d["is_hubbard"]:
                        us = np.array(incar.get("LDAUU", []))
                        js = np.array(incar.get("LDAUJ", []))
                        if sum(us - js) == 0:
                            d["is_hubbard"] = False
                            d["hubbards"] = {}
                    else:
                        d["hubbards"] = {}
                    if d["is_hubbard"]:
                        d["run_type"] = "GGA+U"
                    elif incar.get("LHFCALC", False):
                        d["run_type"] = "HF"
                    else:
                        d["run_type"] = "GGA"
                except Exception as ex:
                    print(str(ex))
                    logger.error(
                        "Unable to parse INCAR for killed run {}.".format(
                            dir_name))
            elif fnmatch(f, "KPOINTS*"):
                try:
                    kpoints = Kpoints.from_file(filename)
                    d["kpoints"] = kpoints.as_dict()
                except:
                    logger.error(
                        "Unable to parse KPOINTS for killed run {}.".format(
                            dir_name))
            elif fnmatch(f, "POSCAR*"):
                try:
                    s = Poscar.from_file(filename).structure
                    comp = s.composition
                    el_amt = s.composition.get_el_amt_dict()
                    d.update({
                        "unit_cell_formula": comp.as_dict(),
                        "reduced_cell_formula": comp.to_reduced_dict,
                        "elements": list(el_amt.keys()),
                        "nelements": len(el_amt),
                        "pretty_formula": comp.reduced_formula,
                        "anonymous_formula": comp.anonymized_formula,
                        "nsites": comp.num_atoms,
                        "chemsys": "-".join(sorted(el_amt.keys()))
                    })
                    d["poscar"] = s.as_dict()
                except:
                    logger.error(
                        "Unable to parse POSCAR for killed run {}.".format(
                            dir_name))
            elif fnmatch(f, "POTCAR*"):
                try:
                    potcar = Potcar.from_file(filename)
                    d["pseudo_potential"] = {
                        "functional": potcar.functional.lower(),
                        "pot_type": "paw",
                        "labels": potcar.symbols
                    }
                except:
                    logger.error(
                        "Unable to parse POTCAR for killed run in {}.".format(
                            dir_name))
            elif fnmatch(f, "OSZICAR"):
                try:
                    d["oszicar"]["root"] = \
                        Oszicar(os.path.join(dir_name, f)).as_dict()
                except:
                    logger.error(
                        "Unable to parse OSZICAR for killed run in {}.".format(
                            dir_name))
            elif re.match("relax\d", f):
                if os.path.exists(os.path.join(dir_name, f, "OSZICAR")):
                    try:
                        d["oszicar"][f] = Oszicar(
                            os.path.join(dir_name, f, "OSZICAR")).as_dict()
                    except:
                        logger.error("Unable to parse OSZICAR for killed "
                                     "run in {}.".format(dir_name))
        return d
예제 #12
0
        volume_ref = entries[idx]['volume'] * scaling
        df_bulk.Volume_ref[idx+1] = volume_ref
                
        # save conventional unit cell
        createFolder('results/bulk_models')        
        conv_struc.to(filename = "results/bulk_models/POSCAR_%s" % (formula))
        conv_struc.to(filename = "results/bulk_models/%s.cif" % (formula))
        
        """
        Import from my results
        """
        
        file_path = '%03d_%s/2nd/' % (idx + 1.0, formula)
        
        try:
            oszicar = Oszicar(file_path + 'OSZICAR')
            tot_E = oszicar.ionic_steps[-1]['F']
            tot_mag = oszicar.ionic_steps[-1]['mag']
            
            df_bulk.total_E[idx+1] = tot_E
            df_bulk.tot_mag[idx+1] = tot_mag

            v = Vasprun(file_path + 'vasprun.xml')
            volume = v.as_dict()['output']['crystal']['lattice']['volume']
            
           
            df_bulk.Volume[idx+1] = volume
            df_bulk.Err_V_percent[idx+1] = (volume_ref - volume) / volume_ref * 100

            el = v.as_dict()['elements']
            el.remove('O')
예제 #13
0
        df_bulk.Eg_ref[idx+1] = entries[idx]['band_gap']
        df_bulk.Theoretical[idx+1] = entries[idx]['theoretical']
        
        volume_ref = entries[idx]['volume'] * scaling
        df_bulk.Volume_ref[idx+1] = volume_ref
                
        # save conventional unit cell
        createFolder('results/bulk_models')        
        conv_struc.to(filename = "results/bulk_models/POSCAR_%s" % (formula))
        conv_struc.to(filename = "results/bulk_models/%s.cif" % (formula))
        
        """
        Import from my results
        """
        try:
            oszicar = Oszicar('%03d_%s/2nd/OSZICAR' % (idx + 1.0, formula))
            tot_E = oszicar.ionic_steps[-1]['F']
            tot_mag = oszicar.ionic_steps[-1]['mag']
            
            df_bulk.total_E[idx+1] = tot_E
            df_bulk.tot_mag[idx+1] = tot_mag

            v = Vasprun('%03d_%s/2nd/vasprun.xml' % (idx + 1.0, formula))
            volume = v.as_dict()['output']['crystal']['lattice']['volume']
            
            df_bulk.Volume[idx+1] = volume
            df_bulk.Err_V_percent[idx+1] = (volume_ref - volume) / volume_ref * 100

            el = v.as_dict()['elements']
            el.remove('O')
예제 #14
0
import math

from pymatgen import Structure, Element
from pymatgen.io.vasp import Oszicar, Xdatcar, Vasprun
import os
import numpy as np
os.chdir('/home/jinho93/interface/lsmo-bto-pt/2.vaccum/baobao/up/again')
dat = Xdatcar('XDATCAR')
zicar = Oszicar('OSZICAR')
vrun = Vasprun('vasprun.xml')
energies = zicar.ionic_steps
selective = [
    r.properties['selective_dynamics'][2] for r in vrun.final_structure.sites
]
output = []
ionic = vrun.ionic_steps
for s, e, ion in zip(dat.structures, energies, ionic):
    sr = []
    ti = []
    z = []
    for i in s.sites:
        if i.specie == Element.O:
            z.append(i.z)
        elif i.specie == Element.Ti or i.specie == Element.Ti:
            ti.append(i.z)
        elif i.specie is Element.Ba or i.specie == Element.Ba:
            sr.append(i.z)

    arr_Sr = [x - y for x, y in zip(sorted(sr[1:]), sorted(z)[2::3])]
    arr_Ti = [x - y for x, y in zip(sorted(ti), sorted(z)[1::3])]
    if max(np.array(ion['forces'])[:, 2][selective]) < .2: