Merge branch 'master' of github.com:materialsproject/pymatgen

Author: shyuep

src/pymatgen/core/composition.py

@@ -619,6 +619,9 @@ def _parse_formula(formula: str, strict: bool = True) -> dict[str, float]:
         # Square brackets are used in formulas to denote coordination complexes (gh-3583)
         formula = formula.replace("[", "(")
         formula = formula.replace("]", ")")
+        # next 2 lines covered by test_curly_bracket_deeply_nested_formulas
+        formula = formula.replace("{", "(")
+        formula = formula.replace("}", ")")
 
         def get_sym_dict(form: str, factor: float) -> dict[str, float]:
             sym_dict: dict[str, float] = defaultdict(float)

src/pymatgen/core/operations.py

@@ -19,7 +19,7 @@
 if TYPE_CHECKING:
     from typing import Any
 
-    from numpy.typing import ArrayLike
+    from numpy.typing import ArrayLike, NDArray
     from typing_extensions import Self
 
 __author__ = "Shyue Ping Ong, Shyam Dwaraknath, Matthew Horton"
@@ -31,7 +31,7 @@ class SymmOp(MSONable):
     for efficiency. Read: https://wikipedia.org/wiki/Affine_transformation.
 
     Attributes:
-        affine_matrix (np.ndarray): A 4x4 array representing the symmetry operation.
+        affine_matrix (NDArray): A 4x4 array representing the symmetry operation.
     """
 
     def __init__(
@@ -116,7 +116,7 @@ def from_rotation_and_translation(
         affine_matrix[:3][:, 3] = translation_vec
         return cls(affine_matrix, tol)
 
-    def operate(self, point: ArrayLike) -> np.ndarray:
+    def operate(self, point: ArrayLike) -> NDArray:
         """Apply the operation on a point.
 
         Args:
@@ -128,7 +128,7 @@ def operate(self, point: ArrayLike) -> np.ndarray:
         affine_point = np.asarray([*point, 1])
         return np.dot(self.affine_matrix, affine_point)[:3]
 
-    def operate_multi(self, points: ArrayLike) -> np.ndarray:
+    def operate_multi(self, points: ArrayLike) -> NDArray:
         """Apply the operation on a list of points.
 
         Args:
@@ -141,7 +141,7 @@ def operate_multi(self, points: ArrayLike) -> np.ndarray:
         affine_points = np.concatenate([points, np.ones(points.shape[:-1] + (1,))], axis=-1)
         return np.inner(affine_points, self.affine_matrix)[..., :-1]
 
-    def apply_rotation_only(self, vector: ArrayLike) -> np.ndarray:
+    def apply_rotation_only(self, vector: ArrayLike) -> NDArray:
         """Vectors should only be operated by the rotation matrix and not the
         translation vector.
 
@@ -150,7 +150,7 @@ def apply_rotation_only(self, vector: ArrayLike) -> np.ndarray:
         """
         return np.dot(self.rotation_matrix, vector)
 
-    def transform_tensor(self, tensor: np.ndarray) -> np.ndarray:
+    def transform_tensor(self, tensor: NDArray) -> NDArray:
         """Apply rotation portion to a tensor. Note that tensor has to be in
         full form, not the Voigt form.
 
