Add capability for Vasprun to read KPOINTS_OPT data

dev_scripts/regen_libxcfunc.py

@@ -45,28 +45,28 @@ def parse_section(section):
     return dct
 
 
-def write_libxc_docs_json(xcfuncs, jpath):
+def write_libxc_docs_json(xc_funcs, json_path):
     """Write json file with libxc metadata to path jpath."""
-    xcfuncs = deepcopy(xcfuncs)
+    xc_funcs = deepcopy(xc_funcs)
 
     # Remove XC_FAMILY from Family and XC_ from Kind to make strings more human-readable.
-    for d in xcfuncs.values():
+    for d in xc_funcs.values():
         d["Family"] = d["Family"].replace("XC_FAMILY_", "", 1)
         d["Kind"] = d["Kind"].replace("XC_", "", 1)
 
     # Build lightweight version with a subset of keys.
-    for num, d in xcfuncs.items():
-        xcfuncs[num] = {key: d[key] for key in ("Family", "Kind", "References")}
+    for num, d in xc_funcs.items():
+        xc_funcs[num] = {key: d[key] for key in ("Family", "Kind", "References")}
         # Descriptions are optional
         for opt in ("Description 1", "Description 2"):
             desc = d.get(opt)
             if desc is not None:
-                xcfuncs[num][opt] = desc
+                xc_funcs[num][opt] = desc
 
-    with open(jpath, "w") as fh:
-        json.dump(xcfuncs, fh)
+    with open(json_path, "w") as fh:
+        json.dump(xc_funcs, fh)
 
-    return xcfuncs
+    return xc_funcs
 
 
 def main():

tests/apps/borg/test_queen.py

@@ -11,9 +11,6 @@
 
 __author__ = "Shyue Ping Ong"
 __copyright__ = "Copyright 2012, The Materials Project"
-__version__ = "0.1"
-__maintainer__ = "Shyue Ping Ong"
-__email__ = "[email protected]"
 __date__ = "Mar 18, 2012"
 
 
@@ -22,7 +19,7 @@ def test_get_data(self):
         drone = VaspToComputedEntryDrone()
         self.queen = BorgQueen(drone, TEST_FILES_DIR, 1)
         data = self.queen.get_data()
-        assert len(data) == 15
+        assert len(data) == 16
 
     def test_load_data(self):
         drone = VaspToComputedEntryDrone()

tests/files/kpoints_opt/KPOINTS

@@ -0,0 +1,4 @@
+Fully automatic kpoint scheme
+0
+Automatic
+25

tests/files/kpoints_opt/KPOINTS_OPT

@@ -0,0 +1,34 @@
+Line_mode KPOINTS file
+10
+Line_mode
+Reciprocal
+0.0 0.0 0.0 ! \Gamma
+0.5 0.0 0.5 ! X
+
+0.5 0.0 0.5 ! X
+0.5 0.25 0.75 ! W
+
+0.5 0.25 0.75 ! W
+0.375 0.375 0.75 ! K
+
+0.375 0.375 0.75 ! K
+0.0 0.0 0.0 ! \Gamma
+
+0.0 0.0 0.0 ! \Gamma
+0.5 0.5 0.5 ! L
+
+0.5 0.5 0.5 ! L
+0.625 0.25 0.625 ! U
+
+0.625 0.25 0.625 ! U
+0.5 0.25 0.75 ! W
+
+0.5 0.25 0.75 ! W
+0.5 0.5 0.5 ! L
+
+0.5 0.5 0.5 ! L
+0.375 0.375 0.75 ! K
+
+0.625 0.25 0.625 ! U
+0.5 0.0 0.5 ! X
+

tests/io/vasp/test_outputs.py

@@ -18,6 +18,7 @@
 from pymatgen.core import Element
 from pymatgen.core.lattice import Lattice
 from pymatgen.core.structure import Structure
+from pymatgen.electronic_structure.bandstructure import BandStructureSymmLine
 from pymatgen.electronic_structure.core import Magmom, Orbital, OrbitalType, Spin
 from pymatgen.entries.compatibility import MaterialsProjectCompatibility
 from pymatgen.io.vasp.inputs import Kpoints, Poscar, Potcar
@@ -705,6 +706,59 @@ def test_eigenvalue_band_properties_separate_spins(self):
         assert props[3][0]
         assert props[3][1]
 
