AOT-biomaps 2.9.138__py3-none-any.whl → 2.9.279__py3-none-any.whl

AOT_biomaps/AOT_Recon/AlgebraicRecon.py

@@ -1,39 +1,51 @@
+import concurrent
+
+from AOT_biomaps.AOT_Recon.ReconTools import get_apodization_vector_gpu
 from ._mainRecon import Recon
-from .ReconEnums import ReconType, OptimizerType, ProcessType
+from .ReconEnums import ReconType, OptimizerType, ProcessType, SMatrixType
 from .AOT_Optimizers import MLEM, LS
-from .ReconTools import check_gpu_memory, calculate_memory_requirement, mse
 from AOT_biomaps.Config import config
-
+from .AOT_SparseSMatrix import SparseSMatrix_CSR, SparseSMatrix_SELL
 
 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 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, lambda_reg=None, L_Factor=None, **kwargs):
+    def __init__(self, opti = OptimizerType.MLEM, numIterations = 10000, numSubsets = 1, isSavingEachIteration=True, maxSaves = 5000, alpha = None, denominatorThreshold = 1e-6, smatrixType = SMatrixType.SELL, sparseThreshold=0.1, device = None, **kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Algebraic
         self.optimizer = opti
         self.reconPhantom = []
         self.reconLaser = []
+        self.indices = []
         self.numIterations = numIterations
         self.numSubsets = numSubsets
         self.isSavingEachIteration = isSavingEachIteration
-        self.lambda_reg = lambda_reg
-        self.L_Factor = L_Factor
+        self.maxSaves = maxSaves
+        self.denominatorThreshold = denominatorThreshold
+        self.alpha = alpha  # Regularization parameter for LS
+        self.device = device
+        self.SMatrix = None  # system matrix
+        self.smatrixType = smatrixType # SMatrixType.DENSE if no sparsing, else SMatrixType.SELL or SMatrixType.CSR or SMatrixType.COO
+        # Sparse matrix attributes
+
+        self.sparseThreshold = sparseThreshold
+
+        self.Z_dim = None  # Used for sparse matrix reconstruction
 
         if self.numIterations <= 0:
             raise ValueError("Number of iterations must be greater than 0.")
@@ -45,38 +57,26 @@ 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)
+        if self.smatrixType == SMatrixType.DENSE:
+            self.SMatrix = self._fillDenseSMatrix()
+        else:
+            self.SMatrix = self._fillSparseSMatrix(isShowLogs=True)
 
     # 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 load_reconCASToR(self,withTumor = True):
-        if withTumor:
-            folder = 'results_withTumor'
-        else:
-            folder = 'results_withoutTumor'
-            
-        for thetaFiles in os.path.join(self.saveDir, folder + '_{}'):
-            if thetaFiles.endswith('.hdr'):
-                theta = Recon.load_recon(thetaFiles)
-                if withTumor:
-                    self.reconPhantom.append(theta)
-                else:
-                    self.reconLaser.append(theta)
-
-    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.
 
@@ -91,8 +91,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")
@@ -119,24 +119,19 @@ class AlgebraicRecon(Recon):
                 scale_str = "_logx"
             elif log_scale_y:
                 scale_str = "_logy"
-            if self.optimizer == OptimizerType.MLEM:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_MSE_plot_MLEM{scale_str}{date_str}.png')
-            elif self.optimizer == OptimizerType.LS:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_MSE_plot_LS{scale_str}{date_str}.png')
-            elif self.optimizer == OptimizerType.LS_TV:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_MSE_plot_LS_TV_Lambda_{self.lambda_reg}_LFactor_{self.L_Factor}{scale_str}{date_str}.png')
+            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
@@ -165,7 +160,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,
@@ -192,19 +186,14 @@ class AlgebraicRecon(Recon):
             savePath = os.path.join(self.saveDir, 'results')
             if not os.path.exists(savePath):
                 os.makedirs(savePath)