@@ -239,12 +239,12 @@ def are_symmetrically_related_vectors(
         return False, False
 
     @property
-    def rotation_matrix(self) -> np.ndarray:
+    def rotation_matrix(self) -> NDArray:
         """A 3x3 numpy.array representing the rotation matrix."""
         return self.affine_matrix[:3][:, :3]
 
     @property
-    def translation_vector(self) -> np.ndarray:
+    def translation_vector(self) -> NDArray:
         """A rank 1 numpy.array of dim 3 representing the translation vector."""
         return self.affine_matrix[:3][:, 3]
 
@@ -462,16 +462,17 @@ def as_xyz_str(self) -> str:
     def from_xyz_str(cls, xyz_str: str) -> Self:
         """
         Args:
-            xyz_str: string of the form 'x, y, z', '-x, -y, z', '-2y+1/2, 3x+1/2, z-y+1/2', etc.
+            xyz_str (str): "x, y, z", "-x, -y, z", "-2y+1/2, 3x+1/2, z-y+1/2", etc.
 
         Returns:
             SymmOp
         """
-        rot_matrix = np.zeros((3, 3))
-        trans = np.zeros(3)
-        tokens = xyz_str.strip().replace(" ", "").lower().split(",")
+        rot_matrix: NDArray = np.zeros((3, 3))
+        trans: NDArray = np.zeros(3)
+        tokens: list[str] = xyz_str.strip().replace(" ", "").lower().split(",")
         re_rot = re.compile(r"([+-]?)([\d\.]*)/?([\d\.]*)([x-z])")
         re_trans = re.compile(r"([+-]?)([\d\.]+)/?([\d\.]*)(?![x-z])")
+
         for idx, tok in enumerate(tokens):
             # Build the rotation matrix
             for match in re_rot.finditer(tok):
@@ -480,11 +481,13 @@ def from_xyz_str(cls, xyz_str: str) -> Self:
                     factor *= float(match[2]) / float(match[3]) if match[3] != "" else float(match[2])
                 j = ord(match[4]) - 120
                 rot_matrix[idx, j] = factor
+
             # Build the translation vector
             for match in re_trans.finditer(tok):
                 factor = -1 if match[1] == "-" else 1
                 num = float(match[2]) / float(match[3]) if match[3] != "" else float(match[2])
                 trans[idx] = num * factor
+
         return cls.from_rotation_and_translation(rot_matrix, trans)
 
     @classmethod

src/pymatgen/io/cif.py

@@ -820,7 +820,7 @@ def get_symops(self, data: CifBlock) -> list[SymmOp]:
             msg = "No _symmetry_equiv_pos_as_xyz type key found. Defaulting to P1."
             warnings.warn(msg, stacklevel=2)
             self.warnings.append(msg)
-            sym_ops = [SymmOp.from_xyz_str(s) for s in ("x", "y", "z")]
+            sym_ops = [SymmOp.from_xyz_str("x, y, z")]
 
         return sym_ops
 

src/pymatgen/io/vasp/outputs.py

@@ -4719,9 +4719,9 @@ def concatenate(
                         preamble.append(line)
                 elif line == "" or "Direct configuration=" in line:
                     poscar = Poscar.from_str("\n".join([*preamble, "Direct", *coords_str]))
-                    if (
-                        ionicstep_end is None and ionicstep_cnt >= ionicstep_start
-                    ) or ionicstep_start <= ionicstep_cnt < ionicstep_end:
+                    if (ionicstep_end is None and ionicstep_cnt >= ionicstep_start) or (
+                        ionicstep_end is not None and ionicstep_start <= ionicstep_cnt < ionicstep_end
+                    ):
                         structures.append(poscar.structure)
                     ionicstep_cnt += 1
                     coords_str = []

tests/core/test_composition.py

@@ -859,6 +859,19 @@ def test_isotopes(self):
         assert composition.elements[0].oxi_state == 1
         assert "Deuterium" in [elem.long_name for elem in composition.elements]
 
+    def test_curly_bracket_deeply_nested_formulas(self):
+        """Test parsing of bulk metallic glass formulas with complex nested brackets collected in
+        Ward et al. (2018) https://doi.org/10.1016/j.actamat.2018.08.002.
+        """
+        for formula, expected in {
+            "{[(Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}100": "Nb4 Fe43.2 Co28.8 Si4.8 B19.2",
+            "{[(Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}99Cr1": "Nb3.96 Cr1 Fe42.768 Co28.512 Si4.752 B19.008",
+            "{[(Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}98Cr2": "Nb3.92 Cr2 Fe42.336 Co28.224 Si4.704 B18.816",
+            "{[(Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}97Cr3": "Nb3.88 Cr3 Fe41.904 Co27.936 Si4.656 B18.624",
+            "{[(Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}96Cr4": "Nb3.84 Cr4 Fe41.472 Co27.648 Si4.608 B18.432",
+        }.items():
+            assert Composition(formula).formula == expected
+
 
 def test_reduce_formula():
     assert reduce_formula({"Li": 2, "Mn": 4, "O": 8}) == ("LiMn2O4", 2)

tests/io/test_cif.py

@@ -2,10 +2,11 @@
 
 import numpy as np
 import pytest
+from monty.tempfile import ScratchDir
 from pytest import approx
 
 from pymatgen.analysis.structure_matcher import StructureMatcher
-from pymatgen.core import Composition, DummySpecies, Element, Lattice, Species, Structure
+from pymatgen.core import Composition, DummySpecies, Element, Lattice, Species, Structure, SymmOp
 from pymatgen.electronic_structure.core import Magmom
 from pymatgen.io.cif import CifBlock, CifParser, CifWriter
 from pymatgen.symmetry.structure import SymmetrizedStructure
@@ -243,6 +244,23 @@ def test_get_symmetrized_structure(self):
         ]
         assert set(sym_structure.labels) == {"O1", "Li1"}
 
+    def test_no_sym_ops(self):
+        with ScratchDir("."):
+            with open(f"{TEST_FILES_DIR}/cif/Li2O.cif") as fin, open("test.cif", "w") as fout:
+                for line_num, line in enumerate(fin, start=1):
+                    # Skip "_symmetry_equiv_pos_as_xyz", "_symmetry_space_group_name_H-M"
+                    # and "_symmetry_Int_Tables_number" sections such that
+                    # no symmop info would be available
+                    if line_num not in range(44, 236) and line_num not in {40, 41}:
+                        fout.write(line)
+
+            parser = CifParser("test.cif")
+
+        # Need `parse_structures` call to update `symmetry_operations`
+        _structure = parser.parse_structures(primitive=False, symmetrized=False)[0]
+        assert parser.symmetry_operations[0] == SymmOp.from_xyz_str("x, y, z")
+        assert any("No _symmetry_equiv_pos_as_xyz type key found" in msg for msg in parser.warnings)
+
     def test_site_symbol_preference(self):
         parser = CifParser(f"{TEST_FILES_DIR}/cif/site_type_symbol_test.cif")
         assert parser.parse_structures()[0].formula == "Ge1.6 Sb1.6 Te4"