tweak classes to allow for bad input sets to later fail in validation doc

Author: esoteric-ephemera

pymatgen/io/validation/common.py

@@ -229,8 +229,14 @@ class VaspFiles(BaseModel):
     """Define required and optional files for validation."""
 
     user_input: VaspInputSafe = Field(description="The VASP input set used in the calculation.")
-    outcar: Optional[LightOutcar] = None
-    vasprun: Optional[LightVasprun] = None
+    outcar: LightOutcar | None = None
+    vasprun: LightVasprun | None = None
+    run_type: str | None = Field(None, description="The type of VASP calculation performed.")
+    functional: str | None = Field(None, description="The density functional used in the calculation.")
+    valid_input_set_name: str | None = Field(
+        None, description="The import string of the reference MP-compatible input set."
+    )
+    validation_errors: list[str] = Field([], description="Errors arising when attempting to validate the input set.")
 
     @model_validator(mode="before")
     @classmethod
@@ -246,6 +252,17 @@ def coerce_to_lightweight(cls, config: Any) -> Any:
             config["vasprun"] = LightVasprun.from_vasprun(config["vasprun"])
         return config
 
+    @model_validator(mode="after")
+    def validate_inputs(self) -> Self:
+        """Check that the input set could be referenced against known input sets."""
+        self.validation_errors = []
+        self.run_type = self.set_run_type()
+        self.functional = self.set_functional()
+        self.valid_input_set_name = None  # Ensure this gets reset / checked
+        if self.run_type and self.functional:
+            self.valid_input_set_name = self.set_valid_input_set_name()
+        return self
+
     @property
     def md5(self) -> str:
         """Get MD5 of VaspFiles for use in validation checks."""
@@ -308,8 +325,7 @@ def from_paths(
 
         return cls(**config)
 
-    @cached_property
-    def run_type(self) -> str:
+    def set_run_type(self) -> str | None:
         """Get the run type of a calculation."""
 
         ibrion = self.user_input.incar.get("IBRION", VASP_DEFAULTS_DICT["IBRION"].value)
@@ -322,30 +338,28 @@ def run_type(self) -> str:
             **{k: "relax" for k in range(1, 4)},
             **{k: "phonon" for k in range(5, 9)},
             **{k: "ts" for k in (40, 44)},
-        }.get(ibrion)
+        }.get(ibrion, None)
 
         if self.user_input.incar.get("ICHARG", VASP_DEFAULTS_DICT["ICHARG"].value) >= 10:
             run_type = "nonscf"
         if self.user_input.incar.get("LCHIMAG", VASP_DEFAULTS_DICT["LCHIMAG"].value):
             run_type == "nmr"
 
         if run_type is None:
-            raise ValidationError(
+            self.validation_errors += [
                 "Could not determine a valid run type. We currently only validate "
                 "Geometry optimizations (relaxations), single-points (statics), "
                 "and non-self-consistent fixed charged density calculations. ",
-            )
+            ]
 
         return run_type
 
-    @cached_property
-    def functional(self) -> str:
+    def set_functional(self) -> str | None:
         """Determine the functional used in the calculation.
 
         Note that this is not a complete determination.
         Only the functionals used by MP are detected here.
         """
-
         func = None
         func_from_potcar = None
         if self.user_input.potcar:
@@ -364,11 +378,13 @@ def functional(self) -> str:
 
         if (metagga := self.user_input.incar.get("METAGGA")) and metagga.lower() != "none":
             if gga:
-                raise ValidationError(
+                self.validation_errors += [
                     "Both the GGA and METAGGA tags were set, which can lead to large errors. "
                     "For context, see:\n"
                     "https://github.com/materialsproject/atomate2/issues/453#issuecomment-1699605867"
-                )
+                ]
+                return None
+
             if metagga.lower() == "scan":
                 func = "scan"
             elif metagga.lower().startswith("r2sca"):
@@ -384,12 +400,13 @@ def functional(self) -> str:
 
         func = func or func_from_potcar
         if func is None:
-            raise ValidationError(
+            self.validation_errors += [
                 "Currently, we only validate calculations using the following functionals:\n"
                 "GGA : PBE, PBEsol\n"
                 "meta-GGA : SCAN, r2SCAN\n"
                 "Hybrids: HSE06"
-            )
+            ]
+
         return func
 
     @property
@@ -399,16 +416,14 @@ def bandgap(self) -> float | None:
             return self.vasprun.bandgap
         return None
 
-    @cached_property
-    def valid_input_set(self) -> VaspInputSafe:
+    def set_valid_input_set_name(self) -> str | None:
         """
-        Determine the MP-compliant input set for a calculation.
+        Determine the MP-compliant input set import string for a calculation.
 
         We need only determine a rough input set here.
         The precise details of the input set do not matter.
         """
 
-        incar_updates: dict[str, Any] = {}
         set_name: str | None = None
         if self.functional == "pbe":
             if self.run_type == "nonscf":