-            if self.optimizer == OptimizerType.MLEM:
-                namePath = f'{self.SMatrix.shape[3]}_SCANS_comparison_MSE_BestANDLastRecon_MLEM_Date_{date_str}.png'
-            elif self.optimizer == OptimizerType.LS:
-                namePath = f'{self.SMatrix.shape[3]}_SCANS_comparison_MSE_BestANDLastRecon_LS_Date_{date_str}.png'
-            elif self.optimizer == OptimizerType.LS_TV:
-                namePath = f'{self.SMatrix.shape[3]}_SCANS_comparison_MSE_BestANDLastRecon_LS_TV_Lambda_{self.lambda_reg}_LFactor_{self.L_Factor}_Date_{date_str}.png'
-            SavingFolder = os.path.join(savePath, namePath)
+            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.
@@ -307,18 +296,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")
@@ -345,18 +335,14 @@ class AlgebraicRecon(Recon):
                 scale_str = "_logx"
             elif log_scale_y:
                 scale_str = "_logy"
-            if self.optimizer == OptimizerType.MLEM:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_SSIM_plot_MLEM{scale_str}{date_str}.png')
-            elif self.optimizer == OptimizerType.LS:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_SSIM_plot_LS{scale_str}{date_str}.png')
-            elif self.optimizer == OptimizerType.LS_TV:
-                SavingFolder = os.path.join(self.saveDir, f'{self.SMatrix.shape[3]}_SCANS_SSIM_plot_LS_TV_Lambda_{self.lambda_reg}_LFactor_{self.L_Factor}{scale_str}{date_str}.png')
+            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.")
@@ -367,9 +353,6 @@ class AlgebraicRecon(Recon):
         # ----------------- Plotting -----------------
         _, axs = plt.subplots(1, 3, figsize=(15, 5))  # 1 row, 3 columns
 
-        # Normalization based on LAMBDA max
-        lambda_max = np.max(self.experiment.OpticImage.laser.intensity)
-
         # Left: Best reconstructed image (normalized)
         im0 = axs[0].imshow(best_recon, 
                             extent=(self.experiment.params.general['Xrange'][0], self.experiment.params.general['Xrange'][1], self.experiment.params.general['Zrange'][1], self.experiment.params.general['Zrange'][0]),
@@ -402,18 +385,19 @@ class AlgebraicRecon(Recon):
         if isSaving:
             now = datetime.now()    
             date_str = now.strftime("%Y_%d_%m_%y")
-            SavingFolder = os.path.join(self.saveDir, 'results', f'comparison_SSIM_BestANDLastRecon{date_str}.png')
+            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, ROI_mask = None, start=0, fin=None, step=10, save_path=None):
+    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.
         """
         if self.reconLaser is None or self.reconLaser == []:
             raise ValueError("Reconstructed laser is empty. Run reconstruction first.")
-        if isinstance(self.Laser,list) and len(self.Laser) == 1:
+        if isinstance(self.reconLaser, list) and len(self.reconLaser) == 1:
             raise ValueError("Reconstructed Image without tumor is a single frame. Run reconstruction with isSavingEachIteration=True to get a sequence of frames.")
         if self.reconPhantom is None or self.reconPhantom == []:
             raise ValueError("Reconstructed phantom is empty. Run reconstruction first.")
@@ -424,24 +408,21 @@ class AlgebraicRecon(Recon):
             fin = len(self.reconPhantom) - 1
 
         iter_range = self.indices
+        
+        if self.CRC is None:
+            self.calculateCRC(use_ROI=use_ROI)
 
-        crc_values = []
         noise_values = []
 
         for i in iter_range:
             recon_without_tumor = self.reconLaser[i].T
-
-            # CRC
-            crc = self.calculateCRC(iteration=i,ROI_mask=ROI_mask)
-            crc_values.append(crc)
-
             # Noise
             noise = np.mean(np.abs(recon_without_tumor - self.experiment.OpticImage.laser.intensity))
             noise_values.append(noise)
 
         plt.figure(figsize=(6, 5))
-        plt.plot(noise_values, crc_values, 'o-', label='ML-EM')
-        for i, (x, y) in zip(iter_range, zip(noise_values, crc_values)):
+        plt.plot(noise_values, self.CRC, 'o-', label=self.optimizer.name)
+        for i, (x, y) in zip(iter_range, zip(noise_values, self.CRC)):
             plt.text(x, y, str(i), fontsize=5.5, ha='left', va='bottom')
 
         plt.xlabel("Noise (mean absolute error)")
@@ -453,13 +434,16 @@ class AlgebraicRecon(Recon):
         plt.title("CRC vs Noise over Iterations")
         plt.grid(True)
         plt.legend()
-
-        if save_path:
-            plt.savefig(save_path, dpi=300)
-            print(f"Figure saved to: {save_path}")
+        if isSaving:
+            now = datetime.now()    
+            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)
+            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.
@@ -564,114 +548,303 @@ 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()
 
-    def save(self, withTumor=True):
+    def checkExistingFile(self, date = None):
         """