+    def test_kpoints_opt(self):
+        vasp_run = Vasprun(f"{TEST_FILES_DIR}/kpoints_opt/vasprun.xml.gz", parse_projected_eigen=True)
+        # This calculation was run using KPOINTS_OPT
+        # Check the k-points were read correctly.
+        assert len(vasp_run.actual_kpoints) == 10
+        assert len(vasp_run.actual_kpoints_weights) == 10
+        assert len(vasp_run.actual_kpoints_opt) == 100
+        assert len(vasp_run.actual_kpoints_weights_opt) == 100
+        # Check the eigenvalues were read correctly.
+        assert vasp_run.eigenvalues[Spin.up].shape == (10, 24, 2)
+        assert vasp_run.eigenvalues_kpoints_opt[Spin.up].shape == (100, 24, 2)
+        assert vasp_run.eigenvalues[Spin.up][0, 0, 0] == approx(-6.1471)
+        assert vasp_run.eigenvalues_kpoints_opt[Spin.up][0, 0, 0] == approx(-6.1536)
+        # Check the projected eigenvalues were read correctly
+        assert vasp_run.projected_eigenvalues[Spin.up].shape == (10, 24, 8, 9)
+        assert vasp_run.projected_eigenvalues_kpoints_opt[Spin.up].shape == (100, 24, 8, 9)
+        assert vasp_run.projected_eigenvalues[Spin.up][0, 1, 0, 0] == approx(0.0492)
+        assert vasp_run.projected_eigenvalues_kpoints_opt[Spin.up][0, 1, 0, 0] == approx(0.0000)
+        # I think these zeroes are a bug in VASP (maybe my VASP) transcribing from PROCAR_OPT to vasprun.xml
+        # Test as_dict
+        vasp_run_dct = vasp_run.as_dict()
+        assert vasp_run_dct["input"]["nkpoints_opt"] == 100
+        assert vasp_run_dct["input"]["nkpoints"] == 10
+        assert vasp_run_dct["output"]["eigenvalues_kpoints_opt"]["1"][0][0][0] == approx(-6.1536)
+
+    def test_kpoints_opt_band_structure(self):
+        vasp_run = Vasprun(
+            f"{TEST_FILES_DIR}/kpoints_opt/vasprun.xml.gz", parse_potcar_file=False, parse_projected_eigen=True
+        )
+        bs = vasp_run.get_band_structure(f"{TEST_FILES_DIR}/kpoints_opt/KPOINTS_OPT")
+        assert isinstance(bs, BandStructureSymmLine)
+        cbm = bs.get_cbm()
+        vbm = bs.get_vbm()
+        assert cbm["kpoint_index"] == [38], "wrong cbm kpoint index"
+        assert cbm["energy"] == approx(6.4394), "wrong cbm energy"
+        assert cbm["band_index"] == {Spin.up: [16], Spin.down: [16]}, "wrong cbm bands"
+        assert vbm["kpoint_index"] == [0, 39, 40]
+        assert vbm["energy"] == approx(5.7562), "wrong vbm energy"
+        assert vbm["band_index"] == {Spin.down: [13, 14, 15], Spin.up: [13, 14, 15]}, "wrong vbm bands"
+        vbm_kp_label = vbm["kpoint"].label
+        assert vbm["kpoint"].label == "\\Gamma", f"Unpexpected {vbm_kp_label=}"
+        cmb_kp_label = cbm["kpoint"].label
+        assert cmb_kp_label is None, f"Unpexpected {cmb_kp_label=}"
+        # Test projection
+        projected = bs.get_projection_on_elements()
+        assert np.isnan(projected[Spin.up][0][0]["Si"])
+        # Due to some error in my VASP, the transcription of PROCAR_OPT into
+        # vasprun.xml is filled to the brim with errors in the projections.
+        # At some point we might get a healthier vasprun.xml, but the point here
+        # is to test the parser, not VASP.
+        projected = bs.get_projections_on_elements_and_orbitals({"Si": ["s"]})
+        assert projected[Spin.up][0][58]["Si"]["s"] == -0.0271
+
 
 class TestOutcar(PymatgenTest):
     def test_init(self):
@@ -1304,6 +1358,38 @@ def test_get_band_structure(self):
         d = vasprun.as_dict()
         assert "eigenvalues" in d["output"]
 
+    def test_kpoints_opt(self):
+        vasp_run = BSVasprun(
+            f"{TEST_FILES_DIR}/kpoints_opt/vasprun.xml.gz", parse_potcar_file=False, parse_projected_eigen=True
+        )
+        bs = vasp_run.get_band_structure(f"{TEST_FILES_DIR}/kpoints_opt/KPOINTS_OPT")
+        assert isinstance(bs, BandStructureSymmLine)
+        cbm = bs.get_cbm()
+        vbm = bs.get_vbm()
+        assert cbm["kpoint_index"] == [38], "wrong cbm kpoint index"
+        assert cbm["energy"] == approx(6.4394), "wrong cbm energy"
+        assert cbm["band_index"] == {Spin.up: [16], Spin.down: [16]}, "wrong cbm bands"
+        # Strangely, when I call with parse_projected_eigen, it gives empty Spin.down,
+        # but without parse_projected_eigen it does not give it.
+        # So at one point it called the empty key.
+        assert vbm["kpoint_index"] == [0, 39, 40]
+        assert vbm["energy"] == approx(5.7562), "wrong vbm energy"
+        assert vbm["band_index"] == {Spin.down: [13, 14, 15], Spin.up: [13, 14, 15]}, "wrong vbm bands"
+        assert vbm["kpoint"].label == "\\Gamma", "wrong vbm label"
+        assert cbm["kpoint"].label is None, "wrong cbm label"
+        # Test projection
+        projected = bs.get_projection_on_elements()
+        assert np.isnan(projected[Spin.up][0][0]["Si"])
+        # Due to some error in my VASP, the transcription of PROCAR_OPT into
+        # vasprun.xml is filled to the brim with errors in the projections.
+        # At some point we might get a healthier vasprun.xml, but the point here
+        # is to test the parser, not VASP.
+        projected = bs.get_projections_on_elements_and_orbitals({"Si": ["s"]})
+        assert projected[Spin.up][0][58]["Si"]["s"] == -0.0271
+        d = vasp_run.as_dict()
+        assert "eigenvalues" in d["output"]
+        assert "eigenvalues_kpoints_opt" in d["output"]
+
 
 class TestOszicar(PymatgenTest):
     def test_init(self):