rewrite electron config parser

Author: DanielYang59

src/pymatgen/io/vasp/inputs.py

@@ -2127,35 +2127,52 @@ def __repr__(self) -> str:
         return f"{cls_name}({symbol=}, {functional=}, {TITEL=}, {VRHFIN=}, {n_valence_elec=:.0f})"
 
     @property
-    def electron_configuration(self) -> list[tuple[int, str, int]] | None:
+    def electron_configuration(self) -> list[tuple[int, str, float]]:
         """Valence electronic configuration corresponding to the ZVAL,
         read from the "Atomic configuration" section of POTCAR.
 
-        If the POTCAR defines a non-integer number of electrons,
-            the configuration is not well-defined, and None is returned.
+        Returns:
+            list[tuple[int, str, float]]: A list of tuples containing:
+                - n (int): Principal quantum number.
+                - subshell (str): Subshell notation (s, p, d, f).
+                - occ (float): Occupation number, limited to ZVAL.
         """
-        # TODO: test non integer cases
-        if not self.nelectrons.is_integer():
-            warnings.warn(
-                "POTCAR has non-integer charge, electron configuration not well-defined.",
-                stacklevel=2,
-            )
-            return None
+        # Find "Atomic configuration" section
+        match = re.search(r"Atomic configuration", self.data)
+        if match is None:
+            raise RuntimeError("Cannot find atomic configuration section in POTCAR.")
 
-        el: Element = Element.from_Z(self.atomic_no)
-        full_config: list[tuple[int, str, int]] = el.full_electronic_structure
-        nelect: float = self.nelectrons
-        config: list[tuple[int, str, int]] = []
+        start_idx: int = self.data[: match.start()].count("\n")
 
-        while nelect > 0:
-            n, l, num_e = full_config.pop(-1)
-            # Skip fully filled d/f orbitals if there are higher n orbitals
-            if l in {"d", "f"} and num_e in {10, 14} and any(n_ > n for n_, _, _ in full_config):
-                continue
-            config.append((n, l, num_e))
-            nelect -= num_e
+        lines = self.data.splitlines()
+
+        # Extract all subshells
+        match_entries = re.search(r"(\d+)\s+entries", lines[start_idx + 1])
+        if match_entries is None:
+            raise RuntimeError("Cannot find entries in POTCAR.")
+        num_entries: int = int(match_entries.group(1))
+
+        l_map: dict[int, str] = {0: "s", 1: "p", 2: "d", 3: "f", 4: "g", 5: "h"}
+        all_config: list[tuple[int, str, float]] = []
+        for line in lines[start_idx + 3 : start_idx + 3 + num_entries]:
+            parts = line.split()
+            n, l, _j, _E, occ = int(parts[0]), int(parts[1]), float(parts[2]), float(parts[3]), float(parts[4])
+
+            all_config.append((n, l_map[l], occ))
+
+        # Get valence electron configuration (defined by ZVAL)
+        valence_config: list[tuple[int, str, float]] = []
+        total_electrons = 0.0
+
+        for n, subshell, occ in reversed(all_config):
+            if occ >= 0.01:  # TODO: hard-coded occupancy cutoff
+                valence_config.append((n, subshell, occ))
+                total_electrons += occ
+
+            if total_electrons >= self.zval:
+                break
 
-        return config
+        return list(reversed(valence_config))
 
     @property
     def element(self) -> str:

tests/io/vasp/test_inputs.py

@@ -1378,59 +1378,89 @@ def test_nelectrons(self):
         assert self.psingle_Fe.nelectrons == 8
 
     def test_electron_configuration(self):
-        # TODO: use `approx` to compare floats
+        def assert_config_equal(actual_config, expected_config) -> None:
+            """
+            Helper function to assert that the electron configuration is equal.
+            Each configuration contains: (n: int, l: str, occ: float).
+            """
+            assert len(actual_config) == len(expected_config), "Configurations have different lengths"
+
+            for expected, actual in zip(expected_config, actual_config, strict=False):
+                assert expected[0] == actual[0], f"Principal quantum number mismatch: {expected[0]} != {actual[0]}"
+                assert expected[1] == actual[1], f"Subshell mismatch: {expected[1]} != {actual[1]}"
+
+                assert expected[2] == approx(actual[2]), f"Occupation number mismatch: {expected[2]} != {actual[2]}"
 
         # Test s-block  (Li: 2s1)
-        assert PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Li.gz").electron_configuration == [
-            (2, "s", 1),
-        ]
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Li.gz").electron_configuration,
+            [
+                (2.0, "s", 1.0),
+            ],
+        )
 
         # Test p-block  (O: 2s2 sp4)
-        assert PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.O.gz").electron_configuration == [
-            (2, "s", 2),
-            (2, "p", 4),
-        ]
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.O.gz").electron_configuration,
+            [
+                (2, "s", 2.0),
+                (2, "p", 4.0),
+            ],
+        )
 
-        # Test d-block (Fe: 4s1 3d7)
-        assert self.psingle_Fe.electron_configuration == [(3, "d", 7), (4, "s", 1)]
+        # Test d-block (Fe: 3d7 4s1)
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Fe.gz").electron_configuration,
+            [(3, "d", 7.0), (4, "s", 1.0)],
+        )
 
         # Test f-block (Ce: 5s2 6s2 5p6 5d1 4f1)
-        assert PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Ce.gz").electron_configuration == [
-            (5, "s", 2),
-            (6, "s", 2),
-            (5, "p", 6),
-            (5, "d", 1),
-            (4, "f", 1),
-        ]
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Ce.gz").electron_configuration,
+            [
+                (5, "s", 2),
+                (6, "s", 2),
+                (5, "p", 6),
+                (5, "d", 1),
+                (4, "f", 1),
+            ],
+        )
 
         # Test "sv" POTCARs (K_sv: 3s2 4s1 3p6)
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.K_sv.gz").electron_configuration,
+            [
+                (3, "s", 2),
+                (4, "s", 1),
+                (3, "p", 6),
+            ],
+        )
+
+        # Test "pv" POTCARs (Fe_pv: 3p6 3d7 4s1)
         assert PotcarSingle.from_file(
-            f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.K_sv.gz"
+            f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Fe_pv.gz"
         ).electron_configuration == [
-            (3, "s", 2),
-            (4, "s", 1),
-            (3, "p", 6),
-        ]
-
-        # Test "pv" POTCARs
-        assert self.psingle_Mn_pv.electron_configuration == [
-            (3, "d", 5),
-            (4, "s", 2),
             (3, "p", 6),
+            (3, "d", 7),
+            (4, "s", 1),
         ]
 
         # Test non-integer occupancy (Be: 2s1.99 2p0.01)
-        assert PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Be.gz").electron_configuration == [
-            (2, "s", 1.99),
-            (2, "p", 0.01),
-        ]
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.Be.gz").electron_configuration,
+            [
+                (2, "s", 1.99),
+                (2, "p", 0.01),
+            ],
+        )
 
         # Test another non-integer occupancy (H.25: 1s0.25)
-        assert PotcarSingle.from_file(
-            f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.H.25.gz"
-        ).electron_configuration == [
-            (1, "s", 0.25),
-        ]
+        assert_config_equal(
+            PotcarSingle.from_file(f"{FAKE_POTCAR_DIR}/POT_GGA_PAW_PBE_54/POTCAR.H.25.gz").electron_configuration,
+            [
+                (1, "s", 0.25),
+            ],
+        )
 
     def test_attributes(self):
         for key, val in self.Mn_pv_attrs.items():