-        Save the reconstruction results (reconPhantom is with tumor, reconLaser is without tumor) and indices of the saved recon results, in format numpy.
-        Warnings : reconPhantom and reconLaser are lists of 2D numpy arrays, each array corresponding to one iteration.
+        Check if the reconstruction file already exists, based on current instance parameters.
+
+        Args:
+            withTumor (bool): If True, checks reconPhantom.npy; otherwise, checks reconLaser.npy.
+            overwrite (bool): If False, returns False if the file exists.
+
+        Returns:
+            tuple: (bool: whether to save, str: the filepath)
         """
         if self.saveDir is None:
-            raise ValueError("Save directory is not specified. Please set saveDir before saving.")
-        if withTumor:
-            if not self.reconPhantom or len(self.reconPhantom) == 0:
-                raise ValueError("Reconstructed phantom is empty. Run reconstruction first.")
-            np.save(os.path.join(self.saveDir, 'results', 'reconPhantom.npy'), np.array(self.reconPhantom))
-        else:
-            if not self.reconLaser or len(self.reconLaser) == 0:
-                raise ValueError("Reconstructed laser is empty. Run reconstruction first.")
-            np.save(os.path.join(self.saveDir, 'results', 'reconLaser.npy'), np.array(self.reconLaser))
-        np.save(os.path.join(self.saveDir, 'results', 'reconIndices.npy'), np.array(self.indices))
-        print(f"Reconstruction results saved to {os.path.join(self.saveDir, 'results')}")
+            raise ValueError("Save directory is not specified.")
+        if date is None:
+            date = datetime.now().strftime("%d%m")
+        results_dir = os.path.join(self.saveDir, f'results_{date}_{self.optimizer.value}')
+        if not os.path.exists(results_dir):
+            os.makedirs(results_dir)
 
-    def load(self, withTumor=True):
+        if os.path.exists(os.path.join(results_dir,"indices.npy")):
+            return (True, results_dir)
+
+        return (False, results_dir)
+
+    def load(self, withTumor=True, results_date=None, optimizer=None, filePath=None, show_logs=True):
         """
