structuretoolkit 0.0.26__tar.gz → 0.0.27__tar.gz

{structuretoolkit-0.0.26/structuretoolkit.egg-info → structuretoolkit-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: structuretoolkit
-Version: 0.0.26
+Version: 0.0.27
 Summary: build, analyse and visualise atomistic structures for materials science
 Author-email: Jan Janssen <janssen@mpie.de>
 License: BSD 3-Clause License
@@ -58,7 +58,7 @@ Provides-Extra: grainboundary
 Requires-Dist: aimsgb<=1.1.1,>=1.0.2; extra == "grainboundary"
 Requires-Dist: pymatgen<=2024.6.10,>=2022.2.1; extra == "grainboundary"
 Provides-Extra: pyscal
-Requires-Dist: pyscal2==2.10.18; extra == "pyscal"
+Requires-Dist: pyscal3==3.2.5; extra == "pyscal"
 Provides-Extra: nglview
 Requires-Dist: nglview<=3.1.2,>=2.7.7; extra == "nglview"
 Provides-Extra: matplotlib
@@ -66,14 +66,14 @@ Requires-Dist: matplotlib==3.8.4; extra == "matplotlib"
 Provides-Extra: plotly
 Requires-Dist: plotly<=5.22.0,>=4.14.3; extra == "plotly"
 Provides-Extra: clusters
-Requires-Dist: scikit-learn==1.5.0; extra == "clusters"
+Requires-Dist: scikit-learn==1.5.1; extra == "clusters"
 Provides-Extra: symmetry
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "symmetry"
 Provides-Extra: surface
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "surface"
 Requires-Dist: pymatgen<=2024.6.10,>=2022.2.1; extra == "surface"
 Provides-Extra: phonopy
-Requires-Dist: phonopy<=2.24.3,>=2.16.2; extra == "phonopy"
+Requires-Dist: phonopy<=2.26.3,>=2.16.2; extra == "phonopy"
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "phonopy"
 Provides-Extra: pyxtal
 Requires-Dist: pyxtal<=0.6.7,>=0.5.5; extra == "pyxtal"

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/pyproject.toml

@@ -41,18 +41,18 @@ grainboundary = [
     "aimsgb>=1.0.2,<=1.1.1",
     "pymatgen>=2022.2.1,<=2024.6.10",
 ]
-pyscal = ["pyscal2==2.10.18"]
+pyscal = ["pyscal3==3.2.5"]
 nglview = ["nglview>=2.7.7,<=3.1.2"]
 matplotlib = ["matplotlib==3.8.4"]
 plotly = ["plotly>=4.14.3,<=5.22.0"]
-clusters = ["scikit-learn==1.5.0"]
+clusters = ["scikit-learn==1.5.1"]
 symmetry = ["spglib>=1.16.5,<=2.4.0"]
 surface = [
     "spglib>=1.16.5,<=2.4.0",
     "pymatgen>=2022.2.1,<=2024.6.10",
 ]
 phonopy = [
-    "phonopy>=2.16.2,<=2.24.3",
+    "phonopy>=2.16.2,<=2.26.3",
     "spglib>=1.16.5,<=2.4.0",
 ]
 pyxtal = ["pyxtal>=0.5.5,<=0.6.7"]

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/structuretoolkit/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-06-25T10:24:48+0200",
+ "date": "2024-07-10T10:21:34+0200",
  "dirty": true,
  "error": null,
- "full-revisionid": "ad534b234cdbd638aeea242cefa4077059fd2ed8",
- "version": "0.0.26"
+ "full-revisionid": "bf6acd3da4ce39b1035efcb21b1f1027cca9d388",
+ "version": "0.0.27"
 }
 '''  # END VERSION_JSON
 

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/structuretoolkit/analyse/pyscal.py

@@ -47,11 +47,8 @@ def get_steinhardt_parameters(
     sys = ase_to_pyscal(structure)
     q = (4, 6) if q is None else q
 
-    sys.find_neighbors(method=neighbor_method, cutoff=cutoff)
-
-    sys.calculate_q(q, averaged=averaged)
-
-    sysq = np.array(sys.get_qvals(q, averaged=averaged))
+    sys.find.neighbors(method=neighbor_method, cutoff=cutoff)
+    sysq = np.array(sys.calculate.steinhardt_parameter(q, averaged=averaged))
 
     if n_clusters is not None:
         from sklearn import cluster
@@ -78,7 +75,7 @@ def get_centro_symmetry_descriptors(
         csm (list) : list of centrosymmetry parameter
     """
     sys = ase_to_pyscal(structure)
-    return np.array(sys.calculate_centrosymmetry(nmax=num_neighbors))
+    return np.array(sys.calculate.centrosymmetry(nmax=num_neighbors))
 
 
 def get_diamond_structure_descriptors(
@@ -101,23 +98,19 @@ def get_diamond_structure_descriptors(
         (depends on `mode`)
     """
     sys = ase_to_pyscal(structure)
-    diamond_dict = sys.identify_diamond()
+    diamond_dict = sys.analyze.diamond_structure()
 
     ovito_identifiers = [
+        "Other",
         "Cubic diamond",
         "Cubic diamond (1st neighbor)",
         "Cubic diamond (2nd neighbor)",
         "Hexagonal diamond",
         "Hexagonal diamond (1st neighbor)",
         "Hexagonal diamond (2nd neighbor)",
-        "Other",
     ]
     pyscal_identifiers = [
         "others",
-        "fcc",
-        "hcp",
-        "bcc",
-        "ico",
         "cubic diamond",
         "cubic diamond 1NN",
         "cubic diamond 2NN",
@@ -125,19 +118,6 @@ def get_diamond_structure_descriptors(
         "hex diamond 1NN",
         "hex diamond 2NN",
     ]
-    convert_to_ovito = {
-        0: 6,
-        1: 6,
-        2: 6,
-        3: 6,
-        4: 6,
-        5: 0,
-        6: 1,
-        7: 2,
-        8: 3,
-        9: 4,
-        10: 5,
-    }
 
     if mode == "total":
         if not ovito_compatibility:
@@ -158,26 +138,22 @@ def get_diamond_structure_descriptors(
                 "IdentifyDiamond.counts.HEX_DIAMOND_SECOND_NEIGHBOR": diamond_dict[
                     "hex diamond 2NN"
                 ],
-                "IdentifyDiamond.counts.OTHER": diamond_dict["others"]
-                + diamond_dict["fcc"]
-                + diamond_dict["hcp"]
-                + diamond_dict["bcc"]
-                + diamond_dict["ico"],
+                "IdentifyDiamond.counts.OTHER": diamond_dict["others"],
             }
     elif mode == "numeric":
         if not ovito_compatibility:
-            return np.array([atom.structure for atom in sys.atoms])
+            return np.array(sys.atoms.structure)
         else:
-            return np.array([convert_to_ovito[atom.structure] for atom in sys.atoms])
+            return np.array([6 if x == 0 else x - 1 for x in sys.atoms.structure])
+
     elif mode == "str":
         if not ovito_compatibility:
-            return np.array([pyscal_identifiers[atom.structure] for atom in sys.atoms])
+            return np.array(
+                [pyscal_identifiers[structure] for structure in sys.atoms.structure]
+            )
         else:
             return np.array(
-                [
-                    ovito_identifiers[convert_to_ovito[atom.structure]]
-                    for atom in sys.atoms
-                ]
+                [ovito_identifiers[structure] for structure in sys.atoms.structure]
             )
     else:
         raise ValueError(
@@ -217,7 +193,7 @@ def get_adaptive_cna_descriptors(
         "CommonNeighborAnalysis.counts.ICO",
     ]
 
-    cna = sys.calculate_cna()
+    cna = sys.analyze.common_neighbor_analysis()
 
     if mode == "total":
         if not ovito_compatibility:
@@ -225,8 +201,7 @@ def get_adaptive_cna_descriptors(
         else:
             return {o: cna[p] for o, p in zip(ovito_parameter, pyscal_parameter)}
     else:
-        structure = sys.atoms
-        cnalist = np.array([atom.structure for atom in structure])
+        cnalist = np.array(sys.atoms.structure)
         if mode == "numeric":
             return cnalist
         elif mode == "str":
@@ -250,9 +225,8 @@ def get_voronoi_volumes(structure: Atoms) -> np.ndarray:
         structure : (ase.atoms.Atoms): The structure to analyze.
     """
     sys = ase_to_pyscal(structure)
-    sys.find_neighbors(method="voronoi")
-    structure = sys.atoms
-    return np.array([atom.volume for atom in structure])
+    sys.find.neighbors(method="voronoi")
+    return np.array(sys.atoms.voronoi.volume)
 
 
 def find_solids(
@@ -287,8 +261,8 @@ def find_solids(
         pyscal system: pyscal system when return_sys=True
     """
     sys = ase_to_pyscal(structure)
-    sys.find_neighbors(method=neighbor_method, cutoff=cutoff)
-    sys.find_solids(
+    sys.find.neighbors(method=neighbor_method, cutoff=cutoff)
+    sys.find.solids(
         bonds=bonds,
         threshold=threshold,
         avgthreshold=avgthreshold,
@@ -299,6 +273,4 @@ def find_solids(
     )
     if return_sys:
         return sys
-    structure = sys.atoms
-    solids = [atom for atom in structure if atom.solid]
-    return len(solids)
+    return np.sum(sys.atoms.solid)

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/structuretoolkit/analyse/symmetry.py

@@ -9,6 +9,8 @@ import numpy as np
 import spglib
 from scipy.spatial import cKDTree
 from typing import Optional
+import string
+from functools import cached_property
 
 import structuretoolkit.common.helper
 from structuretoolkit.common.error import SymmetryError
@@ -230,6 +232,33 @@ class Symmetry(dict):
             np.einsum("ijk->jki", v_reshaped)[self.permutations],
         ).reshape(np.shape(vectors)) / len(self["rotations"])
 
+    def symmetrize_tensor(self, tensor: np.ndarray) -> np.ndarray:
+        """
+        Symmetrization of any tensor. The tensor is defined by a matrix with a
+        shape of `n * (n_atoms, 3)`. For example, if the structure has 100
+        atoms, the vector can have a shape of (100, 3), (100, 3, 100, 3),
+        (100, 3, 100, 3, 100, 3) etc. Additionally, you can also have an array
+        of tensors, i.e. in this example you can have a shape like (4, 100, 3)
+        or (2, 100, 3, 100, 3). When the shape is (n, n_atoms, 3), the function
+        works in the same way as `symmetrize_vectors`, which might be somewhat
+        faster.
+
+        This function can be useful for the symmetrization of Hessian tensors,
+        or any other tensors which should be symmetric.
+
+        Args:
+            tensors (ndarray): n * (n_atoms, 3) tensor to symmetrize
+
+        Returns
+            (np.ndarray) symmetrized tensor of the same shape
+        """
+        return _SymmetrizeTensor(
+            tensor=tensor,
+            structure=self._structure,
+            rotations=self.rotations,
+            permutations=self.permutations,
+        ).result
+
     def _get_spglib_cell(
         self, use_elements: Optional[bool] = None, use_magmoms: Optional[bool] = None
     ) -> tuple:
@@ -389,3 +418,73 @@ class Symmetry(dict):
         if mesh is None:
             raise SymmetryError(spglib.spglib.spglib_error.message)
         return mesh
+
+
+class _SymmetrizeTensor:
+    def __init__(self, tensor, structure, rotations, permutations):
+        self._tensor = np.array(tensor)
+        self._structure = structure
+        self._rotations = rotations
+        self._permutations = permutations
+
+    @cached_property
+    def order(self):
+        order = len(self._tensor.shape) // 2
+        if self._tensor.shape[-2 * order :] != order * self._structure.positions.shape:
+            raise ValueError(
+                "Tensor must have a shape of a multiple of (n_atoms, 3). See"
+                " docstring for more info"
+            )
+        return order
+
+    @cached_property
+    def ij(self):
+        return string.ascii_lowercase[: 2 * self.order]
+
+    @property
+    def IJ(self):
+        return self.ij.upper()
+
+    @property
+    def ij_reorder(self):
+        return "".join(
+            [self.ij[ii] for ii in np.arange(2 * self.order).reshape(-1, 2).T.flatten()]
+        )
+
+    @property
+    def IJ_reorder(self):
+        return "".join(
+            [self.IJ[ii] for ii in np.arange(2 * self.order).reshape(2, -1).T.flatten()]
+        )
+
+    @cached_property
+    def t_t(self):
+        return np.einsum("...{}->{}...".format(self.ij, self.ij_reorder), self._tensor)
+
+    @cached_property
+    def str_einsum(self):
+        return (
+            ",".join(
+                [I + i for i, I in zip(self.ij[-self.order :], self.IJ[-self.order :])]
+            )
+            + ","
+            + self.IJ[: self.order]
+            + self.ij[self.order :]
+            + "...->..."
+            + self.IJ_reorder
+        )
+
+    @property
+    def result(self):
+        return np.mean(
+            [
+                np.einsum(
+                    self.str_einsum,
+                    *self.order * (rot,),
+                    self.t_t[tuple(np.meshgrid(*self.order * (perm,), indexing="ij"))],
+                    optimize=True,
+                )
+                for rot, perm in zip(self._rotations, self._permutations)
+            ],
+            axis=0,
+        )

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/structuretoolkit/common/pyscal.py

@@ -12,11 +12,7 @@ def ase_to_pyscal(structure: Atoms):
     Returns:
         Pyscal system: See the pyscal documentation.
     """
-    import pyscal.core as pc
+    import pyscal3 as pc
 
-    sys = pc.System()
-    sys.read_inputfile(
-        filename=structure,
-        format="ase",
-    )
+    sys = pc.System(structure, format="ase")
     return sys

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27/structuretoolkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: structuretoolkit
-Version: 0.0.26
+Version: 0.0.27
 Summary: build, analyse and visualise atomistic structures for materials science
 Author-email: Jan Janssen <janssen@mpie.de>
 License: BSD 3-Clause License
@@ -58,7 +58,7 @@ Provides-Extra: grainboundary
 Requires-Dist: aimsgb<=1.1.1,>=1.0.2; extra == "grainboundary"
 Requires-Dist: pymatgen<=2024.6.10,>=2022.2.1; extra == "grainboundary"
 Provides-Extra: pyscal
-Requires-Dist: pyscal2==2.10.18; extra == "pyscal"
+Requires-Dist: pyscal3==3.2.5; extra == "pyscal"
 Provides-Extra: nglview
 Requires-Dist: nglview<=3.1.2,>=2.7.7; extra == "nglview"
 Provides-Extra: matplotlib
@@ -66,14 +66,14 @@ Requires-Dist: matplotlib==3.8.4; extra == "matplotlib"
 Provides-Extra: plotly
 Requires-Dist: plotly<=5.22.0,>=4.14.3; extra == "plotly"
 Provides-Extra: clusters
-Requires-Dist: scikit-learn==1.5.0; extra == "clusters"
+Requires-Dist: scikit-learn==1.5.1; extra == "clusters"
 Provides-Extra: symmetry
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "symmetry"
 Provides-Extra: surface
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "surface"
 Requires-Dist: pymatgen<=2024.6.10,>=2022.2.1; extra == "surface"
 Provides-Extra: phonopy
-Requires-Dist: phonopy<=2.24.3,>=2.16.2; extra == "phonopy"
+Requires-Dist: phonopy<=2.26.3,>=2.16.2; extra == "phonopy"
 Requires-Dist: spglib<=2.4.0,>=1.16.5; extra == "phonopy"
 Provides-Extra: pyxtal
 Requires-Dist: pyxtal<=0.6.7,>=0.5.5; extra == "pyxtal"

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/structuretoolkit.egg-info/requires.txt

@@ -3,7 +3,7 @@ numpy<=1.26.4,>=1.23.5
 scipy<=1.14.0,>=1.9.3
 
 [clusters]
-scikit-learn==1.5.0
+scikit-learn==1.5.1
 
 [dscribe]
 dscribe==2.1.1
@@ -19,14 +19,14 @@ matplotlib==3.8.4
 nglview<=3.1.2,>=2.7.7
 
 [phonopy]
-phonopy<=2.24.3,>=2.16.2
+phonopy<=2.26.3,>=2.16.2
 spglib<=2.4.0,>=1.16.5
 
 [plotly]
 plotly<=5.22.0,>=4.14.3
 
 [pyscal]
-pyscal2==2.10.18
+pyscal3==3.2.5
 
 [pyxtal]
 pyxtal<=0.6.7,>=0.5.5

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/tests/test_pyscal.py

@@ -9,7 +9,7 @@ from ase.atoms import Atoms
 import structuretoolkit as stk
 
 try:
-    import pyscal
+    import pyscal3 as pyscal
 
     skip_pyscal_test = False
 except ImportError:
@@ -17,7 +17,7 @@ except ImportError:
 
 
 @unittest.skipIf(
-    skip_pyscal_test, "pyscal is not installed, so the pyscal tests are skipped."
+    skip_pyscal_test, "pyscal3 is not installed, so the pyscal3 tests are skipped."
 )
 class Testpyscal(unittest.TestCase):
     @classmethod
@@ -394,10 +394,6 @@ class Testpyscalatoms(unittest.TestCase):
     def test_analyse_pyscal_diamond_structure(self):
         pyscal_keys = [
             "others",
-            "fcc",
-            "hcp",
-            "bcc",
-            "ico",
             "cubic diamond",
             "cubic diamond 1NN",
             "cubic diamond 2NN",
@@ -438,10 +434,11 @@ class Testpyscalatoms(unittest.TestCase):
         res_dict_total = stk.analyse.get_diamond_structure_descriptors(
             structure=self.si_dia, mode="total", ovito_compatibility=False
         )
+
         self.assertEqual(
             sum([k in res_dict_total.keys() for k in pyscal_keys]), len(pyscal_keys)
         )
-        self.assertEqual(res_dict_total[pyscal_keys[5]], len(self.si_dia))
+        self.assertEqual(res_dict_total[pyscal_keys[1]], len(self.si_dia))
 
         res_numeric = stk.analyse.get_diamond_structure_descriptors(
             structure=self.al_fcc, mode="numeric", ovito_compatibility=False
@@ -462,7 +459,7 @@ class Testpyscalatoms(unittest.TestCase):
             structure=self.si_dia, mode="numeric", ovito_compatibility=False
         )
         self.assertEqual(len(res_numeric), len(self.si_dia))
-        self.assertTrue(all([v == 5 for v in res_numeric]))
+        self.assertTrue(all([v == 1 for v in res_numeric]))
 
         res_str = stk.analyse.get_diamond_structure_descriptors(
             structure=self.al_fcc, mode="str", ovito_compatibility=False

{structuretoolkit-0.0.26 → structuretoolkit-0.0.27}/tests/test_symmetry.py

@@ -18,6 +18,7 @@ except ImportError:
 
 try:
     import spglib
+    from structuretoolkit.analyse.symmetry import _SymmetrizeTensor
 
     skip_spglib_test = False
 except ImportError:
@@ -108,20 +109,22 @@ class TestAtoms(unittest.TestCase):
             "AlAl", scaled_positions=[(0, 0, 0), (0.5, 0.5, 0.5)], cell=cell, pbc=True
         )
         v = np.random.rand(6).reshape(-1, 3)
+        sym = stk.analyse.get_symmetry(structure=Al)
         self.assertAlmostEqual(
-            np.linalg.norm(
-                stk.analyse.get_symmetry(structure=Al).symmetrize_vectors(v)
-            ),
+            np.linalg.norm(sym.symmetrize_vectors(v)),
             0,
         )
         vv = np.random.rand(12).reshape(2, 2, 3)
-        for vvv in stk.analyse.get_symmetry(structure=Al).symmetrize_vectors(vv):
+        for vvv in sym.symmetrize_vectors(vv):
             self.assertAlmostEqual(np.linalg.norm(vvv), 0)
         Al.positions[0, 0] += 0.01
-        w = stk.analyse.get_symmetry(structure=Al).symmetrize_vectors(v)
+        w = sym.symmetrize_vectors(v)
         self.assertAlmostEqual(
             np.absolute(w[:, 0]).sum(), np.linalg.norm(w, axis=-1).sum()
         )
+        self.assertAlmostEqual(
+            np.linalg.norm(sym.symmetrize_vectors(v) - sym.symmetrize_tensor(v)), 0
+        )
 
     def test_get_symmetry_dataset(self):
         cell = 2.2 * np.identity(3)
@@ -155,7 +158,7 @@ class TestAtoms(unittest.TestCase):
         )
 
     def test_get_primitive_cell_hex(self):
-        elements = ['Fe', 'Fe', 'Fe', 'Fe', 'O', 'O', 'O', 'O', 'O', 'O']
+        elements = ["Fe", "Fe", "Fe", "Fe", "O", "O", "O", "O", "O", "O"]
         positions = [
             [0.0, 0.0, 4.89],
             [0.0, 0.0, 11.78],
@@ -174,8 +177,7 @@ class TestAtoms(unittest.TestCase):
         sym = stk.analyse.get_symmetry(structure=structure_repeat)
         structure_prim_base = sym.get_primitive_cell()
         self.assertEqual(
-            structure_prim_base.get_chemical_symbols(),
-            structure.get_chemical_symbols()
+            structure_prim_base.get_chemical_symbols(), structure.get_chemical_symbols()
         )
 
     def test_get_equivalent_points(self):
@@ -284,5 +286,57 @@ class TestAtoms(unittest.TestCase):
             stk.analyse.get_symmetry(structure=structure)
 
 
+@unittest.skipIf(
+    skip_spglib_test, "spglib is not installed, so the spglib tests are skipped."
+)
+class TestSymmetrizeTensors(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.structure = bulk("Al", cubic=True, a=4.0).repeat(2)
+        cls.dataset = {
+            "structure": cls.structure,
+            "rotations": np.eye(3),
+            "permutations": np.arange(len(cls.structure)),
+        }
+
+    def test_order(self):
+        with self.assertRaises(ValueError):
+            _SymmetrizeTensor(
+                tensor=np.array([1]), **self.dataset
+            ).order
+        self.assertEqual(
+            _SymmetrizeTensor(
+                tensor=np.random.randn(*self.structure.positions.shape), **self.dataset
+            ).order,
+            1,
+        )
+        self.assertEqual(
+            _SymmetrizeTensor(
+                tensor=np.random.randn(*2 * self.structure.positions.shape),
+                **self.dataset,
+            ).order,
+            2,
+        )
+
+    def test_indexing(self):
+        st = _SymmetrizeTensor(
+            tensor=np.random.randn(*2 * self.structure.positions.shape), **self.dataset
+        )
+        self.assertEqual(st.ij, "abcd")
+        self.assertEqual(st.ij_reorder, "acbd")
+        self.assertEqual(st.IJ, "ABCD")
+        self.assertEqual(st.IJ_reorder, "ACBD")
+
+    def test_str_einsum(self):
+        st = _SymmetrizeTensor(
+            tensor=np.random.randn(*2 * self.structure.positions.shape), **self.dataset
+        )
+        self.assertEqual(st.str_einsum, "Cc,Dd,ABcd...->...ACBD")
+        st = _SymmetrizeTensor(
+            tensor=np.random.randn(*self.structure.positions.shape), **self.dataset
+        )
+        self.assertEqual(st.str_einsum, "Bb,Ab...->...AB")
+
+
 if __name__ == "__main__":
     unittest.main()