symfc 1.0.0__tar.gz

symfc-1.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, symfc project
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

symfc-1.0.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: symfc
+Version: 1.0.0
+Summary: This is the symfc module.
+Author-email: Atsuto Seko <seko@cms.mtl.kyoto-u.ac.jp>
+Maintainer-email: Atsushi Togo <atztogo@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2023, symfc project
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: Homepage, https://github.com/symfc/symfc
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: spglib
+
+# symfc
+
+## What does symfc do?
+
+Atomic vibrations in crystals are often conveniently described using the phonon
+model. In this model, the crystal potential is expanded into a Taylor series
+with respect to atomic displacements from their equilibrium positions, and the
+expansion coefficients are referred to as force constants.
+
+Predicting phonon properties through computer simulations is becoming
+increasingly popular, with the supercell approach being one of the techniques
+employed for phonon calculations. In this method, force constants are derived
+from datasets of atomic forces and displacements obtained from supercell
+snapshots, which feature various configurations of atomic displacements.
+
+While force constants possess specific symmetries, those computed from
+displacement-force datasets often do not adhere to these symmetries due to
+factors such as numerical noise or approximations used. Symfc is a software
+designed to compute force constants from displacement-force datasets in the
+supercell approach, ensuring they meet the required symmetry constraints.
+
+For more detail, please refer https://arxiv.org/abs/2403.03588.

symfc-1.0.0/README.md

@@ -0,0 +1,22 @@
+# symfc
+
+## What does symfc do?
+
+Atomic vibrations in crystals are often conveniently described using the phonon
+model. In this model, the crystal potential is expanded into a Taylor series
+with respect to atomic displacements from their equilibrium positions, and the
+expansion coefficients are referred to as force constants.
+
+Predicting phonon properties through computer simulations is becoming
+increasingly popular, with the supercell approach being one of the techniques
+employed for phonon calculations. In this method, force constants are derived
+from datasets of atomic forces and displacements obtained from supercell
+snapshots, which feature various configurations of atomic displacements.
+
+While force constants possess specific symmetries, those computed from
+displacement-force datasets often do not adhere to these symmetries due to
+factors such as numerical noise or approximations used. Symfc is a software
+designed to compute force constants from displacement-force datasets in the
+supercell approach, ensuring they meet the required symmetry constraints.
+
+For more detail, please refer https://arxiv.org/abs/2403.03588.

symfc-1.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "symfc"
+dynamic = ["version"]
+readme = {file = "README.md", content-type = "text/markdown"}
+description = "This is the symfc module."
+authors = [
+    { name = "Atsuto Seko", email = "seko@cms.mtl.kyoto-u.ac.jp" }
+]
+maintainers = [
+    {name = "Atsushi Togo", email = "atztogo@gmail.com"}
+]
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "scipy",
+    "spglib",
+]
+license = {file = "LICENSE"}
+
+[project.urls]
+"Homepage" = "https://github.com/symfc/symfc"
+
+[tool.setuptools.dynamic]
+version = { attr = "symfc.version.__version__" }
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = "E203,W503"
+
+[tool.black]
+line-length = 88
+
+[tool.isort]
+profile = "black"

symfc-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

symfc-1.0.0/src/symfc/__init__.py

@@ -0,0 +1,4 @@
+"""Forcd constants calculation code: Symfc."""
+
+from .api_symfc import Symfc  # noqa F401
+from .version import __version__  # noqa F401

symfc-1.0.0/src/symfc/api_symfc.py