-        Load the reconstruction results (reconPhantom is with tumor, reconLaser is without tumor) and indices of the saved recon results, in format numpy.
-        Warnings : reconPhantom and reconLaser are lists of 2D numpy arrays, each array corresponding to one iteration.
+        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.
+        Args:
+            withTumor: If True, loads reconPhantom (with tumor), else reconLaser (without tumor).
+            results_date: Date string (format "ddmm") to specify which results to load. If None, uses the most recent date in saveDir.
+            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).
         """
-        if self.saveDir is None:
-            raise ValueError("Save directory is not specified. Please set saveDir before loading.")
-        if withTumor:
-            recon_path = os.path.join(self.saveDir, 'results', 'reconPhantom.npy')
-            if not os.path.isfile(recon_path):
-                raise FileNotFoundError(f"Reconstructed phantom file not found: {recon_path}")
-            self.reconPhantom = list(np.load(recon_path, allow_pickle=True))
+        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:
-            recon_path = os.path.join(self.saveDir, 'results', 'reconLaser.npy')
-            if not os.path.isfile(recon_path):
-                raise FileNotFoundError(f"Reconstructed laser file not found: {recon_path}")
-            self.reconLaser = list(np.load(recon_path, allow_pickle=True))
-        indices_path = os.path.join(self.saveDir, 'results', 'reconIndices.npy')
-        if not os.path.isfile(indices_path):
-            raise FileNotFoundError(f"Reconstruction indices file not found: {indices_path}")
-        self.indices = list(np.load(indices_path, allow_pickle=True))
-        print(f"Reconstruction results loaded from {os.path.join(self.saveDir, 'results')}")
-
+            # 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 / (self.experiment.params.acoustic['voltage']*self.experiment.params.acoustic['sensitivity'])
+        self.SMatrix = self.SMatrix / (float(self.experiment.params.acoustic['voltage'])*float(self.experiment.params.acoustic['sensitivity']))  
 
     # PRIVATE METHODS
 
-    def _AlgebraicReconPython(self,withTumor):
+    def _fillDenseSMatrix(self):
+        """
+        Construit une matrice dense en mémoire.
+        """
+        T, Z, X = self.experiment.AcousticFields[0].field.shape
+        N = len(self.experiment.AcousticFields)
+        S = np.empty((T, Z, X, N), dtype=np.float32)
+        def copy_block(i):
+            np.copyto(S[..., i], self.experiment.AcousticFields[i].field)
+        with concurrent.futures.ThreadPoolExecutor() as ex:
+            ex.map(copy_block, range(N))
+        return S
+    
+            
+    def _fillSparseSMatrix(self, isShowLogs=True):
+        if self.smatrixType == SMatrixType.CSR:
+            return self._fillSparseSMatrix_CSR(isShowLogs=isShowLogs)
+        if self.smatrixType == SMatrixType.COO:
+            raise NotImplementedError("COO sparse matrix not implemented yet.")
+        if self.smatrixType == SMatrixType.SELL:
+            return self._fillSparseSMatrix_SELL(isShowLogs=isShowLogs)
+    
+    def _fillSparseSMatrix_CSR(self, isShowLogs=True):
+        """
+        Construit une matrice sparse CSR par morceaux sans concaténation intermédiaire.
+        Libère toute la mémoire temporaire à chaque étape.
+        """
+        sparse_matrix = SparseSMatrix_CSR(self.experiment,relative_threshold=self.sparseThreshold)
+        sparse_matrix.allocate()
+        if isShowLogs:
+            print(f" Sparse matrix size: {sparse_matrix.getMatrixSize()} GB")
+            print(f"Sparse matrix density: {sparse_matrix.compute_density()}")
+        return sparse_matrix
+    
+    def _fillSparseSMatrix_SELL(self, isShowLogs=True):
+        """
+        Construit une matrice sparse SELL par morceaux sans concaténation intermédiaire.
+        Libère toute la mémoire temporaire à chaque étape.
+        """
+        sparse_matrix = SparseSMatrix_SELL(self.experiment,relative_threshold=self.sparseThreshold)
+        sparse_matrix.allocate()
+        # fenetre_gpu = get_apodization_vector_gpu(sparse_matrix)
+        # sparse_matrix.apply_apodization_gpu(fenetre_gpu)
+        if isShowLogs:
+            print(f" Sparse matrix size: {sparse_matrix.getMatrixSize()} GB")
+            print(f"Sparse matrix density: {sparse_matrix.compute_density()}")
+        return sparse_matrix
+        
+    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.")
-            if self.optimizer.value == OptimizerType.MLEM.value:
-                self.reconPhantom, self.indices = self._MLEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
-            elif self.optimizer.value == OptimizerType.LS.value:
-                self.reconPhantom, self.indices = self._LS(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
-            elif self.optimizer.value == OptimizerType.LS_TV.value:
-                self.reconPhantom, self.indices = self._LS_Regularized(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
-            else:
-                raise ValueError(f"Only MLEM and LS are supported for simple algebraic reconstruction. {self.optimizer.value} need Bayesian reconstruction")
         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.")
-            if self.optimizer.value == OptimizerType.MLEM.value:
-                self.reconLaser, self.indices = self._MLEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
-            elif self.optimizer.value == OptimizerType.LS.value:
-                self.reconLaser, self.indices = self._LS(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
-            elif self.optimizer.value == OptimizerType.LS_TV.value:
-                self.reconLaser, self.indices = self._LS_Regularized(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
-            else:
-                raise ValueError(f"Only MLEM and LS are supported for simple algebraic reconstruction. {self.optimizer.value} need Bayesian reconstruction")
 
-    def _AlgebraicReconCASToR(self, withTumor):
-        
-        # Define variables
-        smatrix = os.path.join(self.saveDir,"system_matrix")
+        if self.optimizer.value == OptimizerType.MLEM.value:
+            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,
+                                                        smatrixType=self.smatrixType,
+                                                        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,
+                                                        smatrixType=self.smatrixType,
+                                                        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.")
+            if withTumor:
+                self.reconPhantom, self.indices = LS(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,
+                                                        smatrixType=self.smatrixType,
+                                                        Z=self.Z_dim
+                                                )
+            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,
+                                                        device=self.device,
+                                                        use_numba=self.isMultiCPU,
+                                                        denominator_threshold=self.denominatorThreshold,
+                                                        max_saves=self.maxSaves,
+                                                        show_logs=show_logs,
+                                                        smatrixType=self.smatrixType,
+                                                        Z=self.Z_dim
+                                                )
+        else:
+            raise ValueError(f"Only MLEM and LS are supported for simple algebraic reconstruction. {self.optimizer.value} need Bayesian reconstruction")
 
+    def _AlgebraicReconCASToR(self,withTumor, show_logs):
+        # Définir les chemins
+        smatrix = os.path.join(self.saveDir, "system_matrix")
         if withTumor:
             fileName = 'AOSignals_withTumor.cdh'
         else:
             fileName = 'AOSignals_withoutTumor.cdh'
 
-        # Check if input file exists
-        if not os.path.isfile(f"{self.saveDir}/{fileName}"):
-            self.experiment._saveAOsignals_Castor(self.saveDir)
-        # Check if system matrix directory exists
-        elif not os.path.isdir(smatrix):
-            os.mkdir(smatrix)
-        # check if system matrix is empty
-        elif not os.listdir(smatrix):
+        # 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)):
+            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):
+            if show_logs:
+                print("Matrice système manquante. Génération...")
             self.experiment.saveAcousticFields(self.saveDir)
 
-        # Vérifier que le dossier de sortie existe
-        os.makedirs(os.path.join(self.saveDir, 'results','recon'), exist_ok=True)
+        # Vérifier que le fichier .cdh existe (redondant mais sûr)
+        if not os.path.isfile(os.path.join(self.saveDir, fileName)):
+            raise FileNotFoundError(f"Le fichier .cdh n'existe toujours pas : {fileName}")
 
-        # Vérifier que le fichier .cdh existe
-        if not os.path.isfile(fileName):
-            raise FileNotFoundError(f"Le fichier .cdh n'existe pas : {fileName}")
+        # Créer le dossier de sortie
+        os.makedirs(os.path.join(self.saveDir, 'results', 'recon'), exist_ok=True)
 
-        # Créer une copie de l'environnement actuel et ajouter les variables CAStOR
+        # Configuration de l'environnement pour CASToR
         env = os.environ.copy()
-
         env.update({
-            "CASTOR_DIR": f"{self.experiment.params.reconstruction['castor_executable']}",
-            "CASTOR_CONFIG": f"{self.experiment.params.reconstruction['castor_executable']}/config",
+            "CASTOR_DIR": self.experiment.params.reconstruction['castor_executable'],
+            "CASTOR_CONFIG": os.path.join(self.experiment.params.reconstruction['castor_executable'], "config"),
             "CASTOR_64bits": "1",
             "CASTOR_OMP": "1",
             "CASTOR_SIMD": "1",
@@ -680,13 +853,13 @@ class AlgebraicRecon(Recon):
 
         # Construire la commande
         cmd = [
-            f"{self.experiment.params.reconstruction['castor_executable']}/bin/castor-recon",
-            "-df",  f"{self.saveDir}/{fileName}",
+            os.path.join(self.experiment.params.reconstruction['castor_executable'], "bin", "castor-recon"),
+            "-df", os.path.join(self.saveDir, fileName),
             "-opti", self.optimizer.value,
             "-it", f"{self.numIterations}:{self.numSubsets}",
             "-proj", "matrix",
-            "-dout", os.path.join(self.saveDir, 'results','recon'),
-            "-th", f"{ os.cpu_count()}",
+            "-dout", os.path.join(self.saveDir, 'results', 'recon'),
+            "-th", str(os.cpu_count()),
             "-vb", "5",
             "-proj-comp", "1",
             "-ignore-scanner",
@@ -695,90 +868,38 @@ class AlgebraicRecon(Recon):
             "-system-matrix", smatrix,
         ]
 
-        # Print the command
-        print(" ".join(cmd))
+        # Afficher la commande (pour débogage)
+        if show_logs:
+            print("Commande CASToR :")
+            print(" ".join(cmd))
 
-        #save the command to a script file
+        # Chemin du script temporaire
         recon_script_path = os.path.join(gettempdir(), 'recon.sh')
+
+        # Écrire le script bash
         with open(recon_script_path, 'w') as f:
             f.write("#!/bin/bash\n")
+            f.write(f"export PATH={env['CASTOR_DIR']}/bin:$PATH\n")  # Ajoute le chemin de CASToR au PATH
+            f.write(f"export LD_LIBRARY_PATH={env['CASTOR_DIR']}/lib:$LD_LIBRARY_PATH\n")  # Ajoute les bibliothèques si nécessaire
             f.write(" ".join(cmd) + "\n")
 
-        sys.exit(0)
-
-        # --- Run Reconstruction Script ---
-        print(f"Running reconstruction script: {recon_script_path}")
+        # Rendre le script exécutable et l'exécuter
         subprocess.run(["chmod", "+x", recon_script_path], check=True)
-        subprocess.run([recon_script_path], check=True)
-        print("Reconstruction script executed.")
-
+        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)
+        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)
-
-    def _MLEM(self, SMatrix, y, withTumor):
-        """
-        This method implements the MLEM algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU mode is disabled due to memory fragmentation issues or lack of availability.
-        """
-        result = None
-        indices = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                result, indices = MLEM._MLEM_GPU_basic(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU MLEM. Falling back to CPU.")
-
-        if result is None and self.isMultiCPU:
-            result, indices = MLEM._MLEM_CPU_multi(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-
-        if result is None:
-            result, indices = MLEM._MLEM_CPU_opti(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            if result is None:
-                warnings.warn("Optimized MLEM failed. Falling back to basic CPU MLEM.")
-                result, indices = MLEM._MLEM_CPU_basic(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-
-        return result, indices
-    
-    def _LS(self, SMatrix, y, withTumor):
-        """
-        This method implements the LS algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU mode is disabled due to memory fragmentation issues or lack of availability.
-        """
-        result = None
-        indices = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                result, indices = LS._LS_GPU_basic(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU LS. Falling back to CPU.")
-
-        if result is None and self.isMultiCPU:
-            result, indices = LS._LS_CPU_multi(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-
-        if result is None:
-            result, indices = LS._LS_CPU_opti(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            if result is None:
-                warnings.warn("Optimized LS failed. Falling back to basic CPU LS.")
-                result, indices = LS._LS_CPU_basic(SMatrix=SMatrix, y=y, numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-
-        return result, indices
-
-    def _LS_Regularized(self,SMatrix, y, withTumor):
-        result = None
-        indices = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if check_gpu_memory(config.select_best_gpu(), required_memory):
-            if self.lambda_reg is None or self.L_Factor is None:
-                raise ValueError("For LS with TV regularization, both lambda_reg and L_Factor must be specified.")
-            result, indices = LS._LS_TV_GPU(SMatrix= SMatrix, y=y,  numIterations=self.numIterations, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor, lambda_tv=self.lambda_reg, L_Factor=self.L_Factor)
-        else:
-            warnings.warn("Insufficient GPU memory for single GPU LS with TV regularization. Falling back to CPU.")
-            raise NotImplementedError("LS with TV regularization is not implemented for CPU.")
-        return result, indices
     
     # STATIC METHODS
     @staticmethod