AOT-biomaps 2.9.261__py3-none-any.whl → 2.9.318__py3-none-any.whl

AOT_biomaps/AOT_Experiment/Tomography.py

@@ -287,6 +287,56 @@ class Tomography(Experiment):
         if not self._check_patterns(self.patterns):
             raise ValueError("Generated patterns failed validation.")
 
+    def selectAngles(self, angles):
+
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        newAcousticFields = []
+        index = []
+        for i,field in enumerate(self.AcousticFields):
+            if field.angle in angles:
+                newAcousticFields.append(field)
+                index.append(i)
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, index]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
+        self.AcousticFields = newAcousticFields
+
+    def selectPatterns(self, pattern_names):
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        newAcousticFields = []
+        index = []
+        for i,field in enumerate(self.AcousticFields):
+            if field.pattern.activeList in pattern_names:
+                newAcousticFields.append(field)
+                index.append(i)
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, index]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
+        self.AcousticFields = newAcousticFields
+
+    def selectRandom(self,N):
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        if N > len(self.AcousticFields):
+            raise ValueError("N is larger than the number of available AcousticFields.")
+        indices = np.random.choice(len(self.AcousticFields), size=N, replace=False)
+        newAcousticFields = [self.AcousticFields[i] for i in indices]
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, indices]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, indices]
+        self.AcousticFields = newAcousticFields
+
     def _generate_patterns(self, N):
         def format_angle(a):
             return f"{'1' if a < 0 else '0'}{abs(a):02d}"
@@ -390,6 +440,80 @@ class Tomography(Experiment):
 
         return True
 
+    def applyApodisation(self, alpha=0.3, divergence_deg=0.5):
+        """
+        Applique une apodisation dynamique sur les champs acoustiques stockés dans l'objet.
+        L'apodisation suit l'angle d'émission et la divergence naturelle du faisceau pour
+        supprimer les lobes de diffraction (artefacts de bord) sans toucher au signal utile.
+        Args:
+            probe_width (float): Largeur physique active de la sonde (ex: 40e-3 pour 40mm).
+            alpha (float): Paramètre de Tukey (0.0=rectangle, 1.0=hann). 0.3 est un bon compromis.
+            divergence_deg (float): Angle d'ouverture du masque pour suivre l'élargissement du faisceau.
+                                    0.0 = Droit, 0.5 = Légère ouverture (conseillé).
+        """
+        print(f"Application de l'apodisation (Alpha={alpha}, Div={divergence_deg}°) sur {len(self.AcousticFields)} champs...")
+        
+        probe_width = self.params.acoustic['num_elements'] * self.params.acoustic['element_width']
+
+        for i in trange(len(self.AcousticFields), desc="Apodisation"):
+            # 1. Récupération des données et de l'angle
+            field = self.AcousticFields[i].field  # Peut être (Z, X) ou (Time, Z, X)
+            angle = self.AcousticFields[i].angle  # L'angle de l'onde plane
+
+            # 2. Récupération ou construction des axes physiques
+            nz, nx = field.shape[-2:]
+
+            if hasattr(self, 'x_axis') and self.x_axis is not None:
+                x_axis = self.x_axis
+            else:
+                # Génération par défaut centrée sur 0 (ex: -20mm à +20mm)
+                x_axis = np.linspace(-probe_width/2, probe_width/2, nx)
+
+            if hasattr(self, 'z_axis') and self.z_axis is not None:
+                z_axis = self.z_axis
+            else:
+                # Génération par défaut (ex: 0 à 40mm, basé sur un pitch standard ou arbitraire)
+                estimated_depth = 40e-3  # Valeur arbitraire si inconnue
+                z_axis = np.linspace(0, estimated_depth, nz)
+
+            # 3. Préparation des grilles pour le masque
+            Z, X = np.meshgrid(z_axis, x_axis, indexing='ij')
+
+            # 4. Calcul de la géométrie orientée (Steering)
+            angle_rad = np.deg2rad(angle)
+            X_aligned = X - Z * np.tan(angle_rad)
+
+            # 5. Calcul de la largeur dynamique du masque (Divergence)
+            div_rad = np.deg2rad(divergence_deg)
+            current_half_width = (probe_width / 2.0) + Z * np.tan(div_rad)
+
+            # 6. Normalisation et création du masque Tukey
+            X_norm = np.divide(X_aligned, current_half_width, out=np.zeros_like(X_aligned), where=current_half_width!=0)
+
+            mask = np.zeros_like(X_norm)
+            plateau_threshold = 1.0 * (1 - alpha)
+
+            # Zone centrale (plateau = 1)
+            mask[np.abs(X_norm) <= plateau_threshold] = 1.0
+
+            # Zone de transition (cosinus)
+            transition_indices = (np.abs(X_norm) > plateau_threshold) & (np.abs(X_norm) <= 1.0)
+            if np.any(transition_indices):
+                x_trans = np.abs(X_norm[transition_indices]) - plateau_threshold
+                width_trans = 1.0 * alpha
+                mask[transition_indices] = 0.5 * (1 + np.cos(np.pi * x_trans / width_trans))
+
+            # 7. Application du masque (Gestion 2D vs 3D)
+            if field.ndim == 3:
+                field_apodized = field * mask[np.newaxis, :, :]
+            else:
+                field_apodized = field * mask
+
+            # 8. Mise à jour de l'objet
+            self.AcousticFields[i].field = field_apodized
+
+        print("Apodisation terminée.")
+
     # PRIVATE METHODS
     def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False, nameBlock=None):
         if self.patterns is None:

AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py

@@ -1,34 +1,57 @@
 from AOT_biomaps.Config import config
+from AOT_biomaps.AOT_Recon.ReconTools import calculate_memory_requirement, check_gpu_memory
+from AOT_biomaps.AOT_Recon.ReconEnums import SMatrixType
+
 import torch
 import numpy as np
 from tqdm import trange
-from AOT_biomaps.AOT_Recon.ReconTools import calculate_memory_requirement, check_gpu_memory
+import pycuda.driver as drv
+import torch.cuda 
+import gc 
+
+
 
 def LS(
     SMatrix,
     y,
-    numIterations=5000,
-    alpha=1e-3,
+    numIterations=100,
     isSavingEachIteration=True,
     withTumor=True,
+    alpha=1e-1,
     device=None,
+    use_numba=False,
+    denominator_threshold=1e-6,
     max_saves=5000,
-    show_logs=True
+    show_logs=True,
+    smatrixType=SMatrixType.SELL
 ):
     """
     Least Squares reconstruction using Projected Gradient Descent (PGD) with non-negativity constraint.
     Currently only implements the stable GPU version.
     """
     tumor_str = "WITH" if withTumor else "WITHOUT"
-    # Force GPU usage for now
+    # Auto-select device and method
     if device is None:
         if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
-            raise RuntimeError("CUDA is required for this implementation.")
-        device = torch.device(f"cuda:{config.select_best_gpu()}")
+            device = torch.device(f"cuda:{config.select_best_gpu()}")
+            use_gpu = True
+        else:
+            device = torch.device("cpu")
+            use_gpu = False
+    else:
+        use_gpu = device.type == "cuda"
+    # Dispatch to the appropriate implementation
+    if use_gpu:
+            if smatrixType == SMatrixType.CSR:
+                return _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs)
+            elif smatrixType == SMatrixType.SELL:
+                return _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs)
+            elif smatrixType == SMatrixType.DENSE:
+                return _LS_GPU_stable(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold,show_logs)
+            else:
+                raise ValueError("Unsupported SMatrixType for GPU LS.")
     else:
