continue refactor

Author: esoteric-ephemera

pymatgen/io/validation/__init__.py

@@ -4,7 +4,7 @@
 to ensure that data is compatible with some standard.
 """
 
-from pymatgen.io.validation.validation import ValidationDoc  # noqa: F401
+from pymatgen.io.validation.validation import VaspValidator  # noqa: F401
 
 from pymatgen.io.validation.settings import IOValidationSettings as _settings
 

pymatgen/io/validation/check_common_errors.py

@@ -1,61 +1,41 @@
 """Validate VASP KPOINTS files or the KSPACING/KGAMMA INCAR settings."""
 
 from __future__ import annotations
+from pydantic import Field
+from typing import TYPE_CHECKING
 import numpy as np
-from pymatgen.io.vasp import Kpoints
-
-from pymatgen.core import Structure
-from pymatgen.io.vasp.sets import VaspInputSet
 
 from pymatgen.io.validation.common import BaseValidator
 
+if TYPE_CHECKING:
+    from pymatgen.io.validation.common import VaspFiles
+
+
 class CheckKpointsKspacing(BaseValidator):
-    """
-    Check that k-point density is sufficiently high and is compatible with lattice symmetry.
-
-    Parameters
-    -----------
-    reasons : list[str]
-        A list of error strings to update if a check fails. These are higher
-        severity and would deprecate a calculation.
-    warnings : list[str]
-        A list of warning strings to update if a check fails. These are lower
-        severity and would flag a calculation for possible review.
-    valid_input_set: VaspInputSet
-        Valid input set to compare user INCAR parameters to.
-    kpoints : Kpoints or dict
-        Kpoints object or its .as_dict() representation used in the calculation.
-    structure : pymatgen.core.Structure
-        The structure used in the calculation
-    name : str = "Check k-point density"
-        Name of the validator class
-    fast : bool = False
-        Whether to perform quick check.
-        True: stop validation if any check fails.
-        False: perform all checks.
-    defaults : dict
-        Dict of default parameters
-    kpts_tolerance : float
-        Tolerance for evaluating k-point density, as the k-point generation
-        scheme is inconsistent across VASP versions
-    allow_explicit_kpoint_mesh : str | bool
-        Whether to permit explicit generation of k-points (as for a bandstructure calculation).
-    allow_kpoint_shifts : bool
-        Whether to permit shifting the origin of the k-point mesh from Gamma.
-    """
-
-    reasons: list[str]
-    warnings: list[str]
+    """Check that k-point density is sufficiently high and is compatible with lattice symmetry."""
+
     name: str = "Check k-point density"
-    valid_input_set: VaspInputSet = None
-    kpoints: Kpoints = None
-    structure: Structure = None
-    defaults: dict | None = None
-    kpts_tolerance: float | None = None
-    allow_explicit_kpoint_mesh: str | bool = False
-    allow_kpoint_shifts: bool = False
-
-    def _get_valid_num_kpts(self) -> int:
+    kpts_tolerance: float | None = Field(
+        None,
+        description="Tolerance for evaluating k-point density, to accommodate different the k-point generation schemes across VASP versions.",
+    )
+    allow_explicit_kpoint_mesh: bool = Field(
+        False, description="Whether to permit explicit generation of k-points (as for a bandstructure calculation)."
+    )
+    allow_kpoint_shifts: bool = Field(
+        False, description="Whether to permit shifting the origin of the k-point mesh from Gamma."
+    )
+
+    def auto_fail(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> bool:
+        """Quick stop if actual k-points are missing."""
+        if vasp_files.kpoints is None:
+            reasons.append("Missing actual k-points: please specify an IBZKPT or vasprun.xml in VaspFiles.")
+        return vasp_files.kpoints is None
+
+    def _get_valid_num_kpts(
+        self,
+        vasp_files: VaspFiles,
+    ) -> int:
         """
         Get the minimum permitted number of k-points for a structure according to an input set.
 