@@ -420,26 +435,36 @@ def valid_input_set(self) -> VaspInputSafe:
             elif self.run_type in ("relax", "static"):
                 set_name = f"MP{self.run_type.capitalize()}Set"
         elif self.functional in ("pbesol", "scan", "r2scan", "hse06"):
-            if self.functional == "pbesol":
-                incar_updates["GGA"] = "PS"
-            elif self.functional == "scan":
-                incar_updates["METAGGA"] = "SCAN"
-            elif self.functional == "hse06":
-                incar_updates.update(
-                    LHFCALC=True,
-                    HFSCREEN=0.2,
-                    GGA="PE",
-                )
             set_name = f"MPScan{self.run_type.capitalize()}Set"
 
         if set_name is None:
-            raise ValidationError(
+            self.validation_errors += [
                 "Could not determine a valid input set from the specified "
                 f"functional = {self.functional} and calculation type {self.run_type}."
-            )
+            ]
+            return None
+        return set_name
 
+    @cached_property
+    def valid_input_set(self) -> VaspInputSafe:
+        """Determine the MP-compliant input set for a calculation."""
+
+        if self.valid_input_set_name is None:
+            raise ValidationError("Cannot determine a valid input set, see `validation_errors` for more details.")
+
+        incar_updates: dict[str, Any] = {}
+        if self.functional == "pbesol":
+            incar_updates["GGA"] = "PS"
+        elif self.functional == "scan":
+            incar_updates["METAGGA"] = "SCAN"
+        elif self.functional == "hse06":
+            incar_updates.update(
+                LHFCALC=True,
+                HFSCREEN=0.2,
+                GGA="PE",
+            )
         # Note that only the *previous* bandgap informs the k-point density
-        vis = getattr(import_module("pymatgen.io.vasp.sets"), set_name)(
+        vis = getattr(import_module("pymatgen.io.vasp.sets"), self.valid_input_set_name)(
             structure=self.user_input.structure,
             bandgap=None,
             user_incar_settings=incar_updates,

pymatgen/io/validation/validation.py

@@ -1,8 +1,9 @@
 """Define core validation schema."""
 
 from __future__ import annotations
+
 from pathlib import Path
-from pydantic import BaseModel, Field, PrivateAttr
+from pydantic import BaseModel, Field, PrivateAttr, computed_field
 from typing import TYPE_CHECKING
 
 from monty.os.path import zpath
@@ -35,6 +36,7 @@ class VaspValidator(BaseModel):
 
     _validated_md5: str | None = PrivateAttr(None)
 
+    @computed_field  # type: ignore[misc]
     @property
     def valid(self) -> bool:
         """Determine if the calculation is valid after ensuring inputs have not changed."""
@@ -49,13 +51,16 @@ def has_warnings(self) -> bool:
     def recheck(self) -> None:
         """Rerun validation, prioritizing speed."""
         new_md5 = None
-        if self._validated_md5 is None or (new_md5 := self.vasp_files.md5) != self._validated_md5:
+        if (self._validated_md5 is None) or (new_md5 := self.vasp_files.md5) != self._validated_md5:
+            self.reasons = []
+            self.warnings = []
 
             if self.vasp_files.user_input.potcar:
                 check_list = DEFAULT_CHECKS
             else:
                 check_list = [c for c in DEFAULT_CHECKS if c.__name__ != "CheckPotcar"]
             self.reasons, self.warnings = self.run_checks(self.vasp_files, check_list=check_list, fast=True)
+
             self._validated_md5 = new_md5 or self.vasp_files.md5
 
     @staticmethod
@@ -82,6 +87,11 @@ def run_checks(
             The first list are all reasons for validation failure,
             the second list contains all warnings.
         """
+
+        if vasp_files.validation_errors:
+            # Cannot validate the calculation, immediate failure
+            return vasp_files.validation_errors, []
+
         reasons: list[str] = []
         warnings: list[str] = []
         for check in check_list:

pymatgen/io/validation/vasp_defaults.py

@@ -922,7 +922,7 @@ def format_val(val: Any) -> Any:
     ),
     VaspParam(
         name="LORBIT",
-        value=None,
+        value=0,
         operation=None,
         alias="LORBIT",
         tag="misc_special",

pymatgen/io/validation/vasp_defaults.yaml

@@ -557,7 +557,7 @@
   warning:
   severity: reason
 - name: LORBIT
-  value:
+  value:  0
   operation:
   alias: LORBIT
   tag: misc_special

tests/test_validation.py

@@ -319,7 +319,8 @@ def test_common_error_checks(object_name):
             GGA="PE",
             METAGGA="R2SCAN",
         )
-        VaspFiles(**vfd).valid_input_set
+        vf_new = VaspFiles(**vfd)
+        vf_new.valid_input_set
 
     # Drift forces too high check - a warning
     vf = copy.deepcopy(vf_og)