-        if device.type != "cuda":
-            raise RuntimeError("Only GPU implementation is available for now.")
-    return _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves, show_logs=show_logs)
+        raise NotImplementedError("Only GPU implementations are currently available for LS.")
 
 def _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves=5000, show_logs=True):
     """
@@ -104,3 +127,370 @@ def _LS_CPU_opti(*args, **kwargs):
 
 def _LS_CPU_basic(*args, **kwargs):
     raise NotImplementedError("Only _LS_GPU_stable is implemented for now.")
+
+def _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs=True):
+    """
+    Reconstruction par Moindres Carrés (LS) via Gradient Conjugué (CG) sur format CSR.
+    Utilise les mêmes arguments que la fonction MLEM, sans sous-fonctions Python.
+    
+    SMatrix: instance de SparseSMatrix_CSR (déjà allouée)
+    y: données mesurées (1D np.float32 de taille TN)
+    """
+    final_result = None
+    
+    # Paramètres non utilisés dans CG mais conservés pour la signature: denominator_threshold, device
+
+    # --- Logique de Produit Scalaire (Intégrée) ---
+    def _dot_product_gpu(mod, a_ptr, b_ptr, N_int, stream):
+        block_size = 256
+        grid_size = (N_int + block_size - 1) // block_size
+        
+        reduction_host = np.empty(grid_size, dtype=np.float32)
+        reduction_buffer = drv.mem_alloc(reduction_host.nbytes)
+        
+        dot_kernel = mod.get_function("dot_product_reduction_kernel") 
+
+        dot_kernel(reduction_buffer, a_ptr, b_ptr, np.int32(N_int), 
+                   block=(block_size, 1, 1), grid=(grid_size, 1, 1), stream=stream)
+        
+        drv.memcpy_dtoh(reduction_host, reduction_buffer)
+        total_dot = np.sum(reduction_host)
+        
+        reduction_buffer.free()
+        return total_dot
+    # -----------------------------------------------
+
+    try:
+        if not isinstance(SMatrix, SMatrix.__class__):
+            raise TypeError("SMatrix must be a SparseSMatrix_CSR object")
+
+        if SMatrix.ctx:
+            SMatrix.ctx.push()
+
+        dtype = np.float32
+        TN = SMatrix.N * SMatrix.T
+        ZX = SMatrix.Z * SMatrix.X
+        Z = SMatrix.Z 
+        X = SMatrix.X
+        block_size = 256
+        tolerance = 1e-12 
+
+        if show_logs:
+            print(f"Executing on GPU device index: {SMatrix.device.primary_context.device.name()}")
+            print(f"Dim X: {X}, Dim Z: {Z}, TN: {TN}, ZX: {ZX}")
+
+        stream = drv.Stream()
+        
+        # Récupération des Kernels
+        projection_kernel = SMatrix.sparse_mod.get_function('projection_kernel__CSR')
+        backprojection_kernel = SMatrix.sparse_mod.get_function('backprojection_kernel__CSR')
+        axpby_kernel = SMatrix.sparse_mod.get_function("vector_axpby_kernel")
+        minus_axpy_kernel = SMatrix.sparse_mod.get_function("vector_minus_axpy_kernel")
+        
+        # --- Allocation des buffers (Pointeurs Bruts) ---
+        y = y.T.flatten().astype(dtype)
+        y_gpu = drv.mem_alloc(y.nbytes)
+        drv.memcpy_htod_async(y_gpu, y.astype(dtype), stream)
+
+        theta_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize) # lambda
+        drv.memcpy_htod_async(theta_flat_gpu, np.full(ZX, 0.1, dtype=dtype), stream)
+
+        q_flat_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)      # q = A*p
+        r_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)      # r (residue)
+        p_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)      # p (direction)
+        z_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)      # z = A^T A p
+        ATy_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)    # A^T y (constant)
+
+        # --- Initialisation CG ---
+        
+        # 1. ATy = A^T * y 
+        drv.memset_d32_async(ATy_flat_gpu, 0, ZX, stream)
+        backprojection_kernel(ATy_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
+                              y_gpu, np.int32(TN),
+                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+        
+        # 2. q = A * theta_0
+        projection_kernel(q_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
+                          theta_flat_gpu, np.int32(TN),
+                          block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+        # 3. r_temp = A^T * q = A^T A theta_0
+        drv.memset_d32_async(r_flat_gpu, 0, ZX, stream)
+        backprojection_kernel(r_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
+                              q_flat_gpu, np.int32(TN),
+                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+        # 4. r_0 = ATy - r_temp (r = ATy + (-1)*r_temp)
+        axpby_kernel(r_flat_gpu, ATy_flat_gpu, r_flat_gpu, 
+                     np.float32(1.0), np.float32(-1.0), np.int32(ZX), 
+                     block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+        
+        # 5. p_0 = r_0
+        drv.memcpy_dtod(p_flat_gpu, r_flat_gpu, ZX * np.dtype(dtype).itemsize)
+        
+        # 6. rho_prev = ||r_0||^2
+        rho_prev = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+
+        # --- Boucle itérative ---
+        saved_theta, saved_indices = [], []
+        if numIterations <= max_saves:
+            save_indices = list(range(numIterations))
+        else:
+            save_indices = list(range(0, numIterations, max(1, numIterations // max_saves)))
+            if save_indices[-1] != numIterations - 1:
+                save_indices.append(numIterations - 1)
+
+        description = f"AOT-BioMaps -- LS-CG (CSR-sparse SMatrix) ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+
+        for it in iterator:
+            # a. q = A * p
+            projection_kernel(q_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
+                              p_flat_gpu, np.int32(TN),
+                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # b. z = A^T * q = A^T A p
+            drv.memset_d32_async(z_flat_gpu, 0, ZX, stream)
+            backprojection_kernel(z_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
+                                  q_flat_gpu, np.int32(TN),
+                                  block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # c. alpha = rho_prev / <p, z>
+            pAp = _dot_product_gpu(SMatrix.sparse_mod, p_flat_gpu, z_flat_gpu, ZX, stream)
+            
+            if abs(pAp) < 1e-15: break
+            alpha = rho_prev / pAp
+            
+            # d. theta = theta + alpha * p
+            axpby_kernel(theta_flat_gpu, theta_flat_gpu, p_flat_gpu, 
+                         np.float32(1.0), alpha, np.int32(ZX), 
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # e. r = r - alpha * z
+            minus_axpy_kernel(r_flat_gpu, z_flat_gpu, alpha, np.int32(ZX),
+                              block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            # f. rho_curr = ||r||^2
+            rho_curr = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+            
+            if rho_curr < tolerance: break
+
+            # g. beta = rho_curr / rho_prev
+            beta = rho_curr / rho_prev
+            
+            # h. p = r + beta * p
+            axpby_kernel(p_flat_gpu, r_flat_gpu, p_flat_gpu, 
+                         np.float32(1.0), beta, np.int32(ZX), 
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            rho_prev = rho_curr
+
+            if show_logs and (it % 10 == 0 or it == numIterations - 1):
+                drv.Context.synchronize()
+
+            if isSavingEachIteration and it in save_indices:
+                theta_host = np.empty(ZX, dtype=dtype)
+                drv.memcpy_dtoh(theta_host, theta_flat_gpu)
+                saved_theta.append(theta_host.reshape(Z, X))
+                saved_indices.append(it)
+
+        drv.Context.synchronize()
+
+        final_result = np.empty(ZX, dtype=dtype)
+        drv.memcpy_dtoh(final_result, theta_flat_gpu)
+        final_result = final_result.reshape(Z, X)
+
+        # Libération
+        y_gpu.free(); q_flat_gpu.free(); r_flat_gpu.free(); p_flat_gpu.free(); z_flat_gpu.free(); theta_flat_gpu.free(); ATy_flat_gpu.free()
+
+        return (saved_theta, saved_indices) if isSavingEachIteration else (final_result, None)
+
+    except Exception as e:
+        print(f"Error in LS_CG_sparseCSR_pycuda: {type(e).__name__}: {e}")
+        gc.collect()
+        return None, None
+        
+    finally:
+        if SMatrix and hasattr(SMatrix, 'ctx') and SMatrix.ctx:
+            SMatrix.ctx.pop()
+
+def _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs=True):
+    """
+    Reconstruction par Moindres Carrés (LS) via Gradient Conjugué (CG) sur format SELL-C-sigma.
+    Utilise les mêmes arguments que la fonction MLEM, sans sous-fonctions Python.
+
+    SMatrix: instance de SparseSMatrix_SELL (déjà allouée)
+    y: données mesurées (1D np.float32 de taille TN)
+    """
+    final_result = None
+
+    # --- Logique de Produit Scalaire (Intégrée) ---
+    def _dot_product_gpu(mod, a_ptr, b_ptr, N_int, stream):
+        block_size = 256
+        grid_size = (N_int + block_size - 1) // block_size
+        
+        reduction_host = np.empty(grid_size, dtype=np.float32)
+        reduction_buffer = drv.mem_alloc(reduction_host.nbytes)
+        
+        dot_kernel = mod.get_function("dot_product_reduction_kernel") 
+
+        dot_kernel(reduction_buffer, a_ptr, b_ptr, np.int32(N_int), 
+                   block=(block_size, 1, 1), grid=(grid_size, 1, 1), stream=stream)
+        
+        drv.memcpy_dtoh(reduction_host, reduction_buffer)
+        total_dot = np.sum(reduction_host)
+        
+        reduction_buffer.free()
+        return total_dot
+    # -----------------------------------------------
+
+    try:
+        if not isinstance(SMatrix, SMatrix.__class__):
+            raise TypeError("SMatrix must be a SparseSMatrix_SELL object")
+        if SMatrix.sell_values_gpu is None:
+            raise RuntimeError("SELL not built. Call allocate_sell_c_sigma_direct() first.")
+            
+        if SMatrix.ctx:
+            SMatrix.ctx.push()
+
+        dtype = np.float32
+        TN = int(SMatrix.N * SMatrix.T)
+        ZX = int(SMatrix.Z * SMatrix.X)
+        Z = SMatrix.Z 
+        X = SMatrix.X
+        block_size = 256
+        tolerance = 1e-12 
+
+        # Accès aux paramètres SELL
+        projection_kernel = SMatrix.sparse_mod.get_function("projection_kernel__SELL")
+        backprojection_kernel = SMatrix.sparse_mod.get_function("backprojection_kernel__SELL")
+        axpby_kernel = SMatrix.sparse_mod.get_function("vector_axpby_kernel")
+        minus_axpy_kernel = SMatrix.sparse_mod.get_function("vector_minus_axpy_kernel")
+        slice_height = np.int32(SMatrix.slice_height)
+        grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
+
+        stream = drv.Stream()
+
+        # Allocation des buffers
+        y = y.T.flatten().astype(dtype)
+        y_gpu = drv.mem_alloc(y.nbytes)
+        drv.memcpy_htod_async(y_gpu, y.astype(dtype), stream)
+
+        theta_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+        drv.memcpy_htod_async(theta_flat_gpu, np.full(ZX, 0.1, dtype=dtype), stream)
+
+        q_flat_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
+        r_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+        p_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+        z_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+        ATy_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize) 
+
+        # --- Initialisation CG ---
+        
+        # 1. ATy = A^T * y 
+        drv.memset_d32_async(ATy_flat_gpu, 0, ZX, stream)
+        backprojection_kernel(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                              y_gpu, ATy_flat_gpu, np.int32(TN), slice_height,
+                              block=(block_size, 1, 1), grid=grid_rows, stream=stream)
+        
+        # 2. q = A * theta_0
+        projection_kernel(q_flat_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                          theta_flat_gpu, np.int32(TN), slice_height,
+                          block=(block_size, 1, 1), grid=grid_rows, stream=stream)
+
+        # 3. r_temp = A^T * q = A^T A theta_0
+        drv.memset_d32_async(r_flat_gpu, 0, ZX, stream)
+        backprojection_kernel(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                              q_flat_gpu, r_flat_gpu, np.int32(TN), slice_height,
+                              block=(block_size, 1, 1), grid=grid_rows, stream=stream)
+
+        # 4. r_0 = ATy - r_temp
+        axpby_kernel(r_flat_gpu, ATy_flat_gpu, r_flat_gpu, 
+                     np.float32(1.0), np.float32(-1.0), np.int32(ZX), 
+                     block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+        
+        # 5. p_0 = r_0
+        drv.memcpy_dtod(p_flat_gpu, r_flat_gpu, ZX * np.dtype(dtype).itemsize)
+        
+        # 6. rho_prev = ||r_0||^2
+        rho_prev = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+
+        # --- Boucle itérative ---
+        saved_theta, saved_indices = [], []
+        if numIterations <= max_saves:
+            save_indices = list(range(numIterations))
+        else:
+            save_indices = list(range(0, numIterations, max(1, numIterations // max_saves)))
+            if save_indices[-1] != numIterations - 1:
+                save_indices.append(numIterations - 1)
+
+        description = f"AOT-BioMaps -- LS-CG (SELL-c-σ-sparse SMatrix) ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+
+        for it in iterator:
+            # a. q = A * p
+            projection_kernel(q_flat_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                              p_flat_gpu, np.int32(TN), slice_height,
+                              block=(block_size, 1, 1), grid=grid_rows, stream=stream)
+
+            # b. z = A^T * q = A^T A p
+            drv.memset_d32_async(z_flat_gpu, 0, ZX, stream)
+            backprojection_kernel(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                                  q_flat_gpu, z_flat_gpu, np.int32(TN), slice_height,
+                                  block=(block_size, 1, 1), grid=grid_rows, stream=stream)
+
+            # c. alpha = rho_prev / <p, z>
+            pAp = _dot_product_gpu(SMatrix.sparse_mod, p_flat_gpu, z_flat_gpu, ZX, stream)
+            
+            if abs(pAp) < 1e-15: break
+            alpha = rho_prev / pAp
+            
+            # d. theta = theta + alpha * p
+            axpby_kernel(theta_flat_gpu, theta_flat_gpu, p_flat_gpu, 
+                         np.float32(1.0), alpha, np.int32(ZX), 
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # e. r = r - alpha * z
+            minus_axpy_kernel(r_flat_gpu, z_flat_gpu, alpha, np.int32(ZX),
+                              block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            # f. rho_curr = ||r||^2
+            rho_curr = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+            
+            if rho_curr < tolerance: break
+
+            # g. beta = rho_curr / rho_prev
+            beta = rho_curr / rho_prev
+            
+            # h. p = r + beta * p
+            axpby_kernel(p_flat_gpu, r_flat_gpu, p_flat_gpu, 
+                         np.float32(1.0), beta, np.int32(ZX), 
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            rho_prev = rho_curr
+
+            stream.synchronize()
+            if isSavingEachIteration and it in save_indices:
+                out = np.empty(ZX, dtype=dtype)
+                drv.memcpy_dtoh(out, theta_flat_gpu)
+                saved_theta.append(out.reshape((Z, X)))
+                saved_indices.append(it)
+
+        # final copy
+        res = np.empty(ZX, dtype=np.float32)
+        drv.memcpy_dtoh(res, theta_flat_gpu)
+        final_result = res.reshape((Z, X))
+
+        # free temporaries
+        y_gpu.free(); q_flat_gpu.free(); r_flat_gpu.free(); p_flat_gpu.free(); z_flat_gpu.free(); theta_flat_gpu.free(); ATy_flat_gpu.free()
+        
+        return (saved_theta, saved_indices) if isSavingEachIteration else (final_result, None)
+        
+    except Exception as e:
+        print(f"Error in LS_CG_sparseSELL_pycuda: {type(e).__name__}: {e}")
+        gc.collect()
+        return None, None
+        
+    finally:
+        if SMatrix and hasattr(SMatrix, 'ctx') and SMatrix.ctx:
+            SMatrix.ctx.pop()