[WIP] Better input set generator and sets for io.lammps

src/pymatgen/core/periodic_table.py

@@ -19,6 +19,7 @@
 from typing import TYPE_CHECKING, overload
 
 import numpy as np
+from monty.dev import deprecated
 from monty.json import MSONable
 
 from pymatgen.core.units import SUPPORTED_UNIT_NAMES, FloatWithUnit, Ha_to_eV, Length, Mass, Unit
@@ -776,6 +777,19 @@ def is_rare_earth(self) -> bool:
         """
         return self.is_lanthanoid or self.is_actinoid or self.symbol in {"Sc", "Y"}
 
+    @property
+    @deprecated(
+        is_rare_earth,
+        message="is_rare_earth is corrected to include Y and Sc.",
+        deadline=(2025, 1, 1),
+    )
+    def is_rare_earth_metal(self) -> bool:
+        """True if element is a rare earth metal, Lanthanides (La) series and Actinides (Ac) series.
+
+        This property is Deprecated, and scheduled for removal after 2025-01-01.
+        """
+        return self.is_lanthanoid or self.is_actinoid
+
     @property
     def is_metal(self) -> bool:
         """True if is a metal."""

src/pymatgen/io/exciting/inputs.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import itertools
-import warnings
 import xml.etree.ElementTree as ET
 from typing import TYPE_CHECKING
 
@@ -17,13 +16,10 @@
 from pymatgen.symmetry.bandstructure import HighSymmKpath
 
 if TYPE_CHECKING:
-    from typing import ClassVar, Literal
+    from pathlib import Path
 
-    from numpy.typing import ArrayLike, NDArray
     from typing_extensions import Self
 
-    from pymatgen.util.typing import PathLike
-
 __author__ = "Christian Vorwerk"
 __copyright__ = "Copyright 2016"
 __version__ = "1.0"
@@ -41,18 +37,10 @@ class ExcitingInput(MSONable):
     Attributes:
         structure (Structure): Associated Structure.
         title (str): Optional title string.
-        lockxyz (Nx3 NDArray of booleans): Lockxyz attribute for each site if available.
+        lockxyz (numpy.ndarray): Lockxyz attribute for each site if available. A Nx3 array of booleans.
     """
 
-    # Conversion factor between Bohr radius and Angstrom
-    bohr2ang: ClassVar[float] = const.value("Bohr radius") / const.value("Angstrom star")
-
-    def __init__(
-        self,
-        structure: Structure,
-        title: str | None = None,
-        lockxyz: ArrayLike | None = None,
-    ) -> None:
+    def __init__(self, structure: Structure, title=None, lockxyz=None):
         """
         Args:
             structure (Structure): Structure object.
@@ -64,19 +52,22 @@ def __init__(
         if structure.is_ordered:
             site_properties = {}
             if lockxyz:
-                site_properties["selective_dynamics"] = np.asarray(lockxyz)
+                site_properties["selective_dynamics"] = lockxyz
             self.structure = structure.copy(site_properties=site_properties)
             self.title = structure.formula if title is None else title
         else:
             raise ValueError("Structure with partial occupancies cannot be converted into exciting input!")
 
+    # define conversion factor between Bohr radius and Angstrom
+    bohr2ang = const.value("Bohr radius") / const.value("Angstrom star")
+
     @property
-    def lockxyz(self) -> NDArray:
+    def lockxyz(self):
         """Selective dynamics site properties."""
         return self.structure.site_properties.get("selective_dynamics")
 
     @lockxyz.setter
-    def lockxyz(self, lockxyz: ArrayLike) -> NDArray:
+    def lockxyz(self, lockxyz):
         self.structure.add_site_property("selective_dynamics", lockxyz)
 
     @classmethod
@@ -173,7 +164,7 @@ def from_str(cls, data: str) -> Self:
         return cls(structure_in, title_in, lockxyz)
 
     @classmethod
-    def from_file(cls, filename: PathLike) -> Self:
+    def from_file(cls, filename: str | Path) -> Self:
         """
         Args:
             filename: Filename.
@@ -187,27 +178,32 @@ def from_file(cls, filename: PathLike) -> Self:
 
     def write_etree(
         self,
-        celltype: Literal["unchanged", "conventional", "primitive"],
-        cartesian: bool = False,
-        bandstr: bool = False,
+        celltype,
+        cartesian=False,
+        bandstr=False,
         symprec: float = 0.4,
-        angle_tolerance: float = 5,
+        angle_tolerance=5,
         **kwargs,
-    ) -> ET.Element:
-        """Convert the exciting input parameters to an XML Element object.
+    ):
+        """Write the exciting input parameters to an XML object.
 
         Args:
             celltype (str): Choice of unit cell. Can be either the unit cell
                 from self.structure ("unchanged"), the conventional cell
                 ("conventional"), or the primitive unit cell ("primitive").
+
             cartesian (bool): Whether the atomic positions are provided in
                 Cartesian or unit-cell coordinates. Default is False.
+
             bandstr (bool): Whether the bandstructure path along the
                 HighSymmKpath is included in the input file. Only supported if the
                 celltype is set to "primitive". Default is False.
+
             symprec (float): Tolerance for the symmetry finding. Default is 0.4.
+
             angle_tolerance (float): Angle tolerance for the symmetry finding.
