finish tests

Author: esoteric-ephemera

pymatgen/io/validation/check_common_errors.py

@@ -5,11 +5,9 @@
 import numpy as np
 from typing import TYPE_CHECKING
 
-from pymatgen.io.validation.common import BaseValidator
+from pymatgen.io.validation.common import SETTINGS, BaseValidator
 from pymatgen.io.validation.settings import IOValidationSettings
 
-SETTINGS = IOValidationSettings()
-
 if TYPE_CHECKING:
     from numpy.typing import ArrayLike
 
@@ -232,7 +230,6 @@ def _has_frozen_degrees_of_freedom(selective_dynamics_array: ArrayLike[bool] | N
 
     def _check_selective_dynamics(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str]) -> None:
         """Check structure for inappropriate site properties."""
-
         if (
             selec_dyn := vasp_files.user_input.structure.site_properties.get("selective_dynamics")
         ) is not None and vasp_files.run_type == "relax":

pymatgen/io/validation/check_incar.py

@@ -4,19 +4,17 @@
 import numpy as np
 from pydantic import Field
 
-from pymatgen.io.vasp import Incar
-
-from pymatgen.io.validation.common import BaseValidator, VaspFiles
+from pymatgen.io.validation.common import SETTINGS, BaseValidator, VaspFiles
 from pymatgen.io.validation.vasp_defaults import InputCategory, VaspParam
 
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from typing import Any
     from pymatgen.io.validation.common import VaspFiles
 
 # TODO: fix ISIF getting overwritten by MP input set.
 
-
 class CheckIncar(BaseValidator):
     """
     Check calculation parameters related to INCAR input tags.
@@ -37,7 +35,8 @@ class CheckIncar(BaseValidator):
 
     name: str = "Check INCAR tags"
     fft_grid_tolerance: float | None = Field(
-        None, description="Tolerance for determining sufficient density of FFT grid."
+        SETTINGS.VASP_FFT_GRID_TOLERANCE,
+        description="Tolerance for determining sufficient density of FFT grid."
     )
     bandgap_tol: float = Field(1.0e-4, description="Tolerance for assuming a material has no gap.")
 
@@ -70,11 +69,10 @@ def check(self, vasp_files: VaspFiles, reasons: list[str], warnings: list[str])
             if self.fast and len(reasons) > 0:
                 # fast check: stop checking whenever a single check fails
                 break
-
             resp = vasp_param.check(user_incar_params[vasp_param.name], valid_incar_params[vasp_param.name])
             msgs[vasp_param.severity].extend(resp.get(vasp_param.severity, []))
 
-    def update_parameters_and_defaults(self, vasp_files: VaspFiles) -> tuple[Incar, Incar]:
+    def update_parameters_and_defaults(self, vasp_files: VaspFiles) -> tuple[dict[str,Any], dict[str,Any]]:
         """Update a set of parameters according to supplied rules and defaults.
 
         While many of the parameters in VASP need only a simple check to determine
