symfc 1.3.0__tar.gz → 1.3.2__tar.gz

{symfc-1.3.0/src/symfc.egg-info → symfc-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: symfc
-Version: 1.3.0
+Version: 1.3.2
 Summary: This is the symfc module.
 Author-email: Atsuto Seko <seko@cms.mtl.kyoto-u.ac.jp>
 Maintainer-email: Atsushi Togo <atztogo@gmail.com>

{symfc-1.3.0 → symfc-1.3.2}/src/symfc/api_symfc.py

@@ -286,6 +286,7 @@ class Symfc:
                 basis_set_o2 = FCBasisSetO2(
                     self._supercell,
                     spacegroup_operations=self._spacegroup_operations,
+                    cutoff=self._cutoff[2],
                     use_mkl=self._use_mkl,
                     log_level=self._log_level,
                 ).run()
@@ -341,6 +342,7 @@ class Symfc:
                 basis_size_estimates[order] = FCBasisSetO2(
                     self._supercell,
                     spacegroup_operations=self._spacegroup_operations,
+                    cutoff=self._cutoff[2],
                     use_mkl=self._use_mkl,
                     log_level=self._log_level,
                 ).estimate_basis_size()
@@ -409,9 +411,9 @@ class Symfc:
 
     def _prepare_cutoff(self, cutoff):
         if cutoff is None:
-            self._cutoff = {3: None, 4: None}
+            self._cutoff = {2: None, 3: None, 4: None}
         else:
             self._cutoff = cutoff
-            for order in (3, 4):
+            for order in (2, 3, 4):
                 if order not in self._cutoff:
                     self._cutoff[order] = None

{symfc-1.3.0 → symfc-1.3.2}/src/symfc/solvers/solver_O2O3.py

@@ -308,6 +308,7 @@ def prepare_normal_equation_O2O3(
             if verbose:
                 print("Solver_block:", end, "/", disps.shape[0], flush=True)
                 print(" - Time:", "{:.3f}".format(t2 - t1), flush=True)
+            del X3
 
     if verbose:
         print("Solver:", "Calculate X.T @ X and X.T @ y", flush=True)

{symfc-1.3.0 → symfc-1.3.2}/src/symfc/utils/eig_tools.py

@@ -7,7 +7,7 @@ from typing import Optional
 import numpy as np
 import scipy
 from scipy.linalg import get_lapack_funcs
-from scipy.sparse import csr_array, hstack, lil_array
+from scipy.sparse import csr_array
 
 from symfc.utils.solver_funcs import get_batch_slice
 
@@ -385,243 +385,3 @@ def eigsh_projector_sumrule_large(p: csr_array, verbose: bool = True) -> np.ndar
                 eigvecs_full[ids, col_id:col_end] = eigvecs
                 col_id = col_end
     return eigvecs_full[:, :col_id]
-
-
-def _find_smaller_block(p1: np.ndarray, target_size: int = 3000, random: bool = True):
-    """Find a reasonable block in matrix p1."""
-    if random:
-        # algorithm 2 (random choice)
-        total_size = p1.shape[0]
-        ids = np.random.choice(
-            range(total_size),
-            min(target_size, total_size),
-            replace=False,
-        )
-        bools = np.zeros(p1.shape[0], dtype=bool)
-        bools[ids] = True
-        return bools
-
-    # algorithm 1
-    n_data = np.count_nonzero(np.abs(p1) > 1e-15, axis=1)
-    rep_id = np.abs(n_data - target_size).argmin()
-    return np.abs(p1[rep_id]) > 1e-15
-
-
-def _iterative_eigsh_projector(
-    p_block: np.ndarray,
-    max_iter: int = 50,
-    size_terminate: int = 2000,
-    use_mkl: bool = False,
-    verbose: bool = False,
-    use_sparse: bool = True,
-):
-    if use_sparse:
-        return _iterative_eigsh_projector_use_sparse(
-            p_block=p_block,
-            max_iter=max_iter,
-            size_terminate=size_terminate,
-            use_mkl=use_mkl,
-            verbose=verbose,
-        )
-    return _iterative_eigsh_projector_use_dense(
-        p_block=p_block,
-        max_iter=max_iter,
-        size_terminate=size_terminate,
-        verbose=verbose,
-    )
-
-
-def _iterative_eigsh_projector_use_dense(
-    p_block: np.ndarray,
-    max_iter: int = 50,
-    size_terminate: int = 2000,
-    verbose: bool = False,
-):
-    """Solve eigenvalue problem partially for matrix p."""
-    if verbose:
-        print(" - Use iterative projector solver.", flush=True)
-
-    if p_block.shape[0] < size_terminate:
-        return None, p_block, None
-
-    eigvecs_block = np.zeros(p_block.shape, dtype="double")
-    compr = None
-    col_id = 0
-
-    for j in range(max_iter):
-        if verbose:
-            print(" * iteration:", j + 1, flush=True)
-        if p_block.shape[0] < size_terminate:
-            if verbose:
-                print(" iteration stopped. p.shape <", size_terminate, flush=True)
-            break
-
-        bool_small = _find_smaller_block(p_block, target_size=3000)
-        bool_const = np.logical_not(bool_small)
-        n_const = np.count_nonzero(bool_const)
-        if verbose:
-            print(
-                "   - Solving projector of size",
-                np.count_nonzero(bool_small),
-                flush=True,
-            )
-
-        if np.count_nonzero(bool_small) / p_block.shape[0] > 0.95:
-            if verbose:
-                print(" iteration stopped (> 0.95).", flush=True)
-            break
-
-        p_small = p_block[np.ix_(bool_small, bool_small)]
-        rank = int(round(np.trace(p_small)))
-        if rank == 0:
-            break
-
-        eigvecs, (cmplt_eigvals, cmplt_small) = eigh_projector(
-            p_small,
-            return_complement=True,
-            verbose=verbose,
-        )
-        if eigvecs.shape[1] == 0:
-            if verbose:
-                print(" No eigenvectors are found.", flush=True)
-            break
-
-        compr_size = n_const + cmplt_small.shape[1]
-        if verbose:
-            print("   - Compressing matrix:", flush=True)
-            print("  ", p_block.shape[0], "->", compr_size, flush=True)
-
-        col_end = col_id + eigvecs.shape[1]
-        if j == 0:
-            compr = np.zeros((p_block.shape[0], compr_size))
-            row_ids = np.where(bool_const)[0]
-            compr[(row_ids, np.arange(n_const))] = 1.0
-
-            row_ids = np.where(bool_small)[0]
-            compr[row_ids, n_const:] = cmplt_small
-            eigvecs_block[row_ids, col_id:col_end] = eigvecs
-        else:
-            compr_slice = compr[:, bool_small]
-            prod = compr_slice @ cmplt_small
-            eigvecs_block[:, col_id:col_end] = compr_slice @ eigvecs
-            """Time consuming part."""
-            compr = np.hstack([compr[:, bool_const], prod])
-        col_id = col_end
-
-        """
-        cmplt_small.T @ p_small @ cmplt_small
-        = (cmplt_small.T @ cmplt_small
-           @ np.diag(cmplt_eigvals) @ cmplt_small.T @ cmplt_small)
-        = np.diag(cmplt_eigvals)
-        """
-        mat12 = p_block[np.ix_(bool_const, bool_small)] @ cmplt_small
-        p_block = np.block(
-            [
-                [p_block[np.ix_(bool_const, bool_const)], mat12],
-                [mat12.T, np.diag(cmplt_eigvals)],
-            ]
-        )
-
-    if col_id == 0:
-        return None, p_block, None
-    return eigvecs_block[:, :col_id], p_block, compr
-
-
-def _iterative_eigsh_projector_use_sparse(
-    p_block: np.ndarray,
-    max_iter: int = 50,
-    size_terminate: int = 2000,
-    use_mkl: bool = False,
-    verbose: bool = True,
-):
-    """Solve eigenvalue problem partially for matrix p."""
-    if p_block.shape[0] < size_terminate:
-        return None, p_block, None
-
-    if verbose:
-        print(" - Use iterative projector solver.", flush=True)
-
-    eigvecs_block = np.zeros(p_block.shape, dtype="double")
-    compr = None
-    col_id = 0
-
-    for j in range(max_iter):
-        if verbose:
-            print(" * iteration:", j + 1, flush=True)
-        if p_block.shape[0] < size_terminate:
-            if verbose:
-                print(" iteration stopped. p.shape <", size_terminate, flush=True)
-            break
-
-        bool_small = _find_smaller_block(p_block, target_size=3000)
-        bool_const = np.logical_not(bool_small)
-        n_const = np.count_nonzero(bool_const)
-        if verbose:
-            print(
-                "   - Solving projector of size",
-                np.count_nonzero(bool_small),
-                flush=True,
-            )
-
-        if np.count_nonzero(bool_small) / p_block.shape[0] > 0.95:
-            if verbose:
-                print(" iteration stopped (> 0.95).", flush=True)
-            break
-
-        p_small = p_block[np.ix_(bool_small, bool_small)]
-        rank = int(round(np.trace(p_small)))
-        if rank == 0:
-            break
-
-        eigvecs, (cmplt_eigvals, cmplt_small) = eigh_projector(
-            p_small,
-            return_complement=True,
-            verbose=verbose,
-        )
-        cmplt_small_sp = csr_array(cmplt_small)
-        if eigvecs.shape[1] == 0:
-            if verbose:
-                print(" No eigenvectors are found.", flush=True)
-            break
-
-        compr_size = n_const + cmplt_small.shape[1]
-        if verbose:
-            print("   - Compressing matrix:", flush=True)
-            print("  ", p_block.shape[0], "->", compr_size, flush=True)
-
-        col_end = col_id + eigvecs.shape[1]
-        if j == 0:
-            compr1 = csr_array(
-                (np.ones(n_const), (np.where(bool_const)[0], np.arange(n_const))),
-                shape=(p_block.shape[0], n_const),
-                dtype="double",
-            )
-            compr2 = lil_array((p_block.shape[0], cmplt_small.shape[1]), dtype="double")
-            row_ids = np.where(bool_small)[0]
-            compr2[row_ids] = cmplt_small_sp.tolil()
-            compr = hstack([compr1, compr2.tocsr()])
-            eigvecs_block[row_ids, col_id:col_end] = eigvecs
-        else:
-            compr_slice = compr[:, bool_small]
-            prod = dot_product_sparse(compr_slice, cmplt_small_sp, use_mkl=use_mkl)
-            compr = hstack([compr[:, bool_const], prod])
-            eigvecs_block[:, col_id:col_end] = compr_slice.toarray() @ eigvecs
-        col_id = col_end
-
-        """
-        cmplt_small.T @ p_small @ cmplt_small
-        = (cmplt_small.T @ cmplt_small
-           @ np.diag(cmplt_eigvals) @ cmplt_small.T @ cmplt_small)
-        = np.diag(cmplt_eigvals)
-        """
-        mat12 = p_block[np.ix_(bool_const, bool_small)] @ cmplt_small
-        p_block = np.block(
-            [
-                [p_block[np.ix_(bool_const, bool_const)], mat12],
-                [mat12.T, np.diag(cmplt_eigvals)],
-            ]
-        )
-
-    if col_id == 0:
-        return None, p_block, None
-    return eigvecs_block[:, :col_id], p_block, compr.toarray()

{symfc-1.3.0 → symfc-1.3.2}/src/symfc/utils/matrix_tools_O2.py

@@ -95,7 +95,15 @@ def projector_permutation_lat_trans_O2(
     return proj_pt
 
 
-def compressed_projector_sum_rules_O2(
+def optimize_batch_size_sum_rules_O2(natom: int, n_batch: Optional[int] = None):
+    """Calculate batch size for constructing projector for sum rules."""
+    if n_batch > natom:
+        raise ValueError("n_batch must be smaller than N.")
+    batch_size = natom * (natom // n_batch)
+    return batch_size
+
+
+def compressed_projector_sum_rules_O2_index_atoms(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -123,23 +131,20 @@ def compressed_projector_sum_rules_O2(
     proj_size = n_a_compress_mat.shape[1]
     proj_cplmt = csr_array((proj_size, proj_size), dtype="double")
 
-    if n_batch > natom:
-        raise ValueError("n_batch must be smaller than N.")
-    batch_size = natom * (natom // n_batch)
-
     if atomic_decompr_idx is None:
         atomic_decompr_idx = _get_atomic_lat_trans_decompr_indices(trans_perms)
 
     decompr_idx = atomic_decompr_idx.reshape((natom, natom)).T.reshape(-1) * 9
-    nonzero = np.zeros((natom, natom), dtype=bool)
-    indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
-    nonzero[indep_atoms, :] = True
-    nonzero = nonzero.reshape(-1)
-    if fc_cutoff is not None:
-        nonzero_cutoff = fc_cutoff.nonzero_atomic_indices_fc2()
-        nonzero_cutoff = nonzero_cutoff.reshape((natom, natom)).T.reshape(-1)
-        nonzero = nonzero & nonzero_cutoff
+    if fc_cutoff is None:
+        indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
+        nonzero = np.zeros((natom, natom), dtype=bool)
+        nonzero[indep_atoms, :] = True
+        nonzero = nonzero.reshape(-1)
+    else:
+        nonzero = fc_cutoff.nonzero_atomic_indices_fc2()
+        nonzero = nonzero.reshape((natom, natom)).T.reshape(-1)
 
+    batch_size = optimize_batch_size_sum_rules_O2(natom, n_batch=n_batch)
     ab = np.arange(9)
     for begin, end in zip(*get_batch_slice(NN, batch_size)):
         size = end - begin
@@ -148,31 +153,29 @@ def compressed_projector_sum_rules_O2(
 
         nonzero_b = nonzero[begin:end]
         size_data = np.count_nonzero(nonzero_b) * 9
-        if size_data > 0:
-            decompr_idx_b = decompr_idx[begin:end]
-            c_sum_cplmt = csr_array(
+        if size_data == 0:
+            continue
+
+        decompr_idx_b = decompr_idx[begin:end][nonzero_b]
+        c_sum_cplmt = csr_array(
+            (
+                np.ones(size_data, dtype="double"),
                 (
-                    np.ones(size_data, dtype="double"),
-                    (
-                        np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 9)],
-                        (decompr_idx_b[nonzero_b][None, :] + ab[:, None]).reshape(-1),
-                    ),
+                    np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 9)],
+                    (ab[:, None] + decompr_idx_b[None, :]).reshape(-1),
                 ),
-                shape=(size_row, NN9 // n_lp),
-                dtype="double",
-            )
-            c_sum_cplmt = dot_product_sparse(
-                c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl
-            )
-            proj_cplmt += dot_product_sparse(
-                c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl
-            )
+            ),
+            shape=(size_row, NN9 // n_lp),
+            dtype="double",
+        )
+        c_sum_cplmt = dot_product_sparse(c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl)
+        proj_cplmt += dot_product_sparse(c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl)
 
     proj_cplmt /= n_lp * natom
     return scipy.sparse.identity(proj_cplmt.shape[0]) - proj_cplmt
 
 
-def compressed_projector_sum_rules_O2_stable(
+def compressed_projector_sum_rules_O2(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -200,10 +203,6 @@ def compressed_projector_sum_rules_O2_stable(
     proj_size = n_a_compress_mat.shape[1]
     proj_cplmt = csr_array((proj_size, proj_size), dtype="double")
 
-    if n_batch > natom:
-        raise ValueError("n_batch must be smaller than N.")
-    batch_size = natom * (natom // n_batch)
-
     if atomic_decompr_idx is None:
         atomic_decompr_idx = _get_atomic_lat_trans_decompr_indices(trans_perms)
 
@@ -212,6 +211,7 @@ def compressed_projector_sum_rules_O2_stable(
         nonzero = fc_cutoff.nonzero_atomic_indices_fc2()
         nonzero = nonzero.reshape((natom, natom)).T.reshape(-1)
 
+    batch_size = optimize_batch_size_sum_rules_O2(natom, n_batch=n_batch)
     ab = np.arange(9)
     for begin, end in zip(*get_batch_slice(NN, batch_size)):
         size = end - begin
@@ -224,7 +224,7 @@ def compressed_projector_sum_rules_O2_stable(
                     np.ones(size_vector, dtype="double"),
                     (
                         np.repeat(np.arange(size_row), natom),
-                        (decompr_idx[begin:end][None, :] + ab[:, None]).reshape(-1),
+                        (ab[:, None] + decompr_idx[begin:end][None, :]).reshape(-1),
                     ),
                 ),
                 shape=(size_row, NN9 // n_lp),
@@ -232,15 +232,14 @@ def compressed_projector_sum_rules_O2_stable(
             )
         else:
             nonzero_b = nonzero[begin:end]
+            decompr_idx_b = decompr_idx[begin:end][nonzero_b]
             size_data = np.count_nonzero(nonzero_b) * 9
             c_sum_cplmt = csr_array(
                 (
                     np.ones(size_data, dtype="double"),
                     (
                         np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 9)],
-                        (
-                            decompr_idx[begin:end][nonzero_b][None, :] + ab[:, None]
-                        ).reshape(-1),
+                        (ab[:, None] + decompr_idx_b[None, :]).reshape(-1),
                     ),
                 ),
                 shape=(size_row, NN9 // n_lp),

{symfc-1.3.0 → symfc-1.3.2}/src/symfc/utils/matrix_tools_O3.py

@@ -294,7 +294,21 @@ def projector_permutation_lat_trans_O3(
     return proj_pt
 
 
-def compressed_projector_sum_rules_O3(
+def optimize_batch_size_sum_rules_O3(natom: int, n_batch: Optional[int] = None):
+    """Calculate batch size for constructing projector for sum rules."""
+    if n_batch is None:
+        if natom < 256:
+            n_batch = natom // min(natom, 16)
+        else:
+            n_batch = natom // 4
+
+    if n_batch > natom:
+        raise ValueError("n_batch must be smaller than N.")
+    batch_size = natom**2 * (natom // n_batch)
+    return batch_size
+
+
+def compressed_projector_sum_rules_O3_indep_atoms(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -324,31 +338,21 @@ def compressed_projector_sum_rules_O3(
     proj_size = n_a_compress_mat.shape[1]
     proj_cplmt = csr_array((proj_size, proj_size), dtype="double")
 
-    if n_batch is None:
-        if natom < 256:
-            n_batch = natom // min(natom, 64)
-        else:
-            n_batch = natom // 4
-
-    if n_batch > natom:
-        raise ValueError("n_batch must be smaller than N.")
-    batch_size = natom**2 * (natom // n_batch)
-
     if atomic_decompr_idx is None:
         atomic_decompr_idx = get_atomic_lat_trans_decompr_indices_O3(trans_perms)
 
-    """Bottleneck part when using cutoff distance"""
     decompr_idx = atomic_decompr_idx.reshape((natom, NN)).T.reshape(-1) * 27
 
-    indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
-    nonzero = np.zeros((natom, natom, natom), dtype=bool)
-    nonzero[indep_atoms, :, :] = True
-    nonzero = nonzero.reshape(-1)
-    if fc_cutoff is not None:
-        nonzero_cutoff = fc_cutoff.nonzero_atomic_indices_fc3()
-        nonzero_cutoff = nonzero_cutoff.reshape((natom, NN)).T.reshape(-1)
-        nonzero = nonzero & nonzero_cutoff
+    if fc_cutoff is None:
+        indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
+        nonzero = np.zeros((natom, natom, natom), dtype=bool)
+        nonzero[indep_atoms, :, :] = True
+        nonzero = nonzero.reshape(-1)
+    else:
+        nonzero = fc_cutoff.nonzero_atomic_indices_fc3()
+        nonzero = nonzero.reshape((natom, NN)).T.reshape(-1)
 
+    batch_size = optimize_batch_size_sum_rules_O3(natom, n_batch=n_batch)
     abc = np.arange(27)
     for begin, end in zip(*get_batch_slice(NNN, batch_size)):
         size = end - begin
@@ -357,39 +361,31 @@ def compressed_projector_sum_rules_O3(
 
         nonzero_b = nonzero[begin:end]
         size_data = np.count_nonzero(nonzero_b) * 27
+        if size_data == 0:
+            continue
+
         if verbose:
-            print(
-                "Complementary P (Sum rule):",
-                str(end) + "/" + str(NNN) + ",",
-                "Non-zero:",
-                size_data,
-                flush=True,
-            )
-        if size_data > 0:
-            decompr_idx_b = decompr_idx[begin:end]
-            c_sum_cplmt = csr_array(
+            print("Complementary P (Sum rule):", str(end) + "/" + str(NNN), flush=True)
+        decompr_idx_b = decompr_idx[begin:end][nonzero_b]
+        c_sum_cplmt = csr_array(
+            (
+                np.ones(size_data, dtype="double"),
                 (
-                    np.ones(size_data, dtype="double"),
-                    (
-                        np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 27)],
-                        (decompr_idx_b[nonzero_b][None, :] + abc[:, None]).reshape(-1),
-                    ),
+                    np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 27)],
+                    (abc[:, None] + decompr_idx_b[None, :]).reshape(-1),
                 ),
-                shape=(size_row, NNN27 // n_lp),
-                dtype="double",
-            )
-            c_sum_cplmt = dot_product_sparse(
-                c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl
-            )
-            proj_cplmt += dot_product_sparse(
-                c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl
-            )
+            ),
+            shape=(size_row, NNN27 // n_lp),
+            dtype="double",
+        )
+        c_sum_cplmt = dot_product_sparse(c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl)
+        proj_cplmt += dot_product_sparse(c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl)
 
     proj_cplmt /= n_lp * natom
     return scipy.sparse.identity(proj_cplmt.shape[0]) - proj_cplmt
 
 
-def compressed_projector_sum_rules_O3_stable(
+def compressed_projector_sum_rules_O3(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -419,16 +415,6 @@ def compressed_projector_sum_rules_O3_stable(
     proj_size = n_a_compress_mat.shape[1]
     proj_cplmt = csr_array((proj_size, proj_size), dtype="double")
 
-    if n_batch is None:
-        if natom < 256:
-            n_batch = natom // min(natom, 16)
-        else:
-            n_batch = natom // 4
-
-    if n_batch > natom:
-        raise ValueError("n_batch must be smaller than N.")
-    batch_size = natom**2 * (natom // n_batch)
-
     if atomic_decompr_idx is None:
         atomic_decompr_idx = get_atomic_lat_trans_decompr_indices_O3(trans_perms)
 
@@ -437,6 +423,7 @@ def compressed_projector_sum_rules_O3_stable(
         nonzero = fc_cutoff.nonzero_atomic_indices_fc3()
         nonzero = nonzero.reshape((natom, NN)).T.reshape(-1)
 
+    batch_size = optimize_batch_size_sum_rules_O3(natom, n_batch=n_batch)
     abc = np.arange(27)
     for begin, end in zip(*get_batch_slice(NNN, batch_size)):
         if verbose:
@@ -451,7 +438,7 @@ def compressed_projector_sum_rules_O3_stable(
                     np.ones(size_vector, dtype="double"),
                     (
                         np.repeat(np.arange(size_row), natom),
-                        (decompr_idx[begin:end][None, :] + abc[:, None]).reshape(-1),
+                        (abc[:, None] + decompr_idx[begin:end][None, :]).reshape(-1),
                     ),
                 ),
                 shape=(size_row, NNN27 // n_lp),
@@ -459,15 +446,14 @@ def compressed_projector_sum_rules_O3_stable(
             )
         else:
             nonzero_b = nonzero[begin:end]
+            decompr_idx_b = decompr_idx[begin:end][nonzero_b]
             size_data = np.count_nonzero(nonzero_b) * 27
             c_sum_cplmt = csr_array(
                 (
                     np.ones(size_data, dtype="double"),
                     (
                         np.repeat(np.arange(size_row), natom)[np.tile(nonzero_b, 27)],
-                        (
-                            decompr_idx[begin:end][nonzero_b][None, :] + abc[:, None]
-                        ).reshape(-1),
+                        (abc[:, None] + decompr_idx_b[None, :]).reshape(-1),
                     ),
                 ),
                 shape=(size_row, NNN27 // n_lp),