@@ -0,0 +1,180 @@
+"""Symfc API."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Optional, Union
+
+import numpy as np
+
+from symfc.basis_sets import FCBasisSetBase, FCBasisSetO2, FCBasisSetO3
+from symfc.solvers import FCSolverO2, FCSolverO2O3
+from symfc.utils.utils import SymfcAtoms
+
+
+class Symfc:
+    """Symfc API."""
+
+    def __init__(
+        self,
+        supercell: SymfcAtoms,
+        displacements: Optional[np.ndarray] = None,
+        forces: Optional[np.ndarray] = None,
+        use_mkl: bool = False,
+        log_level: int = 0,
+    ):
+        """Init method."""
+        self._supercell: SymfcAtoms = supercell
+        self._displacements: Optional[np.ndarray] = displacements
+        self._forces: Optional[np.ndarray] = forces
+        self._use_mkl = use_mkl
+        self._log_level = log_level
+
+        self._basis_set: dict[FCBasisSetBase] = {}
+        self._force_constants: dict[np.ndarray] = {}
+
+    @property
+    def basis_set(self) -> dict[FCBasisSetBase]:
+        """Return basis set instance.
+
+        Returns
+        -------
+        dict[FCBasisSet]
+            The key is the order of basis set in int.
+
+        """
+        return self._basis_set
+
+    @property
+    def force_constants(self) -> dict[np.ndarray]:
+        """Return force constants.
+
+        Returns
+        -------
+        dict[np.ndarray]
+            The key is the order of force_constants in int.
+
+        """
+        return self._force_constants
+
+    @property
+    def displacements(self) -> np.ndarray:
+        """Setter and getter of supercell displacements.
+
+        ndarray
+            shape=(n_snapshot, natom, 3), dtype='double', order='C'
+
+        """
+        return self._displacements
+
+    @displacements.setter
+    def displacements(self, displacements: Union[np.ndarray, list, tuple]):
+        self._displacements = np.array(displacements, dtype="double", order="C")
+
+    @property
+    def forces(self) -> np.ndarray:
+        """Setter and getter of supercell forces.
+
+        ndarray
+            shape=(n_snapshot, natom, 3), dtype='double', order='C'
+
+        """
+        return self._forces
+
+    @forces.setter
+    def forces(self, forces: Union[np.ndarray, list, tuple]):
+        self._forces = np.array(forces, dtype="double", order="C")
+
+    def run(self, orders: Sequence[int], is_compact_fc=True) -> Symfc:
+        """Run basis set and force constants calculation."""
+        if (
+            orders is not None
+            and self._displacements is not None
+            and self._forces is not None
+        ):
+            for order in orders:
+                self._compute_basis_set(order)
+            self.solve(orders, is_compact_fc=is_compact_fc)
+        return self
+
+    def solve(self, orders: Sequence[int], is_compact_fc=True) -> Symfc:
+        """Calculate force constants.
+
+        orders : Sequence[int]
+            Sequence of fc orders.
+
+        """
+        self._check_dataset()
+        for order in orders:
+            if order not in (2, 3):
+                raise NotImplementedError("Only order-2 and order-3 are implemented.")
+            if order == 2:
+                basis_set: FCBasisSetO2 = self._basis_set[2]
+                solver_o2 = FCSolverO2(
+                    basis_set,
+                    use_mkl=self._use_mkl,
+                    log_level=self._log_level,
+                ).solve(self._displacements, self._forces)
+                if is_compact_fc:
+                    self._force_constants[2] = solver_o2.compact_fc
+                else:
+                    self._force_constants[2] = solver_o2.full_fc
+            if order == 3:
+                basis_set_o2: FCBasisSetO2 = self._basis_set[2]
+                basis_set_o3: FCBasisSetO3 = self._basis_set[3]
+                solver_o2o3 = FCSolverO2O3(
+                    [basis_set_o2, basis_set_o3],
+                    use_mkl=self._use_mkl,
+                    log_level=self._log_level,
+                ).solve(self._displacements, self._forces)
+                if is_compact_fc:
+                    fc2, fc3 = solver_o2o3.compact_fc
+                else:
+                    fc2, fc3 = solver_o2o3.full_fc
+                self._force_constants[2] = fc2
+                self._force_constants[3] = fc3
+        return self
+
+    def _compute_basis_set(self, order: int):
+        """Set order of force constants."""
+        if order not in (2, 3):
+            raise NotImplementedError("Only fc2 basis set is implemented.")
+
+        if order == 2:
+            basis_set_o2 = FCBasisSetO2(
+                self._supercell, use_mkl=self._use_mkl, log_level=self._log_level
+            ).run()
+            self._basis_set[2] = basis_set_o2
+        if order == 3:
+            basis_set_o3 = FCBasisSetO3(
+                self._supercell, use_mkl=self._use_mkl, log_level=self._log_level
+            ).run()
+            self._basis_set[3] = basis_set_o3
+
+    def _check_dataset(self):
+        if self._displacements is None:
+            raise RuntimeError("Dispalcements not found.")
+        if self._forces is None:
+            raise RuntimeError("Forces not found.")
+        if self._displacements.shape != self._forces.shape:
+            raise RuntimeError("Shape mismatch between dispalcements and forces.")
+        if self._displacements.shape != self._forces.shape:
+            raise RuntimeError("Shape mismatch between dispalcements and forces.")
+        if self._displacements.ndim != 3 or self._displacements.shape[1:] != (
+            len(self._supercell),
+            3,
+        ):
+            raise RuntimeError(
+                "Inconsistent array shape of displacements "
+                f"{self._displacements.shape} with respect to supercell "
+                f"{len(self._supercell)}."
+            )
+        if self._forces.ndim != 3 or self._forces.shape[1:] != (
+            len(self._supercell),
+            3,
+        ):
+            raise RuntimeError(
+                "Inconsistent array shape of forces "
+                f"{self._forces.shape} with respect to supercell "
+                f"{len(self._supercell)}."
+            )

symfc-1.0.0/src/symfc/basis_sets/__init__.py

@@ -0,0 +1,5 @@
+"""Symmetry adapted basis sets of force constants."""
+
+from .basis_sets_base import FCBasisSetBase  # noqa 401
+from .basis_sets_O2 import FCBasisSetO2  # noqa 401
+from .basis_sets_O3 import FCBasisSetO3  # noqa 401

symfc-1.0.0/src/symfc/basis_sets/basis_sets_O1.py

@@ -0,0 +1,140 @@
+"""Symmetry adapted basis sets of 1st order force constants."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+from scipy.sparse import csr_array
+
+from symfc.spg_reps import SpgRepsO1
+from symfc.utils.eig_tools import eigsh_projector
+from symfc.utils.matrix_tools_O1 import compressed_projector_sum_rules
+from symfc.utils.utils import SymfcAtoms
+from symfc.utils.utils_O1 import (
+    get_compr_coset_reps_sum,
+    get_lat_trans_compr_matrix,
+    get_lat_trans_decompr_indices,
+)
+
+from .basis_sets_base import FCBasisSetBase
+
+
+class FCBasisSetO1Base(FCBasisSetBase):
+    """Base class of FCBasisSetO1."""
+
+    def __init__(
+        self,
+        supercell: SymfcAtoms,
+        use_mkl: bool = False,
+        log_level: int = 0,
+    ):
+        """Init method.
+
+        Parameters
+        ----------
+        supercell : SymfcAtoms
+            Supercell.
+        use_mkl : bool
+            Use MKL or not. Default is False.
+        log_level : int, optional
+            Log level. Default is 0.
+
+        """
+        super().__init__(supercell, use_mkl=use_mkl, log_level=log_level)
+        self._spg_reps = SpgRepsO1(supercell)
+
+    def _get_c_trans(self) -> csr_array:
+        trans_perms = self._spg_reps.translation_permutations
+        n_lp, N = trans_perms.shape
+        decompr_idx = get_lat_trans_decompr_indices(trans_perms)
+        c_trans = get_lat_trans_compr_matrix(decompr_idx, N, n_lp)
+        return c_trans
+
+
+class FCBasisSetO1(FCBasisSetO1Base):
+    """Dense symmetry adapted basis set for 1st order force constants.
+
+    Attributes
+    ----------
+    basis_set : ndarray
+        Compressed force constants basis set. The first dimension n_x (< n_a) is
+        given as a result of compression, which is depends on the system.
+        shape=(n_x, n_bases), dtype='double'
+    full_basis_set : ndarray
+        Full (decompressed) force constants basis set. shape=(N * 3,
+        n_bases), dtype='double'
+    translation_permutations : ndarray
+        Atom indices after lattice translations. shape=(lattice_translations,
+        supercell_atoms), dtype=int.
+
+    """
+
+    def __init__(
+        self,
+        supercell: SymfcAtoms,
+        use_mkl: bool = False,
+        log_level: int = 0,
+    ):
+        """Init method.
+
+        Parameters
+        ----------
+        supercell : SymfcAtoms
+            Supercell.
+        log_level : int, optional
+            Log level. Default is 0.
+
+        """
+        super().__init__(supercell, use_mkl=use_mkl, log_level=log_level)
+        self._spg_reps = SpgRepsO1(supercell)
+        self._n_a_compression_matrix: Optional[csr_array] = None
+
+    @property
+    def basis_set(self) -> Optional[np.ndarray]:
+        """Return compressed basis set.
+
+        n_c = len(compressed_indices).
+
+        shape=(n_c, n_bases), dtype='double'.
+
+        """
+        return self._basis_set
+
+    @property
+    def full_basis_set(self) -> Optional[np.ndarray]:
+        """Return full (decompressed) basis set.
+
+        shape=(N*3, n_bases), dtype='double'.
+
+        Data in first dimension is ordered by (N,3).
+
+        """
+        return self._full_basis_set
+
+    @property
+    def compact_compression_matrix(self) -> Optional[np.ndarray]:
+        """Return compression matrix for compact basis set."""
+        pass
+
+    @property
+    def compression_matrix(self) -> Optional[np.ndarray]:
+        """Return compression matrix."""
+        pass
+
+    def run(self) -> FCBasisSetO1:
+        """Compute compressed force constants basis set."""
+        c_trans = self._get_c_trans()
+        coset_reps_sum = get_compr_coset_reps_sum(self._spg_reps)
+        proj_rt = coset_reps_sum
+
+        if len(proj_rt.data) == 0:
+            raise ValueError("No basis vectors exist.")
+
+        c_rt = eigsh_projector(proj_rt)
+        compress_mat = c_trans @ c_rt
+        proj = compressed_projector_sum_rules(compress_mat, self._natom)
+        self._basis_set = eigsh_projector(proj)
+        self._full_basis_set = compress_mat @ self._basis_set
+
+        return self

