Change XAS behavior under negative frequencies (#4176)

* revert behavior of xas spectra to only warn user when intensities are negative

* esure that absorbing element is an Element

Author: esoteric-ephemera

src/pymatgen/analysis/xas/spectrum.py

@@ -10,12 +10,16 @@
 from scipy.interpolate import interp1d
 
 from pymatgen.analysis.structure_matcher import StructureMatcher
+from pymatgen.core import Element
 from pymatgen.core.spectrum import Spectrum
 from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
     from typing import Literal
 
+    from pymatgen.core import Structure
+
 __author__ = "Chen Zheng, Yiming Chen"
 __copyright__ = "Copyright 2012, The Materials Project"
 __version__ = "3.0"
@@ -42,29 +46,31 @@ class XAS(Spectrum):
     Attributes:
         x (Sequence[float]): The sequence of energies.
         y (Sequence[float]): The sequence of mu(E).
-        absorbing_element (str): The absorbing element of the spectrum.
+        absorbing_element (str or .Element): The absorbing element of the spectrum.
         edge (str): The edge of the spectrum.
         spectrum_type (str): The type of the spectrum (XANES or EXAFS).
         absorbing_index (int): The absorbing index of the spectrum.
+        zero_negative_intensity (bool) : Whether to set unphysical negative intensities to zero
     """
 
     XLABEL = "Energy"
     YLABEL = "Intensity"
 
     def __init__(
         self,
-        x,
-        y,
-        structure,
-        absorbing_element,
-        edge="K",
-        spectrum_type="XANES",
-        absorbing_index=None,
+        x: Sequence,
+        y: Sequence,
+        structure: Structure,
+        absorbing_element: str | Element,
+        edge: str = "K",
+        spectrum_type: str = "XANES",
+        absorbing_index: int | None = None,
+        zero_negative_intensity: bool = False,
     ):
         """Initialize a spectrum object."""
         super().__init__(x, y, structure, absorbing_element, edge)
         self.structure = structure
-        self.absorbing_element = absorbing_element
+        self.absorbing_element = Element(absorbing_element)
         self.edge = edge
         self.spectrum_type = spectrum_type
         self.e0 = self.x[np.argmax(np.gradient(self.y) / np.gradient(self.x))]
@@ -75,8 +81,16 @@ def __init__(
         ]
         self.absorbing_index = absorbing_index
         # check for empty spectra and negative intensities
-        if sum(1 for i in self.y if i <= 0) / len(self.y) > 0.05:
-            raise ValueError("Double check the intensities. Most of them are non-positive.")
+        neg_intens_mask = self.y < 0.0
+        if len(self.y[neg_intens_mask]) / len(self.y) > 0.05:
+            warnings.warn(
+                "Double check the intensities. More than 5% of them are negative.",
+                UserWarning,
+                stacklevel=2,
+            )
+        self.zero_negative_intensity = zero_negative_intensity
+        if self.zero_negative_intensity:
+            self.y[neg_intens_mask] = 0.0
 
     def __str__(self):
         return (

tests/analysis/xas/test_spectrum.py

@@ -67,10 +67,10 @@ def test_str(self):
         assert str(self.k_xanes) == "Co K Edge XANES for LiCoO2: <super: <class 'XAS'>, <XAS object>>"
 
     def test_validate(self):
-        y_zeros = np.zeros(len(self.k_xanes.x))
-        with pytest.raises(
-            ValueError,
-            match="Double check the intensities. Most of them are non-positive",
+        y_zeros = -np.ones(len(self.k_xanes.x))
+        with pytest.warns(
+            UserWarning,
+            match="Double check the intensities. More than 5% of them are negative.",
         ):
             XAS(
                 self.k_xanes.x,
@@ -79,6 +79,17 @@ def test_validate(self):
                 self.k_xanes.absorbing_element,
             )
 
+    def test_zero_negative_intensity(self):
+        y_w_neg_intens = [(-1) ** i * v for i, v in enumerate(self.k_xanes.y)]
+        spectrum = XAS(
+            self.k_xanes.x,
+            y_w_neg_intens,
+            self.k_xanes.structure,
+            self.k_xanes.absorbing_element,
+            zero_negative_intensity=True,
+        )
+        assert all(v == 0.0 for i, v in enumerate(spectrum.y) if i % 2 == 1)
+
     def test_stitch_xafs(self):
         with pytest.raises(ValueError, match="Invalid mode. Only XAFS and L23 are supported"):
             XAS.stitch(self.k_xanes, self.k_exafs, mode="invalid")