@@ -64,68 +44,71 @@ def _get_valid_num_kpts(self) -> int:
         int, the minimum permitted number of k-points, consistent with self.kpts_tolerance
         """
         # If MP input set specifies KSPACING in the INCAR
-        if ("KSPACING" in self.valid_input_set.incar.keys()) and (self.valid_input_set.kpoints is None):
-            valid_kspacing = self.valid_input_set.incar.get("KSPACING", self.defaults["KSPACING"]["value"])
+        if ("KSPACING" in vasp_files.valid_input_set.incar.keys()) and (vasp_files.valid_input_set.kpoints is None):
+            valid_kspacing = vasp_files.valid_input_set.incar.get("KSPACING", self.vasp_defaults["KSPACING"].value)
             # number of kpoints along each of the three lattice vectors
             nk = [
-                max(1, np.ceil(self.structure.lattice.reciprocal_lattice.abc[ik] / valid_kspacing)) for ik in range(3)
+                max(1, np.ceil(vasp_files.structure.lattice.reciprocal_lattice.abc[ik] / valid_kspacing))
+                for ik in range(3)
             ]
             valid_num_kpts = np.prod(nk)
         # If MP input set specifies a KPOINTS file
         else:
-            valid_num_kpts = self.valid_input_set.kpoints.num_kpts or np.prod(self.valid_input_set.kpoints.kpts[0])
+            valid_num_kpts = vasp_files.valid_input_set.kpoints.num_kpts or np.prod(
+                vasp_files.valid_input_set.kpoints.kpts[0]
+            )
 
         return int(np.floor(int(valid_num_kpts) * self.kpts_tolerance))
 
-    def _check_user_shifted_mesh(self) -> None:
+    def _check_user_shifted_mesh(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # Check for user shifts
-        if (not self.allow_kpoint_shifts) and any(shift_val != 0 for shift_val in self.kpoints.kpts_shift):
-            self.reasons.append("INPUT SETTINGS --> KPOINTS: shifting the kpoint mesh is not currently allowed.")
+        if (not self.allow_kpoint_shifts) and any(shift_val != 0 for shift_val in vasp_files.kpoints.kpts_shift):
+            reasons.append("INPUT SETTINGS --> KPOINTS: shifting the kpoint mesh is not currently allowed.")
 
-    def _check_explicit_mesh_permitted(self) -> None:
+    def _check_explicit_mesh_permitted(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # Check for explicit kpoint meshes
 
-        if (not self.allow_explicit_kpoint_mesh) and len(self.kpoints.kpts) > 1:
-            self.reasons.append(
+        if (not self.allow_explicit_kpoint_mesh) and len(vasp_files.kpoints.kpts) > 1:
+            reasons.append(
                 "INPUT SETTINGS --> KPOINTS: explicitly defining "
                 "the k-point mesh is not currently allowed. "
                 "Automatic k-point generation is required."
             )
 
-    def _check_kpoint_density(self) -> None:
+    def _check_kpoint_density(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         """
         Check that k-point density is sufficiently high and is compatible with lattice symmetry.
         """
 
         # Check number of kpoints used
-        valid_num_kpts = self._get_valid_num_kpts()
+        valid_num_kpts = self._get_valid_num_kpts(vasp_files)
 
         cur_num_kpts = max(
-            self.kpoints.num_kpts,
-            np.prod(self.kpoints.kpts),
-            len(self.kpoints.kpts),
+            vasp_files.kpoints.num_kpts,
+            np.prod(vasp_files.kpoints.kpts),
+            len(vasp_files.kpoints.kpts),
         )
         if cur_num_kpts < valid_num_kpts:
-            self.reasons.append(
+            reasons.append(
                 f"INPUT SETTINGS --> KPOINTS or KSPACING: {cur_num_kpts} kpoints were "
                 f"used, but it should have been at least {valid_num_kpts}."
             )
 
-    def _check_kpoint_mesh_symmetry(self) -> None:
+    def _check_kpoint_mesh_symmetry(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         # check for valid kpoint mesh (which depends on symmetry of the structure)
 
-        cur_kpoint_style = self.kpoints.style.name.lower()
-        is_hexagonal = self.structure.lattice.is_hexagonal()
-        is_face_centered = self.structure.get_space_group_info()[0][0] == "F"
+        cur_kpoint_style = vasp_files.kpoints.style.name.lower()
+        is_hexagonal = vasp_files.structure.lattice.is_hexagonal()
+        is_face_centered = vasp_files.structure.get_space_group_info()[0][0] == "F"
         monkhorst_mesh_is_invalid = is_hexagonal or is_face_centered
         if (
             cur_kpoint_style == "monkhorst"
             and monkhorst_mesh_is_invalid
-            and any(x % 2 == 0 for x in self.kpoints.kpts[0])
+            and any(x % 2 == 0 for x in vasp_files.kpoints.kpts[0])
         ):
             # only allow Monkhorst with all odd number of subdivisions per axis.
-            kx, ky, kz = self.kpoints.kpts[0]
-            self.reasons.append(
+            kx, ky, kz = vasp_files.kpoints.kpts[0]
+            reasons.append(
                 f"INPUT SETTINGS --> KPOINTS or KGAMMA: ({kx}x{ky}x{kz}) "
                 "Monkhorst-Pack kpoint mesh was used."
                 "To be compatible with the symmetry of the lattice, "

pymatgen/io/validation/check_incar.py

@@ -1,80 +1,61 @@
 """Check POTCAR against known POTCARs in pymatgen, without setting up psp_resources."""
 
 from __future__ import annotations
+from functools import cached_property
 from pydantic import Field
 from importlib.resources import files as import_resource_files
 from monty.serialization import loadfn
-import numpy as np
-
-from pymatgen.core import Structure
-from pymatgen.io.vasp.sets import VaspInputSet
+from typing import TYPE_CHECKING
 
 from pymatgen.io.validation.common import BaseValidator
 
-_potcar_summary_stats = loadfn(import_resource_files("pymatgen.io.vasp") / "potcar-summary-stats.json.bz2")
+if TYPE_CHECKING:
+    from pathlib import Path
+    from pymatgen.io.validation.common import VaspFiles
+
 
 class CheckPotcar(BaseValidator):
     """
     Check POTCAR against library of known valid POTCARs.