symfc-1.0.0/src/symfc/basis_sets/basis_sets_O2.py

@@ -0,0 +1,171 @@
+"""Symmetry adapted basis sets of 2nd order force constants."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+from scipy.sparse import csr_array
+
+from symfc.spg_reps import SpgRepsO2
+from symfc.utils.eig_tools import (
+    dot_product_sparse,
+    eigsh_projector,
+    eigsh_projector_sumrule,
+)
+from symfc.utils.matrix_tools_O2 import compressed_projector_sum_rules
+from symfc.utils.utils import SymfcAtoms
+from symfc.utils.utils_O2 import (
+    get_compr_coset_reps_sum,
+    get_lat_trans_compr_matrix,
+    get_lat_trans_decompr_indices,
+    get_perm_compr_matrix,
+)
+
+from .basis_sets_base import FCBasisSetBase
+
+
+class FCBasisSetO2(FCBasisSetBase):
+    """Dense symmetry adapted basis set for 2nd order force constants.
+
+    Attributes
+    ----------
+    basis_set : ndarray
+        Compressed force constants basis set. The first dimension n_x (< n_a) is
+        given as a result of compression, which is depends on the system.
+        shape=(n_x * N * 9, n_bases), dtype='double'
+    full_basis_set : ndarray
+        Full (decompressed) force constants basis set. shape=(N * N * 9,
+        n_bases), dtype='double'
+    translation_permutations : ndarray
+        Atom indices after lattice translations. shape=(lattice_translations,
+        supercell_atoms), dtype=int.
+
+    """
+
+    def __init__(
+        self,
+        supercell: SymfcAtoms,
+        use_mkl: bool = False,
+        log_level: int = 0,
+    ):
+        """Init method.
+
+        Parameters
+        ----------
+        supercell : SymfcAtoms
+            Supercell.
+        use_mkl : bool
+            Use MKL or not. Default is False.
+        log_level : int, optional
+            Log level. Default is 0.
+
+        """
+        super().__init__(supercell, use_mkl=use_mkl, log_level=log_level)
+        self._spg_reps = SpgRepsO2(supercell)
+        self._n_a_compression_matrix: Optional[csr_array] = None
+
+    @property
+    def basis_set(self) -> Optional[np.ndarray]:
+        """Return compressed basis set.
+
+        n_c = len(compressed_indices).
+
+        shape=(n_c*N*3*3, n_bases), dtype='double'.
+
+        Data in first dimension is ordered by (n_c,N,3,3).
+
+        """
+        return self._basis_set
+
+    @property
+    def compression_matrix(self) -> Optional[csr_array]:
+        """Return compression matrix.
+
+        This expands fc basis_sets to (N*N*3*3, n_bases).
+
+        """
+        c_trans = self._get_c_trans()
+        return dot_product_sparse(
+            c_trans, self._n_a_compression_matrix, use_mkl=self._use_mkl
+        )
+
+    @property
+    def compact_compression_matrix(self) -> Optional[csr_array]:
+        """Return compact compression matrix.
+
+        This expands basis_sets to (n_a*N*3*3, n_bases).
+
+        """
+        n_lp = self.translation_permutations.shape[0]
+        return self._n_a_compression_matrix / np.sqrt(n_lp)
+
+    @property
+    def decompression_indices(self) -> np.ndarray:
+        """Return decompression indices in (N,N,3,3) order."""
+        trans_perms = self.translation_permutations
+        return get_lat_trans_decompr_indices(trans_perms)
+
+    def run(self) -> FCBasisSetO2:
+        """Compute compressed force constants basis set.
+
+        compression using C(pt)
+            = eigvecs of C(trans).T @ C(perm) @ C(perm).T @ C(trans)
+        proj_rpt = c_pt.transpose() @ coset_reps_sum @ c_pt
+
+        [C_pt @ C_trans.T] @ P_sum @ [C_trans @ C_pt] @ C_rpt
+         = C_rpt @ [C_rpt.T @ C_pt @ C_trans.T] @ P_sum @ [C_trans @ C_pt @ C_rpt]
+         = C_rpt @ compression_mat.T @ (I - P_sum^(c)) @ compression_mat
+         = C_rpt @ compression_mat.T @ (I - Csum(c) @ Csum(c).T) @ compression_mat
+         = C_rpt @ proj
+
+        compress_mat = c_trans @ c_pt @ c_rpt
+
+        """
+        N = self._natom
+        c_trans = self._get_c_trans()
+        n_a_compress_mat = self._get_n_a_compress_mat(c_trans)
+        compress_mat = dot_product_sparse(
+            c_trans, n_a_compress_mat, use_mkl=self._use_mkl
+        )
+        proj = compressed_projector_sum_rules(compress_mat, N, use_mkl=self._use_mkl)
+        eigvecs = eigsh_projector_sumrule(proj)
+
+        if self._log_level:
+            print(f"Final size of basis set: {eigvecs.shape}")
+
+        self._basis_set = eigvecs
+        self._n_a_compression_matrix = n_a_compress_mat
+        return self
+
+    def _get_n_a_compress_mat(self, c_trans: csr_array) -> csr_array:
+        """Return compression matrix without c_trans mutiplied.
+
+        This compression matrix is preserved as a class instance variable.
+        The full compression matrix is obtained by
+
+        c_trans @ n_a_compression_matrix.
+
+        The compact compression matrix is obtained by
+
+        n_a_compression_matrix / sqrt(n_lp).
+
+        """
+        N = self._natom
+        c_perm = get_perm_compr_matrix(N)
+        c_pt = dot_product_sparse(c_perm.T, c_trans, use_mkl=self._use_mkl)
+        proj_pt = dot_product_sparse(c_pt.T, c_pt, use_mkl=self._use_mkl)
+        coset_reps_sum = get_compr_coset_reps_sum(self._spg_reps)
+        c_pt = eigsh_projector(proj_pt)
+        proj_rpt = dot_product_sparse(coset_reps_sum, c_pt, use_mkl=self._use_mkl)
+        proj_rpt = dot_product_sparse(c_pt.T, proj_rpt)
+        c_rpt = eigsh_projector(proj_rpt)
+        n_a_compress_mat = dot_product_sparse(c_pt, c_rpt, use_mkl=self._use_mkl)
+        return n_a_compress_mat
+
+    def _get_c_trans(self) -> csr_array:
+        trans_perms = self._spg_reps.translation_permutations
+        n_lp, N = trans_perms.shape
+        decompr_idx = get_lat_trans_decompr_indices(trans_perms)
+        c_trans = get_lat_trans_compr_matrix(decompr_idx, N, n_lp)
+        return c_trans