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

AOT_biomaps/AOT_Recon/AnalyticRecon.py

@@ -21,6 +21,9 @@ class AnalyticRecon(Recon):
             self._analyticReconPython(withTumor)
         else:
             raise ValueError(f"Unknown analytic reconstruction type: {processType}")
+        
+    def checkExistingFile(self, date = None):
+        raise NotImplementedError("checkExistingFile method is not implemented yet.")
 
     def _analyticReconPython(self,withTumor):
         """
@@ -48,56 +51,41 @@ class AnalyticRecon(Recon):
     def _iFourierRecon(self, AOsignal):
         """
         Reconstruction d'image utilisant la transformation de Fourier inverse.
-
-        :param AOsignal: Signal dans le domaine temporel.
+        :param AOsignal: Signal dans le domaine temporel (shape: N_t, N_theta).
         :return: Image reconstruite dans le domaine spatial.
         """
-        # Signal dans le domaine fréquentiel (FFT sur l'axe temporel)
-        s_tilde = np.fft.fft(AOsignal, axis=0)
-
-        theta = np.array([af.angle for af in self.experiment.AcousticFields])  # angles (N_theta,)
-        f_s = np.array([af.f_s for af in self.experiment.AcousticFields])  # spatial freqs (N_theta,)
-        f_t = np.fft.fftfreq(AOsignal.shape[0], d=self.experiment.dt)  # temporal freqs
-
+        theta = np.array([af.angle for af in self.experiment.AcousticFields])
+        f_s = np.array([af.f_s for af in self.experiment.AcousticFields])
+        dt = self.experiment.dt
+        f_t = np.fft.fftfreq(AOsignal.shape[0], d=dt)  # fréquences temporelles
         x = self.experiment.OpticImage.laser.x
         z = self.experiment.OpticImage.laser.z
-        X, Z = np.meshgrid(x, z, indexing='ij')  # shape (Nx, Nz)
-
-        N_theta = len(theta)
-        I_rec = np.zeros((len(x), len(z)), dtype=complex)
-
-        for i, th in enumerate(trange(N_theta, desc="AOT-BioMaps -- Analytic Recontruction Tomography : iFourier (Processing projection) ---- processing on single CPU ----")):
-            fs = f_s[i]
-
-            # Projection des coordonnées dans le repère tourné
-            x_prime = X * np.cos(th) + Z * np.sin(th)
-            z_prime = -X * np.sin(th) + Z * np.cos(th)
+        X, Z = np.meshgrid(x, z, indexing='ij')  # grille spatiale (Nx, Nz)
 
-            # Signal spectral pour cet angle (1D pour chaque f_t)
-            s_angle = s_tilde[:, i]  # shape (len(f_t),)
+        # Transformée de Fourier du signal
+        s_tilde = np.fft.fft(AOsignal, axis=0)  # shape: (N_t, N_theta)
 
-            # Grille 2D des fréquences
-            F_t, F_s = np.meshgrid(f_t, [fs], indexing='ij')  # F_t: (len(f_t), 1), F_s: (1, 1)
-
-            # Phase : exp(2iπ(x' f_s + z' f_t)) = (x_prime * f_s + z_prime * f_t)
-            phase = 2j * np.pi * (x_prime[:, :, None] * fs + z_prime[:, :, None] * f_t[None, None, :])
-
-            # reshape s_angle to (len(f_t), 1, 1)
-            s_angle = s_angle[:, None, None]
-
-            # Contribution de cet angle
-            integrand = s_angle * np.exp(phase)
-
-            # Intégration sur f_t (somme discrète)
-            I_theta = np.sum(integrand, axis=0)
-
-            # Ajout à la reconstruction
-            I_rec += I_theta
-
-        I_rec /= N_theta
+        # Initialisation de l'image reconstruite
+        I_rec = np.zeros((len(x), len(z)), dtype=complex)
 
+        # Boucle sur les angles
+        for i, th in enumerate(trange(len(theta), desc="AOT-BioMaps -- iFourier Reconstruction")):
+            # Coordonnées tournées
+            X_prime = X * np.cos(th) + Z * np.sin(th)
+            Z_prime = -X * np.sin(th) + Z * np.cos(th)
+
+            # Pour chaque fréquence temporelle f_t[j]
+            for j in range(len(f_t)):
+                # Phase: exp(2jπ (X_prime * f_s[i] + Z_prime * f_t[j]))
+                phase = 2j * np.pi * (X_prime * f_s[i] + Z_prime * f_t[j])
+                # Contribution de cette fréquence
+                I_rec += s_tilde[j, i] * np.exp(phase) * dt  # Pondération par dt pour l'intégration
+
+        # Normalisation
+        I_rec /= len(theta)
         return np.abs(I_rec)
 
+
     def _iRadonRecon(self, AOsignal):
         """
         Reconstruction d'image utilisant la méthode iRadon.