-
-    reasons : list[str]
-        A list of error strings to update if a check fails. These are higher
-        severity and would deprecate a calculation.
-    warnings : list[str]
-        A list of warning strings to update if a check fails. These are lower
-        severity and would flag a calculation for possible review.
-    valid_input_set: VaspInputSet
-        Valid input set to compare user INCAR parameters to.
-    structure: Pymatgen Structure
-        Structure used in the calculation.
-    potcar: dict
-        Spec (symbol, hash, and summary stats) for the POTCAR used in the calculation.
-    name : str = "Check POTCARs"
-        Name of the validator class
-    fast : bool = False
-        Whether to perform quick check.
-        True: stop validation if any check fails.
-        False: perform all checks.
-    potcar_summary_stats : dict
-        Dictionary of potcar summary data. Mapping is calculation type -> potcar symbol -> summary data.
-    data_match_tol : float = 1.e-6
-        Tolerance for matching POTCARs to summary statistics data.
-    fast : bool = False
-        True: stop validation when any single check fails
     """
 
-    reasons: list[str]
-    warnings: list[str]
-    valid_input_set: VaspInputSet = None
-    structure: Structure = None
-    potcars: list[dict] = None
-    name: str = "Check POTCARs"
-    potcar_summary_stats: dict = Field(default_factory=lambda: _potcar_summary_stats)
-    data_match_tol: float = 1.0e-6
-    fast: bool = False
-
-    def _check_potcar_spec(self):
-        """
-        Checks to make sure the POTCAR is equivalent to the correct POTCAR from the pymatgen input set."""
-
-        if not self.potcar_summary_stats:
-            # If no reference summary stats specified, or we're only doing a quick check,
-            # and there are already failure reasons, return
-            return
-
-        if self.potcars is None or any(potcar.get("summary_stats") is None for potcar in self.potcars):
-            self.reasons.append(
+    name: str = "Check POTCAR"
+    potcar_summary_stats_path: str | Path = Field(
+        import_resource_files("pymatgen.io.vasp") / "potcar-summary-stats.json.bz2",
+        description="Path to potcar summary data. Mapping is calculation type -> potcar symbol -> summary data.",
+    )
+    data_match_tol: float = Field(1.0e-6, description="Tolerance for matching POTCARs to summary statistics data.")
+
+    @cached_property
+    def potcar_summary_stats(self) -> dict | None:
+        """Load POTCAR summary statistics file."""
+        if self.potcar_summary_stats_path:
+            return loadfn(self.potcar_summary_stats_path, cls=None)
+        return
+
+    def auto_fail(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> bool:
+        """Skip if no POTCAR was provided, or if summary stats file was unset."""
+        if vasp_files.potcar is None:
+            reasons.append(
                 "PSEUDOPOTENTIALS --> Missing POTCAR files. "
                 "Alternatively, our potcar checker may have an issue--please create a GitHub issue if you "
                 "know your POTCAR exists and can be read by Pymatgen."
             )
-            return
+        elif self.potcar_summary_stats is None:
+            # If no reference summary stats specified, or we're only doing a quick check,
+            # and there are already failure reasons, return
+            return True
+        return vasp_files.potcar is None
 
-        psp_subset = self.potcar_summary_stats.get(self.valid_input_set._config_dict["POTCAR_FUNCTIONAL"], {})
+    def _check_potcar_spec(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]):
+        """
+        Checks to make sure the POTCAR is equivalent to the correct POTCAR from the pymatgen input set."""
+
+        psp_subset = self.potcar_summary_stats.get(vasp_files.valid_input_set._config_dict["POTCAR_FUNCTIONAL"], {})
 
         valid_potcar_summary_stats = {}  # type: ignore
-        for element in self.structure.composition.remove_charges().as_dict():
-            potcar_symbol = self.valid_input_set._config_dict["POTCAR"][element]
+        for element in vasp_files.structure.composition.remove_charges().as_dict():
+            potcar_symbol = vasp_files.valid_input_set._config_dict["POTCAR"][element]
             for titel_no_spc in psp_subset:
                 for psp in psp_subset[titel_no_spc]:
                     if psp["symbol"] == potcar_symbol:
@@ -84,15 +65,17 @@ def _check_potcar_spec(self):
 
         try:
             incorrect_potcars = []
-            for potcar in self.potcars:
-                reference_summary_stats = valid_potcar_summary_stats.get(potcar["titel"].replace(" ", ""), [])
+            for potcar in vasp_files.potcar:
+                reference_summary_stats = valid_potcar_summary_stats.get(potcar.TITEL.replace(" ", ""), [])
 
                 if len(reference_summary_stats) == 0:
-                    incorrect_potcars.append(potcar["titel"].split(" ")[1])
+                    incorrect_potcars.append(potcar.TITEL.split(" ")[1])
                     continue
 
                 for ref_psp in reference_summary_stats:
-                    if found_match := self.compare_potcar_stats(ref_psp, potcar["summary_stats"]):
+                    if found_match := potcar.compare_potcar_stats(
+                        ref_psp, potcar._summary_stats, tolerance=self.data_match_tol
+                    ):
                         break
 
                 if not found_match:
@@ -113,55 +96,15 @@ def _check_potcar_spec(self):
                         ", ".join(incorrect_potcars[:-1]) + "," + f" and {incorrect_potcars[-1]}"
                     )  # type: ignore
 
-                self.reasons.append(
+                reasons.append(
                     f"PSEUDOPOTENTIALS --> Incorrect POTCAR files were used for {incorrect_potcars}. "
                     "Alternatively, our potcar checker may have an issue--please create a GitHub issue if you "
                     "believe the POTCARs used are correct."
                 )
 
-        except KeyError as e:
-            print(f"POTCAR check exception: {e}")
-            # Assume it is an old calculation without potcar_spec data and treat it as failing the POTCAR check
-            self.reasons.append(
+        except KeyError:
+            reasons.append(
                 "Issue validating POTCARS --> Likely due to an old version of Emmet "
                 "(wherein potcar summary_stats is not saved in TaskDoc), though "
                 "other errors have been seen. Hence, it is marked as invalid."
             )
-
-    def compare_potcar_stats(self, potcar_stats_1: dict, potcar_stats_2: dict) -> bool:
-        """Utility function to compare PotcarSingle._summary_stats."""
-
-        if not all(
-            potcar_stats_1.get(key)
-            for key in (
-                "keywords",
-                "stats",
-            )
-        ) or (
-            not all(
-                potcar_stats_2.get(key)
-                for key in (
-                    "keywords",
-                    "stats",
-                )
-            )
-        ):
-            return False
-
-        key_match = all(
-            set(potcar_stats_1["keywords"].get(key)) == set(potcar_stats_2["keywords"].get(key))  # type: ignore
-            for key in ["header", "data"]
-        )
-
-        data_match = False
-        if key_match:
-            data_diff = [
-                abs(
-                    potcar_stats_1["stats"].get(key, {}).get(stat) - potcar_stats_2["stats"].get(key, {}).get(stat)
-                )  # type: ignore
-                for stat in ["MEAN", "ABSMEAN", "VAR", "MIN", "MAX"]
-                for key in ["header", "data"]
-            ]
-            data_match = all(np.array(data_diff) < self.data_match_tol)
-
-        return key_match and data_match