-                Default is 5.
+            Default is 5.
+
             **kwargs: Additional parameters for the input file.
 
         Returns:
@@ -301,68 +297,77 @@ def write_etree(
 
     def write_string(
         self,
-        celltype: Literal["unchanged", "conventional", "primitive"],
-        cartesian: bool = False,
-        bandstr: bool = False,
+        celltype,
+        cartesian=False,
+        bandstr=False,
         symprec: float = 0.4,
-        angle_tolerance: float = 5,
+        angle_tolerance=5,
         **kwargs,
-    ) -> str:
-        """Convert exciting input to a string.
+    ):
+        """Write exciting input.xml as a string.
 
         Args:
             celltype (str): Choice of unit cell. Can be either the unit cell
-                from self.structure ("unchanged"), the conventional cell
-                ("conventional"), or the primitive unit cell ("primitive").
+            from self.structure ("unchanged"), the conventional cell
+            ("conventional"), or the primitive unit cell ("primitive").
+
             cartesian (bool): Whether the atomic positions are provided in
-                Cartesian or unit-cell coordinates. Default is False.
+            Cartesian or unit-cell coordinates. Default is False.
+
             bandstr (bool): Whether the bandstructure path along the
-                HighSymmKpath is included in the input file. Only supported if the
-                celltype is set to "primitive". Default is False.
+            HighSymmKpath is included in the input file. Only supported if the
+            celltype is set to "primitive". Default is False.
+
             symprec (float): Tolerance for the symmetry finding. Default is 0.4.
+
             angle_tolerance (float): Angle tolerance for the symmetry finding.
-                Default is 5.
+            Default is 5.
+
             **kwargs: Additional parameters for the input file.
 
         Returns:
-            str
+            String
         """
         try:
             root = self.write_etree(celltype, cartesian, bandstr, symprec, angle_tolerance, **kwargs)
             self._indent(root)
             # output should be a string not a bytes object
             string = ET.tostring(root).decode("UTF-8")
-
         except Exception:
             raise ValueError("Incorrect celltype!")
-
         return string
 
     def write_file(
         self,
-        celltype: Literal["unchanged", "conventional", "primitive"],
-        filename: PathLike,
-        cartesian: bool = False,
-        bandstr: bool = False,
+        celltype,
+        filename,
+        cartesian=False,
+        bandstr=False,
         symprec: float = 0.4,
-        angle_tolerance: float = 5,
+        angle_tolerance=5,
         **kwargs,
-    ) -> None:
+    ):
         """Write exciting input file.
 
         Args:
             celltype (str): Choice of unit cell. Can be either the unit cell
-                from self.structure ("unchanged"), the conventional cell
-                ("conventional"), or the primitive unit cell ("primitive").
-            filename (PathLike): Filename for exciting input.
+            from self.structure ("unchanged"), the conventional cell
+            ("conventional"), or the primitive unit cell ("primitive").
+
+            filename (str): Filename for exciting input.
+
             cartesian (bool): Whether the atomic positions are provided in
-                Cartesian or unit-cell coordinates. Default is False.
+            Cartesian or unit-cell coordinates. Default is False.
+
             bandstr (bool): Whether the bandstructure path along the
-                HighSymmKpath is included in the input file. Only supported if the
-                celltype is set to "primitive". Default is False.
+            HighSymmKpath is included in the input file. Only supported if the
+            celltype is set to "primitive". Default is False.
+
             symprec (float): Tolerance for the symmetry finding. Default is 0.4.
+
             angle_tolerance (float): Angle tolerance for the symmetry finding.
-                Default is 5.
+            Default is 5.
+
             **kwargs: Additional parameters for the input file.
         """
         try:
@@ -373,15 +378,15 @@ def write_file(
         except Exception:
             raise ValueError("Incorrect celltype!")
 
+    # Missing PrettyPrint option in the current version of xml.etree.cElementTree
     @staticmethod
-    def _indent(elem: ET.Element, level: int = 0) -> None:
+    def _indent(elem, level=0):
         """
-        Helper method to indent elements, as missing PrettyPrint option
-        in the current version of xml.etree.cElementTree.
+        Helper method to indent elements.
 
         Args:
-            elem (ET.Element): The Element to process.
-            level (int): The indentation level.
+            elem:
+            level:
         """
         i = "\n" + level * "  "
         if len(elem):
@@ -396,23 +401,19 @@ def _indent(elem: ET.Element, level: int = 0) -> None:
         elif level and (not elem.tail or not elem.tail.strip()):
             elem.tail = i
 
-    def _dicttoxml(self, paramdict_: dict, element: ET.Element) -> None:
+    def _dicttoxml(self, paramdict_, element):
         for key, value in paramdict_.items():
             if isinstance(value, str) and key == "text()":
                 element.text = value
-
             elif isinstance(value, str):
                 element.attrib[key] = value
-
             elif isinstance(value, list):
                 for item in value:
                     self._dicttoxml(item, ET.SubElement(element, key))
-
             elif isinstance(value, dict):
                 if element.findall(key) == []:
                     self._dicttoxml(value, ET.SubElement(element, key))
                 else:
                     self._dicttoxml(value, element.findall(key)[0])
-
             else:
-                warnings.warn(f"cannot deal with {key} = {value}", stacklevel=2)
+                print("cannot deal with", key, "=", value)