AOT-biomaps 2.9.212__py3-none-any.whl → 2.9.233__py3-none-any.whl

AOT_biomaps/AOT_Recon/AlgebraicRecon.py

@@ -1,27 +1,27 @@
 from ._mainRecon import Recon
-from .ReconEnums import ReconType, OptimizerType, ProcessType
+from .ReconEnums import ReconType, OptimizerType, ProcessType, SparsingType
 from .AOT_Optimizers import MLEM, LS
-from .ReconTools import check_gpu_memory, calculate_memory_requirement, mse, load_recon
 from AOT_biomaps.Config import config
 
 import os
-import sys
 import subprocess
-import warnings
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.animation as animation
 from IPython.display import HTML
 from datetime import datetime
 from tempfile import gettempdir
-import re
+import cupy as cp
+import cupyx.scipy.sparse as cpsparse
+import gc
+from tqdm import trange
 
 class AlgebraicRecon(Recon):
     """
     This class implements the Algebraic reconstruction process.
     It currently does not perform any operations but serves as a template for future implementations.
     """
-    def __init__(self, opti = OptimizerType.MLEM, numIterations = 10000, numSubsets = 1, isSavingEachIteration=True, maxSaves = 5000, alpha = None, **kwargs):
+    def __init__(self, opti = OptimizerType.MLEM, numIterations = 10000, numSubsets = 1, isSavingEachIteration=True, maxSaves = 5000, alpha = None, denominatorThreshold = 1e-6, useSparseSMatrix=True, sparseType = SparsingType.CSR, sparseThreshold=0.1, device = None, **kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Algebraic
         self.optimizer = opti
@@ -32,7 +32,14 @@ class AlgebraicRecon(Recon):
         self.numSubsets = numSubsets
         self.isSavingEachIteration = isSavingEachIteration
         self.maxSaves = maxSaves
+        self.denominatorThreshold = denominatorThreshold
         self.alpha = alpha  # Regularization parameter for LS
+        self.device = device
+        self.SMatrix_sparse = None  # Sparse system matrix
+        self.sparseThreshold = sparseThreshold
+        self.useSparseSMatrix = useSparseSMatrix  # Whether to use sparse SMatrix in optimizers
+        self.sparseType = sparseType
+        self.Z_dim = None  # Used for sparse matrix reconstruction
 
         if self.numIterations <= 0:
             raise ValueError("Number of iterations must be greater than 0.")
@@ -44,143 +51,29 @@ class AlgebraicRecon(Recon):
             raise TypeError("Number of subsets must be an integer.")
         
         print("Generating system matrix (processing acoustic fields)...")
-        self.SMatrix = np.stack([ac_field.field for ac_field in self.experiment.AcousticFields], axis=-1)
+        self.SMatrix = self._sparseSMatrix()
 
     # PUBLIC METHODS
 
-    def run(self, processType = ProcessType.PYTHON, withTumor= True):
+    def run(self, processType = ProcessType.PYTHON, withTumor= True, show_logs=True):
         """
         This method is a placeholder for the Algebraic reconstruction process.
         It currently does not perform any operations but serves as a template for future implementations.
         """
-            
         if(processType == ProcessType.CASToR):
-            self._AlgebraicReconCASToR(withTumor)
+            self._AlgebraicReconCASToR(withTumor=withTumor, show_logs=show_logs)
         elif(processType == ProcessType.PYTHON):
-            self._AlgebraicReconPython(withTumor)
+            self._AlgebraicReconPython(withTumor=withTumor, show_logs=show_logs)
         else:
             raise ValueError(f"Unknown Algebraic reconstruction type: {processType}")
+        
+    def sparse_SMatrix(self):
+        if self.sparseType == SparsingType.CSR:
+            self.SMatrix_sparse, self.Z_dim = self._sparseSMatrix_CSR(self.experiment.AcousticFields, threshold=self.sparseThreshold)
+        if self.sparseType == SparsingType.COO:
+            raise NotImplementedError("COO sparse matrix not implemented yet.")
 
-    def load_reconCASToR(self, withTumor=True):
-        # Détermine le dossier et le préfixe des fichiers
-        folder = 'results_withTumor' if withTumor else 'results_withoutTumor'
-        folder_path = os.path.join(self.saveDir, folder)
-
-        # Liste tous les fichiers .img dans le dossier
-        img_files = [
-            f for f in os.listdir(folder_path)
-            if f.endswith('.img') and f.startswith(folder)
-        ]
-
-        # Fonction pour extraire le numéro d'itération (ex: "it56" → 56)
-        def get_iteration(filename):
-            match = re.search(r'_it(\d+)\.img$', filename)
-            return int(match.group(1)) if match else float('inf')  # Retourne l'infini pour les fichiers invalides (ils seront à la fin)
-
-        # Trie les fichiers par numéro d'itération (croissant)
-        sorted_files = sorted(img_files, key=get_iteration)
-
-        # Charge les données et remplit self.reconPhantom/self.reconLaser + self.indices
-        for file in sorted_files:
-            # Chemin complet du fichier .hdr correspondant
-            hdr_path = os.path.join(folder_path, file.replace('.img', '.hdr'))
-
-            # Vérifie que le .hdr existe avant de charger
-            if os.path.exists(hdr_path):
-                theta = load_recon(hdr_path)
-                iteration = get_iteration(file)
-
-                if iteration != float('inf'):  # Ignore les fichiers mal formatés
-                    if withTumor:
-                        self.reconPhantom.append(theta)
-                    else:
-                        self.reconLaser.append(theta)
-                    self.indices.append(iteration)
-
-    def load_reconPython(self, withTumor=True, results_date=None, optimizer=None, filePath=None):
-        if filePath is not None:
-            # Mode chargement direct depuis un fichier
-            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
-            recon_path = filePath
-            if not os.path.exists(recon_path):
-                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
-            # Charge les données
-            data = np.load(recon_path, allow_pickle=True)
-            # Découpe en liste de 2D si c'est un tableau 3D
-            if isinstance(data, np.ndarray) and data.ndim == 3:
-                if withTumor:
-                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
-                else:
-                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
-            else:
-                # Si ce n'est pas un tableau 3D, on suppose que c'est déjà une liste de 2D
-                if withTumor:
-                    self.reconPhantom = data
-                else:
-                    self.reconLaser = data
-            # Essayer de charger les indices
-            base_dir, file_name = os.path.split(recon_path)
-            file_base, _ = os.path.splitext(file_name)
-            indices_path = os.path.join(base_dir, f"indices.npy")
-            if os.path.exists(indices_path):
-                indices_data = np.load(indices_path, allow_pickle=True)
-                if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
-                    self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
-                else:
-                    self.indices = indices_data
-            else:
-                self.indices = None
-            print(f"Loaded reconstruction results and indices from {recon_path}")
-        else:
-            # Mode chargement depuis le répertoire de résultats
-            if self.saveDir is None:
-                raise ValueError("Save directory is not specified. Please set saveDir before loading.")
-            # Determine optimizer name for path matching
-            opt_name = optimizer.value if optimizer is not None else self.optimizer.value
-            # Find the most recent results directory if no date is specified
-            if results_date is None:
-                dirs = [
-                    d for d in os.listdir(self.saveDir)
-                    if os.path.isdir(os.path.join(self.saveDir, d))
-                    and re.match(r'results_\d{4}_' + re.escape(opt_name) + r'($|_)', d)
-                ]
-                if not dirs:
-                    raise FileNotFoundError(f"No results directory found for optimizer '{opt_name}' in {self.saveDir}.")
-                dirs.sort(reverse=True)  # Most recent first
-                results_dir = os.path.join(self.saveDir, dirs[0])
-            else:
-                results_dir = os.path.join(self.saveDir, f'results_{results_date}_{opt_name}')
-                if not os.path.exists(results_dir):
-                    raise FileNotFoundError(f"Directory {results_dir} does not exist.")
-            # Load reconstruction results
-            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
-            recon_path = os.path.join(results_dir, f'{recon_key}.npy')
-            if not os.path.exists(recon_path):
-                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
-            data = np.load(recon_path, allow_pickle=True)
-            # Découpe en liste de 2D si c'est un tableau 3D
-            if isinstance(data, np.ndarray) and data.ndim == 3:
-                if withTumor:
-                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
-                else:
-                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
-            else:
-                if withTumor:
-                    self.reconPhantom = data
-                else:
-                    self.reconLaser = data
-            # Try to load saved indices (if file exists)
-            indices_path = os.path.join(results_dir, 'indices.npy')
-            if os.path.exists(indices_path):
-                indices_data = np.load(indices_path, allow_pickle=True)
-                if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
-                    self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
-                else:
-                    self.indices = indices_data
-            else:
-                self.indices = None
-
-    def plot_MSE(self, isSaving=True, log_scale_x=False, log_scale_y=False):
+    def plot_MSE(self, isSaving=True, log_scale_x=False, log_scale_y=False, show_logs=True):
         """
         Plot the Mean Squared Error (MSE) of the reconstruction.
 
@@ -195,8 +88,8 @@ class AlgebraicRecon(Recon):
             raise ValueError("MSE is empty. Please calculate MSE first.")
 
         best_idx = self.indices[np.argmin(self.MSE)]
-
-        print(f"Lowest MSE = {np.min(self.MSE):.4f} at iteration {best_idx+1}")
+        if show_logs:
+            print(f"Lowest MSE = {np.min(self.MSE):.4f} at iteration {best_idx+1}")
         # Plot MSE curve
         plt.figure(figsize=(7, 5))
         plt.plot(self.indices, self.MSE, 'r-', label="MSE curve")
@@ -225,17 +118,17 @@ class AlgebraicRecon(Recon):
                 scale_str = "_logy"
             SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_MSE_plot_{self.optimizer.name}_{scale_str}{date_str}.png')
             plt.savefig(SavingFolder, dpi=300)
-            print(f"MSE plot saved to {SavingFolder}")
+            if show_logs:
+                print(f"MSE plot saved to {SavingFolder}")
 
         plt.show()
 
-    def show_MSE_bestRecon(self, isSaving=True):
+    def show_MSE_bestRecon(self, isSaving=True, show_logs=True):
         if not self.MSE:
             raise ValueError("MSE is empty. Please calculate MSE first.")
 
 
         best_idx = np.argmin(self.MSE)
-        print(best_idx)
         best_recon = self.reconPhantom[best_idx]
 
         # Crée la figure et les axes
@@ -264,7 +157,6 @@ class AlgebraicRecon(Recon):
 
         # Right: Reconstruction at last iteration
         lastRecon = self.reconPhantom[-1]
-        print(lastRecon.shape)
         if self.experiment.OpticImage.phantom.shape != lastRecon.shape:
             lastRecon = lastRecon.T
         im2 = axs[2].imshow(lastRecon,
@@ -293,11 +185,12 @@ class AlgebraicRecon(Recon):
                 os.makedirs(savePath)
             SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_comparison_MSE_BestANDLastRecon_{self.optimizer.name}_{date_str}.png')
             plt.savefig(SavingFolder, dpi=300, bbox_inches='tight')
-            print(f"MSE plot saved to {SavingFolder}")
+            if show_logs:
+                print(f"MSE plot saved to {SavingFolder}")
 
         plt.show()
 
-    def show_theta_animation(self, vmin=None, vmax=None, total_duration_ms=3000, save_path=None, max_frames=1000, isPropMSE=True):
+    def show_theta_animation(self, vmin=None, vmax=None, total_duration_ms=3000, save_path=None, max_frames=1000, isPropMSE=True, show_logs=True):
         """
         Show theta iteration animation with speed proportional to MSE acceleration.
         In "propMSE" mode: slow down when MSE changes rapidly, speed up when MSE stagnates.
@@ -400,18 +293,19 @@ class AlgebraicRecon(Recon):
                 ani.save(save_path, writer=animation.PillowWriter(fps=100))
             elif save_path.endswith(".mp4"):
                 ani.save(save_path, writer="ffmpeg", fps=30)
-            print(f"Animation saved to {save_path}")
+            if show_logs:
+                print(f"Animation saved to {save_path}")
 
         plt.close(fig)
         return HTML(ani.to_jshtml())
 
-    def plot_SSIM(self, isSaving=True, log_scale_x=False, log_scale_y=False):
+    def plot_SSIM(self, isSaving=True, log_scale_x=False, log_scale_y=False, show_logs=True):
         if not self.SSIM:
             raise ValueError("SSIM is empty. Please calculate SSIM first.")
 
         best_idx = self.indices[np.argmax(self.SSIM)]
-
-        print(f"Highest SSIM = {np.max(self.SSIM):.4f} at iteration {best_idx+1}")
+        if show_logs:
+            print(f"Highest SSIM = {np.max(self.SSIM):.4f} at iteration {best_idx+1}")
         # Plot SSIM curve
         plt.figure(figsize=(7, 5))
         plt.plot(self.indices, self.SSIM, 'r-', label="SSIM curve")
@@ -440,11 +334,12 @@ class AlgebraicRecon(Recon):
                 scale_str = "_logy"
             SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_SSIM_plot_{self.optimizer.name}_{scale_str}{date_str}.png')
             plt.savefig(SavingFolder, dpi=300)
-            print(f"SSIM plot saved to {SavingFolder}")
+            if show_logs:
+                print(f"SSIM plot saved to {SavingFolder}")
 
         plt.show()
 
-    def show_SSIM_bestRecon(self, isSaving=True):
+    def show_SSIM_bestRecon(self, isSaving=True, show_logs=True):
         
         if not self.SSIM:
             raise ValueError("SSIM is empty. Please calculate SSIM first.")
@@ -489,10 +384,11 @@ class AlgebraicRecon(Recon):
             date_str = now.strftime("%Y_%d_%m_%y")
             SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_comparison_SSIM_BestANDLastRecon_{self.optimizer.name}_{date_str}.png')
             plt.savefig(SavingFolder, dpi=300)
-            print(f"SSIM plot saved to {SavingFolder}")
+            if show_logs:
+                print(f"SSIM plot saved to {SavingFolder}")
         plt.show()
 
-    def plot_CRC_vs_Noise(self, use_ROI=True, fin=None, isSaving=True):
+    def plot_CRC_vs_Noise(self, use_ROI=True, fin=None, isSaving=True, show_logs=True):
         """
         Plot CRC (Contrast Recovery Coefficient) vs Noise for each iteration.
         """
@@ -540,10 +436,11 @@ class AlgebraicRecon(Recon):
             date_str = now.strftime("%Y_%d_%m_%y")
             SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_CRCvsNOISE_{self.optimizer.name}_{date_str}.png')
             plt.savefig(SavingFolder, dpi=300)
-            print(f"CRCvsNOISE plot saved to {SavingFolder}")
+            if show_logs:
+                print(f"CRCvsNOISE plot saved to {SavingFolder}")
         plt.show()
         
-    def show_reconstruction_progress(self, start=0, fin=None, save_path=None, with_tumor=True):
+    def show_reconstruction_progress(self, start=0, fin=None, save_path=None, with_tumor=True, show_logs=True):
         """
         Show the reconstruction progress for either with or without tumor.
         If isPropMSE is True, the frame selection is adapted to MSE changes.
@@ -648,7 +545,8 @@ class AlgebraicRecon(Recon):
             else:
                 save_path = f"{save_path}_{title_suffix}"
             plt.savefig(save_path, dpi=300)
-            print(f"Figure saved to: {save_path}")
+            if show_logs:
+                print(f"Figure saved to: {save_path}")
 
         plt.show()
 
@@ -671,12 +569,12 @@ class AlgebraicRecon(Recon):
         if not os.path.exists(results_dir):
             os.makedirs(results_dir)
 
-        if os.path.exists(os.path.join(results_dir,"reconIndices.npy")):
+        if os.path.exists(os.path.join(results_dir,"indices.npy")):
             return (True, results_dir)
 
         return (False, results_dir)
 
-    def load(self, processType = ProcessType.PYTHON, withTumor=True, results_date=None, optimizer=None, filePath=None):
+    def load(self, withTumor=True, results_date=None, optimizer=None, filePath=None, show_logs=True):
         """
         Load the reconstruction results (reconPhantom or reconLaser) and indices as lists of 2D np arrays into self.
         If the loaded file is a 3D array, it is split into a list of 2D arrays.
@@ -686,53 +584,301 @@ class AlgebraicRecon(Recon):
             optimizer: Optimizer name (as string or enum) to filter results. If None, uses the current optimizer of the instance.
             filePath: Optional. If provided, loads directly from this path (overrides saveDir and results_date).
         """
-
-        pass
-        # print(f"Loaded reconstruction results and indices from {results_dir}")
-
+        if filePath is not None:
+            # Mode chargement direct depuis un fichier
+            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
+            recon_path = filePath
+            if not os.path.exists(recon_path):
+                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
+            # Charge le fichier (3D ou liste de 2D)
+            data = np.load(recon_path, allow_pickle=True)
+            # Découpe en liste de 2D si c'est un tableau 3D
+            if isinstance(data, np.ndarray) and data.ndim == 3:
+                if withTumor:
+                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
+                else:
+                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
+            else:
+                # Sinon, suppose que c'est déjà une liste de 2D
+                if withTumor:
+                    self.reconPhantom = data
+                else:
+                    self.reconLaser = data
+            # Essayer de charger les indices
+            base_dir, _ = os.path.split(recon_path)
+            indices_path = os.path.join(base_dir, 'indices.npy')
+            if os.path.exists(indices_path):
+                indices_data = np.load(indices_path, allow_pickle=True)
+                if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
+                    self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
+                else:
+                    self.indices = indices_data
+            else:
+                self.indices = None
+                
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {recon_path}")
+        else:
+            # Mode chargement depuis le répertoire de résultats
+            if self.saveDir is None:
+                raise ValueError("Save directory is not specified. Please set saveDir before loading.")
+            # Use current optimizer and potential function if not provided
+            opt_name = optimizer.value if optimizer is not None else self.optimizer.value
+            # Build the base directory pattern
+            dir_pattern = f'results_*_{opt_name}'
+            # Add parameters to the pattern based on the optimizer
+            if optimizer is None:
+                optimizer = self.optimizer
+            if optimizer == OptimizerType.PPGMLEM:
+                beta_str = f'_Beta_{self.beta}'
+                delta_str = f'_Delta_{self.delta}'
+                gamma_str = f'_Gamma_{self.gamma}'
+                sigma_str = f'_Sigma_{self.sigma}'
+                dir_pattern += f'{beta_str}{delta_str}{gamma_str}{sigma_str}'
+            elif optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
+                beta_str = f'_Beta_{self.beta}'
+                sigma_str = f'_Sigma_{self.sigma}'
+                dir_pattern += f'{beta_str}{sigma_str}'
+            # Find the most recent results directory if no date is specified
+            if results_date is None:
+                dirs = [d for d in os.listdir(self.saveDir) if os.path.isdir(os.path.join(self.saveDir, d)) and dir_pattern in d]
+                if not dirs:
+                    raise FileNotFoundError(f"No matching results directory found for pattern '{dir_pattern}' in {self.saveDir}.")
+                dirs.sort(reverse=True)  # Most recent first
+                results_dir = os.path.join(self.saveDir, dirs[0])
+            else:
+                results_dir = os.path.join(self.saveDir, f'results_{results_date}_{opt_name}')
+                if optimizer == OptimizerType.MLEM:
+                    pass
+                elif optimizer == OptimizerType.LS:
+                    results_dir += f'_Alpha_{self.alpha}'
+                if not os.path.exists(results_dir):
+                    raise FileNotFoundError(f"Directory {results_dir} does not exist.")
+            # Load reconstruction results
+            recon_key = 'reconPhantom' if withTumor else 'reconLaser'
+            recon_path = os.path.join(results_dir, f'{recon_key}.npy')
+            if not os.path.exists(recon_path):
+                raise FileNotFoundError(f"No reconstruction file found at {recon_path}.")
+            data = np.load(recon_path, allow_pickle=True)
+            if isinstance(data, np.ndarray) and data.ndim == 3:
+                if withTumor:
+                    self.reconPhantom = [data[i, :, :] for i in range(data.shape[0])]
+                else:
+                    self.reconLaser = [data[i, :, :] for i in range(data.shape[0])]
+            else:
+                if withTumor:
+                    self.reconPhantom = data
+                else:
+                    self.reconLaser = data
+            # Load saved indices as list of 2D arrays
+            indices_path = os.path.join(results_dir, 'indices.npy')
+            if not os.path.exists(indices_path):
+                raise FileNotFoundError(f"No indices file found at {indices_path}.")
+            indices_data = np.load(indices_path, allow_pickle=True)
+            if isinstance(indices_data, np.ndarray) and indices_data.ndim == 3:
+                self.indices = [indices_data[i, :, :] for i in range(indices_data.shape[0])]
+            else:
+                self.indices = indices_data
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {results_dir}")
+        
     def normalizeSMatrix(self):
         self.SMatrix = self.SMatrix / (float(self.experiment.params.acoustic['voltage'])*float(self.experiment.params.acoustic['sensitivity']))  
 
     # PRIVATE METHODS
 
-    def _AlgebraicReconPython(self,withTumor):
+    def _sparseSMatrix_CSR(AcousticFields, threshold_factor=0.1, normalize=False):
+        """
+        Construit une matrice sparse CSR par morceaux sans concaténation intermédiaire.
+        Libère toute la mémoire temporaire à chaque étape.
+        """
+        device_index = config.select_best_gpu()
+        # Configuration GPU
+        cp.cuda.Device(device_index).use()
+        dtype = cp.float32
+        dtype_indices = cp.int32
+
+        # Mesure mémoire initiale
+        total_mem, free_mem = cp.cuda.Device(device_index).mem_info
+        initial_mem = total_mem - free_mem
+        print(f"VRAM initiale: {initial_mem / 1024**3:.3f} Go")
+
+        N = len(AcousticFields)
+        if N == 0:
+            raise ValueError("Aucun champ acoustique fourni.")
+
+        # Déterminer les dimensions
+        field = AcousticFields[0].field
+        if isinstance(field, np.ndarray):
+            field = cp.asarray(field, dtype=dtype)
+        T, Z, X = field.shape
+        TN, ZX = T * N, Z * X
+
+        # Création d'une matrice CSR vide
+        SMatrix = cpsparse.csr_matrix((TN, ZX), dtype=dtype)
+
+        try:
+            # Traitement field par field
+            for n in trange(N, desc="Sparsing fields", unit="field"):
+                field = AcousticFields[n].field
+                if isinstance(field, np.ndarray):
+                    field = cp.asarray(field, dtype=dtype)
+
+                # Liste pour stocker les données du field courant
+                field_rows = []
+                field_cols = []
+                field_values = []
+
+                for t in range(T):
+                    field_t = field[t]
+                    threshold = threshold_factor * cp.max(cp.abs(field_t))
+                    mask = cp.abs(field_t) > threshold
+
+                    if not cp.any(mask):
+                        continue
+
+                    z_idx, x_idx = cp.where(mask)
+                    rows = cp.full_like(z_idx, t * N + n, dtype=dtype_indices)
+                    cols = z_idx * X + x_idx
+                    vals = field_t[mask].astype(dtype)
+
+                    if normalize:
+                        max_val = cp.max(cp.abs(vals)) if vals.size > 0 else 1.0
+                        vals = vals / max_val if max_val > 0 else vals
+
+                    field_rows.append(rows)
+                    field_cols.append(cols)
+                    field_values.append(vals)
+
+                    # Libération immédiate
+                    del rows, cols, vals, z_idx, x_idx, mask, field_t
+                    cp.get_default_memory_pool().free_all_blocks()
+
+                # Si des données pour ce field
+                if field_rows:
+                    # Création d'une matrice COO temporaire pour ce field
+                    temp_rows = cp.concatenate(field_rows)
+                    temp_cols = cp.concatenate(field_cols)
+                    temp_values = cp.concatenate(field_values)
+
+                    # Création d'une matrice COO puis conversion en CSR
+                    field_matrix = cpsparse.coo_matrix(
+                        (temp_values, (temp_rows, temp_cols)),
+                        shape=(TN, ZX),
+                        dtype=dtype
+                    ).tocsr()
+
+                    # Ajout à la matrice globale
+                    SMatrix += field_matrix
+
+                    # Libération mémoire
+                    del field_rows, field_cols, field_values
+                    del temp_rows, temp_cols, temp_values, field_matrix
+                    cp.get_default_memory_pool().free_all_blocks()
+                    gc.collect()
+
+                # Libération du field
+                del field
+                cp.get_default_memory_pool().free_all_blocks()
+                gc.collect()
+
+            # Optimisation finale de la matrice
+            SMatrix.sum_duplicates()
+            SMatrix.eliminate_zeros()
+
+            # Calcul des métriques
+            nnz = SMatrix.nnz
+            density = nnz / (TN * ZX)
+            size_bytes = nnz * (4 + 4)  # 4 octets pour int32 + 4 pour float32
+
+            print(f"Dimensions: {TN} x {ZX}, NNZ={nnz:,} (density={density:.2%}) using {size_bytes / 1024**3:.2f} Go of VRAM")
+
+            # Dernière libération avant le return
+            cp.get_default_memory_pool().free_all_blocks()
+            gc.collect()
+
+            return {
+                'DATA': SMatrix,
+                'density': density,
+                'size_bytes': size_bytes
+            }, Z
+
+        except Exception as e:
+            print(f"Erreur: {str(e)}")
+            del SMatrix
+            cp.get_default_memory_pool().free_all_blocks()
+            gc.collect()
+            raise
+
+
+    def _AlgebraicReconPython(self,withTumor, show_logs):
     
         if withTumor:
             if self.experiment.AOsignal_withTumor is None:
                 raise ValueError("AO signal with tumor is not available. Please generate AO signal with tumor the experiment first in the experiment object.")
-            else:
-                y = self.experiment.AOsignal_withTumor
         else:
             if self.experiment.AOsignal_withoutTumor is None:
                 raise ValueError("AO signal without tumor is not available. Please generate AO signal without tumor the experiment first in the experiment object.")
-            else:
-                y = self.experiment.AOsignal_withoutTumor
+        
+        if self.useSparseSMatrix and self.SMatrix_sparse is None:
+            raise ValueError("Sparse SMatrix is not available. Please generate sparse SMatrix first.")
 
         if self.optimizer.value == OptimizerType.MLEM.value:
-            self.reconPhantom, self.indices = MLEM(SMatrix=self.SMatrix, 
-                                                    y=y,
-                                                    numIterations=self.numIterations,
-                                                    isSavingEachIteration=self.isSavingEachIteration,
-                                                    withTumor=withTumor,
-                                                    use_multi_gpu= self.isMultiGPU,
-                                                    use_numba= self.isMultiCPU,
-                                                    max_saves=self.maxSaves
-                                                    )
+            if withTumor:
+                self.reconPhantom, self.indices = MLEM(SMatrix=self.SMatrix, 
+                                                        y=self.experiment.AOsignal_withTumor,
+                                                        numIterations=self.numIterations,
+                                                        isSavingEachIteration=self.isSavingEachIteration,
+                                                        withTumor=withTumor,
+                                                        device=self.device,
+                                                        use_numba=self.isMultiCPU,
+                                                        denominator_threshold=self.denominatorThreshold,
+                                                        max_saves=self.maxSaves,
+                                                        show_logs=show_logs,
+                                                        useSparseSMatrix=self.useSparseSMatrix,
+                                                        Z=self.Z_dim
+                                                        )
+            else:
+                self.reconLaser, self.indices = MLEM(SMatrix=self.SMatrix, 
+                                                        y=self.experiment.AOsignal_withoutTumor,
+                                                        numIterations=self.numIterations,
+                                                        isSavingEachIteration=self.isSavingEachIteration,
+                                                        withTumor=withTumor,
+                                                        device=self.device,
+                                                        use_numba=self.isMultiCPU,
+                                                        denominator_threshold=self.denominatorThreshold,
+                                                        max_saves=self.maxSaves,
+                                                        show_logs=show_logs,
+                                                        useSparseSMatrix=self.useSparseSMatrix,
+                                                        Z=self.Z_dim
+                                                        )
         elif self.optimizer.value == OptimizerType.LS.value:
             if self.alpha is None:
                 raise ValueError("Alpha (regularization parameter) must be set for LS reconstruction.")
-            self.reconPhantom, self.indices = LS(SMatrix=self.SMatrix,
-                                                y=y, 
+            if withTumor:
+                self.reconPhantom, self.indices = LS(SMatrix=self.SMatrix,
+                                                y=self.experiment.AOsignal_withTumor, 
                                                 numIterations=self.numIterations, 
                                                 isSavingEachIteration=self.isSavingEachIteration, 
                                                 withTumor=withTumor,
                                                 alpha=self.alpha,
                                                 max_saves=self.maxSaves,
+                                                show_logs=show_logs
+                                                )
+            else:
+                self.reconLaser, self.indices = LS(SMatrix=self.SMatrix,
+                                                y=self.experiment.AOsignal_withoutTumor, 
+                                                numIterations=self.numIterations, 
+                                                isSavingEachIteration=self.isSavingEachIteration, 
+                                                withTumor=withTumor,
+                                                alpha=self.alpha,
+                                                max_saves=self.maxSaves,
+                                                show_logs=show_logs
                                                 )
         else:
             raise ValueError(f"Only MLEM and LS are supported for simple algebraic reconstruction. {self.optimizer.value} need Bayesian reconstruction")
 
-    def _AlgebraicReconCASToR(self, withTumor):
+    def _AlgebraicReconCASToR(self,withTumor, show_logs):
         # Définir les chemins
         smatrix = os.path.join(self.saveDir, "system_matrix")
         if withTumor:
@@ -742,14 +888,16 @@ class AlgebraicRecon(Recon):
 
         # Vérifier et générer les fichiers d'entrée si nécessaire
         if not os.path.isfile(os.path.join(self.saveDir, fileName)):
-            print(f"Fichier .cdh manquant. Génération de {fileName}...")
+            if show_logs:
+                print(f"Fichier .cdh manquant. Génération de {fileName}...")
             self.experiment.saveAOsignals_Castor(self.saveDir)
 
         # Vérifier/générer la matrice système
         if not os.path.isdir(smatrix):
             os.makedirs(smatrix, exist_ok=True)
         if not os.listdir(smatrix):
-            print("Matrice système manquante. Génération...")
+            if show_logs:
+                print("Matrice système manquante. Génération...")
             self.experiment.saveAcousticFields(self.saveDir)
 
         # Vérifier que le fichier .cdh existe (redondant mais sûr)
@@ -788,8 +936,9 @@ class AlgebraicRecon(Recon):
         ]
 
         # Afficher la commande (pour débogage)
-        print("Commande CASToR :")
-        print(" ".join(cmd))
+        if show_logs:
+            print("Commande CASToR :")
+            print(" ".join(cmd))
 
         # Chemin du script temporaire
         recon_script_path = os.path.join(gettempdir(), 'recon.sh')
@@ -803,17 +952,20 @@ class AlgebraicRecon(Recon):
 
         # Rendre le script exécutable et l'exécuter
         subprocess.run(["chmod", "+x", recon_script_path], check=True)
-        print(f"Exécution de la reconstruction avec CASToR...")
+        if show_logs:
+            print(f"Exécution de la reconstruction avec CASToR...")
         result = subprocess.run(recon_script_path, env=env, check=True, capture_output=True, text=True)
 
         # Afficher la sortie de CASToR (pour débogage)
-        print("Sortie CASToR :")
-        print(result.stdout)
-        if result.stderr:
-            print("Erreurs :")
-            print(result.stderr)
-
-        print("Reconstruction terminée avec succès.")
+        if show_logs:
+            print("Sortie CASToR :")
+            print(result.stdout)
+            if result.stderr:
+                print("Erreurs :")
+                print(result.stderr)
+
+        if show_logs:
+            print("Reconstruction terminée avec succès.")
         self.load_reconCASToR(withTumor=withTumor)
     
     # STATIC METHODS