@@ -299,10 +297,19 @@ def _update_hybrid_params(self, user_incar: dict, ref_incar: dict, vasp_files: V
     def _update_fft_params(self, user_incar: dict, ref_incar: dict, vasp_files: VaspFiles) -> None:
         """Update ENCUT and parameters related to the FFT grid."""
 
+        # ensure that ENCUT is appropriately updated
+        user_incar["ENMAX"] = user_incar.get(
+            "ENCUT",
+            getattr(vasp_files.vasprun,"parameters",{}).get("ENMAX")
+        )
+
+        ref_incar["ENMAX"] = vasp_files.valid_input_set.incar.get("ENCUT", self.vasp_defaults["ENMAX"])
+
         grid_keys = {"NGX", "NGXF", "NGY", "NGYF", "NGZ", "NGZF"}
         # NGX/Y/Z and NGXF/YF/ZF. Not checked if not in INCAR file (as this means the VASP default was used).
         if any(i for i in grid_keys if i in user_incar.keys()):
-            ref_incar["ENMAX"] = max(user_incar["ENMAX"], ref_incar["ENMAX"])
+            enmaxs = [user_incar["ENMAX"], ref_incar["ENMAX"]]
+            ref_incar["ENMAX"] = max([v for v in enmaxs if v < float("inf")])
 
             (
                 [
@@ -315,10 +322,10 @@ def _update_fft_params(self, user_incar: dict, ref_incar: dict, vasp_files: Vasp
                     ref_incar["NGYF"],
                     ref_incar["NGZF"],
                 ],
-            ) = vasp_files.valid_input_set.calculate_ng(custom_encut=ref_incar["ENMAX"])
+            ) = vasp_files.valid_input_set._calculate_ng(custom_encut=ref_incar["ENMAX"])
 
             for key in grid_keys:
-                ref_incar[key] = int(ref_incar[key] * self._fft_grid_tolerance)
+                ref_incar[key] = int(ref_incar[key] * self.fft_grid_tolerance)
 
                 self.vasp_defaults[key] = VaspParam(
                     name=key,
@@ -379,7 +386,7 @@ def _update_smearing_params(self, user_incar: dict, ref_incar: dict, vasp_files:
 
         This is based on the final bandgap obtained in the calc.
         """
-        if vasp_files.bandgap:
+        if vasp_files.bandgap is not None:
 
             smearing_comment = (
                 f"This is flagged as incorrect because this calculation had a bandgap of {round(vasp_files.bandgap,3)}"
@@ -405,8 +412,9 @@ def _update_smearing_params(self, user_incar: dict, ref_incar: dict, vasp_files:
             for key in ["ISMEAR", "SIGMA"]:
                 self.vasp_defaults[key].comment = smearing_comment
 
-            else:
+            if user_incar["ISMEAR"] not in [-5, -4, -2]:
                 self.vasp_defaults["SIGMA"].operation = "<="
+
         else:
             # These are generally applicable in all cases. Loosen check to warning.
             ref_incar["ISMEAR"] = [-1, 0]
@@ -418,7 +426,7 @@ def _update_smearing_params(self, user_incar: dict, ref_incar: dict, vasp_files:
                     "may lead to significant errors in forces. To enable this check, "
                     "supply a vasprun.xml file."
                 )
-            self.vasp_defaults["ISMEAR"].severity = "warning"
+                self.vasp_defaults["ISMEAR"].severity = "warning"
 
         # Also check if SIGMA is too large according to the VASP wiki,
         # which occurs when the entropy term in the energy is greater than 1 meV/atom.
@@ -485,7 +493,7 @@ def _update_electronic_params(self, user_incar: dict, ref_incar: dict, vasp_file
 
         # ENAUG. Should only be checked for calculations where the relevant MP input set specifies ENAUG.
         # In that case, ENAUG should be the same or greater than in valid_input_set.
-        if ref_incar.get("ENAUG"):
+        if ref_incar.get("ENAUG") < float("inf"):
             self.vasp_defaults["ENAUG"].operation = ">="
 
         # IALGO.
@@ -504,12 +512,18 @@ def _update_electronic_params(self, user_incar: dict, ref_incar: dict, vasp_file
                     f"NELECT should be set to {nelect + user_incar['NELECT']} instead."
                 )
             except Exception:
-                self.vasp_defaults["NELECT"].operation = "auto fail"
-                self.vasp_defaults["NELECT"].alias = "NELECT / POTCAR"
-                self.vasp_defaults["NELECT"].comment = (
-                    "sIssue checking whether NELECT was changed to make "
-                    "the structure have a non-zero charge. This is likely due to the "
-                    "directory not having a POTCAR file."
+                self.vasp_defaults["NELECT"] = VaspParam(
+                    name = "NELECT",
+                    value = None,
+                    tag = "electronic",
+                    operation= "auto fail",
+                    severity="warning",
+                    alias = "NELECT / POTCAR",
+                    comment=(
+                        "Issue checking whether NELECT was changed to make "
+                        "the structure have a non-zero charge. This is likely due to the "
+                        "directory not having a POTCAR file."
+                    )
                 )
 
             # NBANDS.
@@ -535,7 +549,10 @@ def _update_ionic_params(self, user_incar: dict, ref_incar: dict, vasp_files: Va
 
         # IBRION.
         ref_incar["IBRION"] = [-1, 1, 2]
-        if (inp_set_ibrion := vasp_files.user_input.incar.get("IBRION")) and inp_set_ibrion not in ref_incar["IBRION"]:
+        if (
+            (inp_set_ibrion := vasp_files.valid_input_set.incar.get("IBRION")) 
+            and inp_set_ibrion not in ref_incar["IBRION"]
+        ):
             ref_incar["IBRION"].append(inp_set_ibrion)
 
         ionic_steps = []

pymatgen/io/validation/check_kpoints_kspacing.py

@@ -5,10 +5,7 @@
 from typing import TYPE_CHECKING
 import numpy as np
 
-from pymatgen.io.validation.common import BaseValidator
-from pymatgen.io.validation.settings import IOValidationSettings
-
-SETTINGS = IOValidationSettings()
+from pymatgen.io.validation.common import SETTINGS, BaseValidator
 
 if TYPE_CHECKING:
     from pymatgen.io.validation.common import VaspFiles
@@ -22,7 +19,7 @@ class CheckKpointsKspacing(BaseValidator):
         SETTINGS.VASP_KPTS_TOLERANCE,
         description="Tolerance for evaluating k-point density, to accommodate different the k-point generation schemes across VASP versions.",
     )
-    allow_explicit_kpoint_mesh: bool = Field(
+    allow_explicit_kpoint_mesh: bool | str | None = Field(
         SETTINGS.VASP_ALLOW_EXPLICIT_KPT_MESH,
         description="Whether to permit explicit generation of k-points (as for a bandstructure calculation).",
     )
@@ -73,7 +70,14 @@ def _check_user_shifted_mesh(self, vasp_files: VaspFiles, reasons: list[str], wa
     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(vasp_files.actual_kpoints.kpts) > 1:
+        if isinstance(self.allow_explicit_kpoint_mesh,bool):
+            allow_explicit = self.allow_explicit_kpoint_mesh
+        elif self.allow_explicit_kpoint_mesh == "auto":
+            allow_explicit = vasp_files.run_type == "nonscf"
+        else:
+            allow_explicit = False
+
+        if (not allow_explicit) and len(vasp_files.actual_kpoints.kpts) > 1:
             reasons.append(
                 "INPUT SETTINGS --> KPOINTS: explicitly defining "
                 "the k-point mesh is not currently allowed. "

pymatgen/io/validation/common.py

@@ -14,10 +14,12 @@
 from pymatgen.io.vasp.sets import VaspInputSet
 
 from pymatgen.io.validation.vasp_defaults import VaspParam, VASP_DEFAULTS_DICT
+from pymatgen.io.validation.settings import IOValidationSettings
 
 if TYPE_CHECKING:
     from typing_extensions import Self
 
+SETTINGS = IOValidationSettings()
 
 class ValidationError(Exception):
     """Define custom exception during validation."""
@@ -32,6 +34,13 @@ class _PotcarSummaryStatsKeywords(BaseModel):
         header: set[str] = Field(description="The keywords in the POTCAR header.")
         data: set[str] = Field(description="The keywords in the POTCAR body.")
 
+        @model_serializer
+        def set_to_list(self) -> dict[str,list[str]]:
+            """Ensure JSON compliance of set fields."""
+            return {
+                k : list(getattr(self,k)) for k in ("header","data")
+            }
+
     class _PotcarSummaryStatsStats(BaseModel):
         """Schematize `PotcarSingle._summary_stats["stats"]` field."""
 
@@ -79,6 +88,7 @@ class LightVasprun(BaseModel):
     kpoints: Kpoints = Field(description="The actual k-points used in the calculation.")
     parameters: dict[str, Any] = Field(description="The default-padded input parameters interpreted by VASP.")
     bandgap: float = Field(description="The bandgap - note that this field is derived from the Vasprun object.")
+    potcar_symbols : list[str] | None = Field(None, description="Optional: if a POTCAR is unavailable, this is used to determine the functional used in the calculation.")
 
     @classmethod
     def from_vasprun(cls, vasprun: Vasprun) -> Self:
@@ -95,6 +105,7 @@ class VaspInputSafe(BaseModel):
     structure: Structure = Field(description="The structure associated with the calculation.")
     kpoints: Kpoints | None = Field(None, description="The optional KPOINTS or IBZKPT file used in the calculation.")
     potcar: list[PotcarSummaryStats] | None = Field(None, description="The optional POTCAR used in the calculation.")
+    _pmg_vis : VaspInputSet | None = PrivateAttr(None)
 
     @model_serializer
     def deserialize_objects(self) -> dict[str, Any]:
@@ -111,7 +122,7 @@ def deserialize_objects(self) -> dict[str, Any]:
 
     @classmethod
     def from_vasp_input_set(cls, vis: VaspInputSet) -> Self:
-        return cls(
+        new_vis = cls(
             **{
                 k: getattr(vis, k)
                 for k in (
@@ -122,36 +133,23 @@ def from_vasp_input_set(cls, vis: VaspInputSet) -> Self:
             },
             potcar=PotcarSummaryStats.from_file(vis.potcar),
         )
+        new_vis._pmg_vis = vis
+        return new_vis
+
+    
+    def _calculate_ng(self, **kwargs) -> tuple[list[int], list[int]] | None:
+        """Interface to pymatgen vasp input set as needed."""
+        if self._pmg_vis:
+            return self._pmg_vis.calculate_ng(**kwargs)
+        return None
 
 
 class VaspFiles(BaseModel):
     """Define required and optional files for validation."""
 
-    user_input: VaspInputSafe = Field(description="The VASP input set used in the calculation.")
-    _outcar: os.PathLike | Outcar | LightOutcar | None = PrivateAttr(None)
-    _vasprun: os.PathLike | Vasprun | LightVasprun | None = PrivateAttr(None)
-
-    @cached_property
-    def outcar(self) -> LightOutcar | None:
-        """The optional OUTCAR."""
-        if self._outcar:
-            if not isinstance(self._outcar, Outcar | LightOutcar):
-                self._outcar = Outcar(self._outcar)
-            if isinstance(self._outcar, Outcar):
-                return LightOutcar(drift=self._outcar.drift, magnetization=self._outcar.magnetization)
-            return self._outcar
-        return None
-
-    @cached_property
-    def vasprun(self) -> LightVasprun | None:
-        """The optional vasprun.xml."""
-        if self._vasprun:
-            if not isinstance(self._vasprun, Vasprun | LightVasprun):
-                self._vasprun = Vasprun(self._vasprun)
-            if isinstance(self._vasprun, Vasprun):
-                return LightVasprun.from_vasprun(self._vasprun)
-            return self._vasprun
-        return None
+    user_input : VaspInputSafe = Field(description="The VASP input set used in the calculation.")
+    outcar: LightOutcar | None = None
+    vasprun: LightVasprun | None = None
 
     @property
     def actual_kpoints(self) -> Kpoints | None:
@@ -188,22 +186,34 @@ def from_paths(
             "kpoints": Kpoints,
             "poscar": Poscar,
             "potcar": PotcarSummaryStats,
+            "outcar": Outcar,
+            "vasprun": Vasprun,
         }
+        potcar_enmax = None
         for file_name, file_cls in to_obj.items():
             if (path := _vars.get(file_name)) and Path(path).exists():
                 if file_name == "poscar":
                     config["user_input"]["structure"] = file_cls.from_file(path).structure
-                else:
+                elif hasattr(file_cls,"from_file"):
                     config["user_input"][file_name] = file_cls.from_file(path)
+                else:
+                    config[file_name] = file_cls(path)
 
-        vf = cls(**config)
-        for file_name in ("outcar", "vasprun"):
-            if (path := _vars.get(file_name)) and Path(path).exists():
-                setattr(vf, f"_{file_name}", path)
+                if file_name == "potcar":
+                    potcar_enmax = max(ps.ENMAX for ps in Potcar.from_file(path))
+
+        if config.get("outcar"):
+            config["outcar"] = LightOutcar(
+                drift = config["outcar"].drift, magnetization=config["outcar"].magnetization,
+            )
+        if config.get("vasprun"):
+            config["vasprun"] = LightVasprun.from_vasprun(config["vasprun"])
+        else:
+            if not config["incar"].get("ENCUT") and potcar_enmax:
+                config["incar"]["ENCUT"] = potcar_enmax
 
-        return vf
+        return cls(**config)
 
-    @computed_field  # type: ignore[misc]
     @cached_property
     def run_type(self) -> str:
         """Get the run type of a calculation."""
@@ -234,7 +244,6 @@ def run_type(self) -> str:
 
         return run_type
 
-    @computed_field  # type: ignore[misc]
     @cached_property
     def functional(self) -> str:
         """Determine the functional used in the calculation.
@@ -247,6 +256,9 @@ def functional(self) -> str:
         func_from_potcar = None
         if self.user_input.potcar:
             func_from_potcar = {"pe": "pbe", "ca": "lda"}.get(self.user_input.potcar[0].lexch.lower())
+        elif self.vasprun and self.vasprun.potcar_symbols:
+            pot_func = self.vasprun.potcar_symbols[0].split()[0].split("_")[-1]
+            func_from_potcar = "pbe" if pot_func == "PBE" else "lda"
 
         if gga := self.user_input.incar.get("GGA"):
             if gga.lower() == "pe":
@@ -293,7 +305,6 @@ def bandgap(self) -> float | None:
             return self.vasprun.bandgap
         return None
 
-    @computed_field  # type: ignore[misc]
     @cached_property
     def valid_input_set(self) -> VaspInputSafe:
         """
@@ -310,6 +321,8 @@ def valid_input_set(self) -> VaspInputSafe:
                 set_name = "MPNonSCFSet"
             elif self.run_type == "nmr":
                 set_name = "MPNMRSet"
+            elif self.run_type == "md":
+                set_name = None
             else:
                 set_name = f"MP{self.run_type.capitalize()}Set"
         elif self.functional in ("pbesol", "scan", "r2scan", "hse06"):