AOT_biomaps/AOT_Recon/BayesianRecon.py

@@ -1,11 +1,13 @@
 from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
 from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, OptimizerType, PotentialType, ProcessType
 from .ReconTools import check_gpu_memory, calculate_memory_requirement
-from .AOT_Optimizers import MAPEM, DEPIERRO
+from .AOT_Optimizers import MAPEM, MAPEM_STOP, DEPIERRO
 from AOT_biomaps.Config import config
 
 import warnings
 import numpy as np
+import os
+from datetime import datetime
 
 class BayesianRecon(AlgebraicRecon):
     """
@@ -36,7 +38,146 @@ class BayesianRecon(AlgebraicRecon):
         if not isinstance(self.potentialFunction, PotentialType):
             raise TypeError(f"Potential functions must be of type PotentialType, got {type(self.potentialFunction)}")  
 
-    def run(self, processType=ProcessType.PYTHON, withTumor=True):
+    def checkExistingFile(self, date = None):
+        """
+        Check if the reconstruction file already exists, based on current instance parameters.
+
+        Args:
+            withTumor (bool): If True, checks the phantom file; otherwise, checks the laser file.
+            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.")
+
+        # Construction du chemin du fichier
+        if date is None:
+            date = datetime.now().strftime("%d%m")
+
+        opt_name = self.optimizer.value
+        pot_name = self.potentialFunction.value
+        dir_name = f'results_{date}_{opt_name}_{pot_name}'
+
+        if self.optimizer == OptimizerType.PPGMLEM:
+            dir_name += f'_Beta_{self.beta}_Delta_{self.delta}_Gamma_{self.gamma}_Sigma_{self.sigma}'
+        elif self.optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
+            dir_name += f'_Beta_{self.beta}_Sigma_{self.sigma}'
+
+        results_dir = os.path.join(self.saveDir, dir_name)
+        if not os.path.exists(results_dir):
+            os.makedirs(results_dir)
+
+        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, potential_function=None, filePath=None, show_logs=True):
+        """
+        Load the reconstruction results and indices as lists of 2D np arrays for Bayesian reconstruction and store them in self.
+        If the loaded file is a 3D array, it is split into a list of 2D arrays.
+        """
+        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
+            pot_name = potential_function.value if potential_function is not None else self.potentialFunction.value
+            # Build the base directory pattern
+            dir_pattern = f'results_*_{opt_name}_{pot_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}_{pot_name}')
+                if optimizer == OptimizerType.PPGMLEM:
+                    results_dir += f'_Beta_{self.beta}_Delta_{self.delta}_Gamma_{self.gamma}_Sigma_{self.sigma}'
+                elif optimizer in (OptimizerType.PGC, OptimizerType.DEPIERRO95):
+                    results_dir += f'_Beta_{self.beta}_Sigma_{self.sigma}'
+                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 run(self, processType=ProcessType.PYTHON, withTumor=True, show_logs=True):
         """
         This method is a placeholder for the Bayesian reconstruction process.
         It currently does not perform any operations but serves as a template for future implementations.
@@ -48,109 +189,42 @@ class BayesianRecon(AlgebraicRecon):
         else:
             raise ValueError(f"Unknown Bayesian reconstruction type: {processType}")
         
-    def _bayesianReconCASToR(self, withTumor):
+    def _bayesianReconCASToR(self, show_logs, withTumor):
         raise NotImplementedError("CASToR Bayesian reconstruction is not implemented yet.")
 
-    def _bayesianReconPython(self, withTumor):
-
+    def _bayesianReconPython(self, show_logs, withTumor):
         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.PPGMLEM.value:
-                self.reconPhantom = self._MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = MAPEM_STOP(
+                    SMatrix=self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    Omega=self.potentialFunction,
+                    beta=self.beta,
+                    delta=self.delta,
+                    gamma=self.gamma,
+                    sigma=self.sigma,
+                    numIterations=self.numIterations,
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    withTumor=withTumor,
+                    device=self.device,
+                    max_saves=5000,
+                    show_logs=True)
             elif self.optimizer.value == OptimizerType.PGC.value:
-                self.reconPhantom = self._MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.DEPIERRO95.value:
-                self.reconPhantom = self._DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
+                self.reconPhantom, self.indices = DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor, show_logs=show_logs)
             else:
                 raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")
         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.PPGMLEM.value:
-                self.reconLaser = self._MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
+                self.reconLaser, self.indices = MAPEM_STOP(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.PGC.value:
-                self.reconLaser = self._MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
+                self.reconLaser, self.indices = MAPEM(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             elif self.optimizer.value == OptimizerType.DEPIERRO95.value:
-                self.reconLaser = self._DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
-            else:
-                raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")
-
-    def _MAPEM_STOP(self, SMatrix, y, withTumor):
-        """
-        This method implements the MAPEM_STOP algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = MAPEM._MAPEM_GPU_STOP(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU MAPEM_STOP. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = MAPEM._MAPEM_CPU_STOP(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
-    def _MAPEM(self, SMatrix, y, withTumor):
-        """
-        This method implements the MAPEM algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = MAPEM._MAPEM_GPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
+                self.reconLaser, self.indices = DEPIERRO(SMatrix=self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor, show_logs=show_logs)
             else:
-                warnings.warn("Insufficient GPU memory for single GPU MAPEM. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = MAPEM._MAPEM_CPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, delta=self.delta, gamma=self.gamma, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
-    def _DEPIERRO(self, SMatrix, y, withTumor):
-        """
-        This method implements the DEPIERRO algorithm using either CPU or single-GPU PyTorch acceleration.
-        Multi-GPU and Multi-CPU modes are not implemented for this algorithm.
-        """
-        result = None
-        required_memory = calculate_memory_requirement(SMatrix, y)
-
-        if self.isGPU:
-            if check_gpu_memory(config.select_best_gpu(), required_memory):
-                try:
-                    result = DEPIERRO._DEPIERRO_GPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                except Exception as e:
-                    warnings.warn(f"Falling back to CPU implementation due to an error in GPU implementation: {e}")
-            else:
-                warnings.warn("Insufficient GPU memory for single GPU DEPIERRO. Falling back to CPU.")
-
-        if result is None:
-            try:
-                result = DEPIERRO._DEPIERRO_CPU(SMatrix=SMatrix, y=y, Omega=self.potentialFunction, numIterations=self.numIterations, beta=self.beta, sigma=self.sigma, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            except Exception as e:
-                warnings.warn(f"An error occurred in CPU implementation: {e}")
-                result = None
-
-        return result
-
+                raise ValueError(f"Unknown optimizer type: {self.optimizer.value}")

AOT_biomaps/AOT_Recon/DeepLearningRecon.py

@@ -29,4 +29,7 @@ class DeepLearningRecon(Recon):
         pass
 
     def _deepLearningReconPython(self):
-        pass
+        pass
+
+    def checkExistingFile(self, date = None):
+        raise NotImplementedError("checkExistingFile method is not implemented yet.")

AOT_biomaps/AOT_Recon/PrimalDualRecon.py

@@ -1,19 +1,23 @@
 from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
-from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType, NoiseType
-from AOT_biomaps.AOT_Recon.AOT_Optimizers.PDHG import chambolle_pock_TV_cpu, chambolle_pock_TV_gpu, chambolle_pock_KL_cpu, chambolle_pock_KL_gpu
+from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType
+from AOT_biomaps.AOT_Recon.AOT_Optimizers import CP_KL, CP_TV
+from AOT_biomaps.AOT_Recon.ReconEnums import OptimizerType
+
+import os
+from datetime import datetime
+import numpy as np
+import re
 
 class PrimalDualRecon(AlgebraicRecon):
     """
     This class implements the convex reconstruction process.
     It currently does not perform any operations but serves as a template for future implementations.
     """
-    def __init__(self, alpha, theta=1.0, L=None, noiseModel = NoiseType.GAUSSIAN,**kwargs):
+    def __init__(self, theta=1.0, L=None, **kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Convex
-        self.alpha = alpha # regularization parameter
         self.theta = theta # relaxation parameter (between 1 and 2)
         self.L = L # norme spectrale de l'opérateur linéaire défini par les matrices P et P^T
-        self.noiseModel = noiseModel
 
     def run(self, processType=ProcessType.PYTHON, withTumor=True):
         """
@@ -28,37 +32,177 @@ class PrimalDualRecon(AlgebraicRecon):
             raise ValueError(f"Unknown convex reconstruction type: {processType}")
 
     def _convexReconCASToR(self, withTumor):
-        pass
+        raise NotImplementedError("CASToR convex reconstruction is not implemented yet.")
 
-    def _convexReconPython(self, withTumor):
-        if withTumor:
-            self.reconPhantom = self._chambolle_pock(self.SMatrix, y=self.experiment.AOsignal_withTumor, withTumor=withTumor)
-        else:
-            self.reconLaser = self._chambolle_pock(self.SMatrix, y=self.experiment.AOsignal_withoutTumor, withTumor=withTumor)
-    
-    def _chambolle_pock(self, SMatrix, y, withTumor):
-        if self.isGPU:
-            try:
-                if self.noiseModel == NoiseType.GAUSSIAN:
-                    return chambolle_pock_TV_gpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                elif self.noiseModel == NoiseType.POISSON:
-                    return chambolle_pock_KL_gpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
+
+    def checkExistingFile(self, date = None):
+        """
+        Check if the file already exists, based on current instance parameters.
+        Returns:
+            tuple: (bool: whether to save, str: the filepath)
+        """
+        if date is None:
+            date = datetime.now().strftime("%d%m")
+        results_dir = os.path.join(
+            self.saveDir,
+            f'results_{date}_{self.optimizer.value}_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
+        )
+        os.makedirs(results_dir, exist_ok=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 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 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:
+                # Sinon, suppose que c'est déjà une liste de 2D
+                if withTumor:
+                    self.reconPhantom = data
                 else:
-                    raise ValueError(f"Noise model must be either GAUSSIAN or POISSON, got {self.noiseModel}")
-            except:
-                if self.noiseModel == NoiseType.GAUSSIAN:
-                    return chambolle_pock_TV_cpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-                elif self.noiseModel == NoiseType.POISSON:
-                    return chambolle_pock_KL_cpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
+                    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:
-                    raise ValueError(f"Noise model must be either GAUSSIAN or POISSON, got {self.noiseModel}")
+                    self.indices = indices_data
+            else:
+                self.indices = None
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {recon_path}")
         else:
-            if self.noiseModel == NoiseType.GAUSSIAN:
-                return chambolle_pock_TV_cpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
-            elif self.noiseModel == NoiseType.POISSON:
-                return chambolle_pock_KL_cpu(SMatrix=SMatrix, y=y, alpha=self.alpha, theta=self.theta, numIterations=self.numIterations, L=self.L, isSavingEachIteration=self.isSavingEachIteration, withTumor=withTumor)
+            # 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
+            dir_pattern = f'results_*_{opt_name}'
+            if opt_name == OptimizerType.CP_TV.value or opt_name == OptimizerType.CP_KL.value:
+                dir_pattern += f'_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
+            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 opt_name == OptimizerType.CP_TV.value or opt_name == OptimizerType.CP_KL.value:
+                    results_dir += f'_Alpha_{self.alpha}_Theta_{self.theta}_L_{self.L}'
+                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:
-                raise ValueError(f"Noise model must be either GAUSSIAN or POISSON, got {self.noiseModel}")
+                self.indices = None
+            if show_logs:
+                print(f"Loaded reconstruction results and indices from {results_dir}")
+
+    def _convexReconPython(self, withTumor):
+        if self.optimizer == OptimizerType.CP_TV:
+            if withTumor:
+                self.reconPhantom, self.indices = CP_TV(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                    )
+            else:
+                self.reconLaser, self.indices = CP_TV(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withoutTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                    )
+        elif self.optimizer == OptimizerType.CP_KL:
+            if withTumor:
+                self.reconPhantom, self.indices = CP_KL(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                )
+            else:
+                self.reconLaser, self.indices = CP_KL(
+                    self.SMatrix, 
+                    y=self.experiment.AOsignal_withoutTumor, 
+                    alpha=self.alpha, 
+                    theta=self.theta, 
+                    numIterations=self.numIterations, 
+                    isSavingEachIteration=self.isSavingEachIteration,
+                    L=self.L, 
+                    withTumor=withTumor,
+                    device=None
+                )
+        else:
+            raise ValueError(f"Optimizer value must be CP_TV or CP_KL, got {self.optimizer}")
+