symfc 1.0.0__py3-none-any.whl

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/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/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/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/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