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

AOT_biomaps/AOT_Experiment/Tomography.py

@@ -7,6 +7,8 @@ import psutil
 import numpy as np
 import matplotlib.pyplot as plt
 from tqdm import trange
+import h5py
+from scipy.io import loadmat
 
 class Tomography(Experiment):
     def __init__(self, **kwargs):
@@ -433,3 +435,71 @@ class Tomography(Experiment):
             listAcousticFields.append(AcousticField)
             progress_bar.set_postfix_str("")
         return listAcousticFields
+
+    def load_experimentalAO(self, pathAO, withTumor = True, h5name='AOsignal'):
+        """
+        Load experimental AO signals from specified file paths.
+        Args:
+            path_withTumor: Path to the AO signal with tumor.
+            path_withoutTumor: Path to the AO signal without tumor.
+        """
+        if not os.path.exists(pathAO):
+            raise FileNotFoundError(f"File {pathAO} not found.")
+
+        if pathAO.endswith('.npy'):
+            ao_signal = np.load(pathAO)
+        elif pathAO.endswith('.h5'):
+            with h5py.File(pathAO, 'r') as f:
+                if h5name not in f:
+                    raise KeyError(f"Dataset '{h5name}' not found in the HDF5 file.")
+                ao_signal = f[h5name][:]
+        elif pathAO.endswith('.mat'):
+            mat_data = loadmat(pathAO)
+            if h5name not in mat_data:
+                raise KeyError(f"Dataset '{h5name}' not found in the .mat file.")
+            ao_signal = mat_data[h5name]
+        elif pathAO.endswith('.hdr'):
+            ao_signal = self._loadAOSignal(pathAO)
+        else:
+            raise ValueError("Unsupported file format. Supported formats are: .npy, .h5, .mat, .hdr")
+        
+        if withTumor:
+            self.AOsignal_withTumor = ao_signal
+        else:
+            self.AOsignal_withoutTumor = ao_signal
+
+    def check_experimentalAO(self, activeListPath, withTumor=True):
+        """
+        Check if the experimental AO signals are correctly initialized.
+        """
+        if withTumor:
+            if self.AOsignal_withTumor is None:
+                raise ValueError("Experimental AOsignal with tumor is not initialized. Please load the experimental AO signal with tumor first.")
+        else:
+            if self.AOsignal_withoutTumor is None:
+                raise ValueError("Experimental AOsignal without tumor is not initialized. Please load the experimental AO signal without tumor first.")
+        if self.AcousticFields is not None:
+            # get min time shape between all AO signals
+            print()
+            
+            if self.AcousticFields[0].field.shape[0] > self.AOsignal_withTumor.shape[0]:
+                self.cutAcousticFields(max_t=self.AOsignal_withTumor.shape[0]/float(self.params.acoustic['f_saving']))
+            else:
+                for i in range(len(self.AcousticFields)):
+                    min_time_shape = min(self.AcousticFields[i].field.shape[0])
+                if withTumor:
+                    self.AOsignal_withTumor = self.AOsignal_withTumor[:min_time_shape, :]
+                else:
+                    self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:min_time_shape, :]
+
+            for field in self.AcousticFields:                        
+                if activeListPath is not None:
+                    with open(activeListPath, 'r') as file:
+                        lines = file.readlines()
+                        expected_name = lines[self.AcousticFields.index(field)].strip()
+                        nameField = field.getName_field()
+                        if nameField.startswith("field_"):
+                            nameField = nameField[len("field_"):]
+                        if nameField != expected_name:
+                            raise ValueError(f"Field name {nameField} does not match the expected name {expected_name} from the active list.")
+        print("Experimental AO signals are correctly initialized.")

AOT_biomaps/AOT_Experiment/_mainExperiment.py

@@ -77,7 +77,6 @@ class Experiment(ABC):
                 raise ValueError(f"Field {field.getName_field()} has an invalid shape: {field.field.shape}. Expected shape to be at least ({max_sample},).")
             self.AcousticFields[i].field = field.field[min_sample:max_sample, :, :]
 
-
     def addNoise(self, noiseType='gaussian', noiseLvl=0.1, withTumor=True):
         """
         Ajoute du bruit (gaussien ou poisson) au signal AO sélectionné.
@@ -290,28 +289,48 @@ class Experiment(ABC):
 
     @staticmethod
     def _loadAOSignal(AOsignalPath):
-        # if extension is .cdh load .cdf file
         if AOsignalPath.endswith(".cdh"):
             with open(AOsignalPath, "r") as file:
                 cdh_content = file.readlines()
-
-            n_events = int([line.split(":")[1].strip() for line in cdh_content if "Number of events" in line][0])
-            n_acquisitions = int([line.split(":")[1].strip() for line in cdh_content if "Number of acquisitions per event" in line][0])
-
-            AOsignal_matrix = np.zeros((n_events, n_acquisitions), dtype=np.float32)
-
-            with open(AOsignalPath.replace(".cdh", ".cdf"), "rb") as file:
-                for event in range(n_events):
-                    num_elements = int([line.split(":")[1].strip() for line in cdh_content if "Number of US transducers" in line][0])
-                    hex_length = (num_elements + 3) // 4
-                    file.read(hex_length // 2)
-
-                    signal = np.frombuffer(file.read(n_acquisitions * 4), dtype=np.float32)
-                    AOsignal_matrix[event, :] = signal
-
-            return AOsignal_matrix
-        if AOsignalPath.endswith(".npy"):
-            return np.load(AOsignalPath)
+            
+            cdf_path = AOsignalPath.replace(".cdh", ".cdf")
+
+            # Extraire les paramètres depuis le fichier .cdh
+            n_scans = int([line.split(":")[1].strip() for line in cdh_content if "Number of events" in line][0])
+            n_acquisitions_per_event = int([line.split(":")[1].strip() for line in cdh_content if "Number of acquisitions per event" in line][0])
+            num_elements = int([line.split(":")[1].strip() for line in cdh_content if "Number of US transducers" in line][0])
+
+            # Initialisation des structures
+            AO_signal = np.zeros((n_acquisitions_per_event, n_scans), dtype=np.float32)
+            active_lists = []
+            angles = []
+
+            # Lecture du fichier binaire
+            with open(cdf_path, "rb") as file:
+                for j in trange(n_scans, desc="Lecture des événements"):
+                    # Lire l'activeList : 48 caractères hex = 24 bytes
+                    active_list_bytes = file.read(24)
+                    active_list_hex = active_list_bytes.hex()
+                    active_lists.append(active_list_hex)
+
+                    # Lire l'angle (1 byte signé)
+                    angle_byte = file.read(1)
+                    angle = np.frombuffer(angle_byte, dtype=np.int8)[0]
+                    angles.append(angle)
+
+                    # Lire le signal AO (float32)
+                    data = np.frombuffer(file.read(n_acquisitions_per_event * 4), dtype=np.float32)
+                    if len(data) != n_acquisitions_per_event:
+                        raise ValueError(f"Erreur à l'événement {j} : attendu {n_acquisitions_per_event}, obtenu {len(data)}")
+                    AO_signal[:, j] = data
+
+            return AO_signal
+
+
+        elif AOsignalPath.endswith(".npy"):
+            return np.load(AOsignalPath)  # Supposé déjà au bon format
+        else:
+            raise ValueError("Format de fichier non supporté. Utilisez .cdh/.cdf ou .npy.")
 
     def saveAOsignals_Castor(self, save_directory, withTumor=True):
         if withTumor:
@@ -339,10 +358,10 @@ class Experiment(ABC):
         header_content = (
             f"Data filename: {'AOSignals_withTumor.cdf' if withTumor else 'AOSignals_withoutTumor.cdf'}\n"
             f"Number of events: {nScan}\n"
-            f"Number of acquisitions per event: {AO_signal.shape[1]}\n"
+            f"Number of acquisitions per event: {AO_signal.shape[0]}\n"
             f"Start time (s): 0\n"
             f"Duration (s): 1\n"
-            f"Acquisition frequency (Hz): {1/self.AcousticFields[0].kgrid.dt}\n"
+            f"Acquisition frequency (Hz): {self.params.acoustic['f_saving']}\n"
             f"Data mode: histogram\n"
             f"Data type: AOT\n"
             f"Number of US transducers: {self.params.acoustic['num_elements']}"

AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py

@@ -1,6 +1,8 @@
 from AOT_biomaps.AOT_Recon.ReconEnums import PotentialType
-from AOT_biomaps.AOT_Recon.ReconTools import _build_adjacency_sparse
+from AOT_biomaps.AOT_Recon.ReconTools import _build_adjacency_sparse, calculate_memory_requirement, check_gpu_memory
 from AOT_biomaps.Config import config
+
+import warnings
 import numpy as np
 import torch
 from tqdm import trange
@@ -11,9 +13,42 @@ if config.get_process() == 'gpu':
     except ImportError:
         raise ImportError("torch_scatter and torch_sparse are required for GPU processing. Please install them using 'pip install torch-scatter torch-sparse' with correct link (follow instructions https://github.com/LucasDuclos/AcoustoOpticTomography/edit/main/README.md).")
 
-def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, withTumor, max_saves=5000):
-    # Initialisation du device
-    device = torch.device(f"cuda:{config.select_best_gpu()}")
+def DEPIERRO(
+        SMatrix,
+        y, 
+        numIterations,
+        beta,
+        sigma,
+        isSavingEachIteration,
+        withTumor, 
+        max_saves, 
+        show_logs):
+        """
+        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.
+        """
+        try:
+            tumor_str = "WITH" if withTumor else "WITHOUT"
+            # Auto-select device and method
+            if device is None:
+                if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
+                    device = torch.device(f"cuda:{config.select_best_gpu()}")
+                    use_gpu = True
+                else:
+                    device = torch.device("cpu")
+                    use_gpu = False
+            else:
+                use_gpu = device.type == "cuda"
+            # Dispatch to the appropriate implementation
+            if use_gpu:
+                return _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs)
+            else:
+                return _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs)
+        except Exception as e:
+            print(f"Error in MLEM: {type(e).__name__}: {e}")
+            return None, None
+
+def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
     # Conversion des données en tenseurs PyTorch (float64)
     A_matrix_torch = torch.tensor(SMatrix, dtype=torch.float64, device=device)
     y_torch = torch.tensor(y, dtype=torch.float64, device=device)
@@ -33,7 +68,7 @@ def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration,
     # Construction de la matrice d'adjacence
     adj_index, adj_values = _build_adjacency_sparse(Z, X, device=device, dtype=torch.float64)
     # Description pour la barre de progression
-    description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()}"
+    description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()}"
     # Configuration pour la sauvegarde des itérations
     saved_indices = [0]
 
@@ -47,7 +82,8 @@ def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration,
             save_indices.append(numIterations - 1)
 
     # Boucle principale MAP-EM
-    for it in trange(numIterations, desc=description):
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for it in iterator:
         theta_p = matrix_theta_torch[-1]
         theta_p_flat = theta_p.reshape(-1)
         # Étape 1 : Projection avant
@@ -92,7 +128,7 @@ def _DEPIERRO_GPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration,
     else:
         return matrix_theta_torch[-1].cpu().numpy(), None
 
-def _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, withTumor, max_saves=5000):
+def _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
     try:
         if beta is None or sigma is None:
             raise ValueError("Depierro95 optimizer requires beta and sigma parameters.")
@@ -120,9 +156,10 @@ def _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration,
             if save_indices[-1] != numIterations - 1:
                 save_indices.append(numIterations - 1)
 
-        description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+        description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: DE PIERRO (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
 
-        for p in trange(numIterations, desc=description):
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
             theta_p = matrix_theta[-1]
             theta_p_flat = theta_p.reshape(-1)
             q_flat = np.dot(A_flat, theta_p_flat)
@@ -141,9 +178,9 @@ def _DEPIERRO_CPU(SMatrix, y, numIterations, beta, sigma, isSavingEachIteration,
             theta_p_plus_1_flat = np.clip(theta_p_plus_1_flat, a_min=0, a_max=None)
             theta_next = theta_p_plus_1_flat.reshape(Z, X)
             matrix_theta[-1] = theta_next
-            if isSavingEachIteration and p in save_indices:
+            if isSavingEachIteration and it in save_indices:
                 I_reconMatrix.append(theta_next.copy())
-                saved_indices.append(p)
+                saved_indices.append(it)
 
         if isSavingEachIteration:
             return I_reconMatrix, saved_indices

AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py

@@ -2,6 +2,7 @@ from AOT_biomaps.Config import config
 import torch
 import numpy as np
 from tqdm import trange
+from AOT_biomaps.AOT_Recon.ReconTools import calculate_memory_requirement, check_gpu_memory
 
 def LS(
     SMatrix,
@@ -12,6 +13,7 @@ def LS(
     withTumor=True,
     device=None,
     max_saves=5000,
+    show_logs=True
 ):
     """
     Least Squares reconstruction using Projected Gradient Descent (PGD) with non-negativity constraint.
@@ -20,15 +22,15 @@ def LS(
     tumor_str = "WITH" if withTumor else "WITHOUT"
     # Force GPU usage for now
     if device is None:
-        if not torch.cuda.is_available():
+        if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
             raise RuntimeError("CUDA is required for this implementation.")
         device = torch.device(f"cuda:{config.select_best_gpu()}")
     else:
         if device.type != "cuda":
             raise RuntimeError("Only GPU implementation is available for now.")
-    return _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves)
+    return _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves, show_logs=show_logs)
 
-def _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves=5000):
+def _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumor_str, max_saves=5000, show_logs=True):
     """
     Stable GPU implementation of LS using projected gradient descent with diagonal preconditioner.
     """
@@ -65,13 +67,14 @@ def _LS_GPU_stable(SMatrix, y, numIterations, alpha, isSavingEachIteration, tumo
     AT_r = torch.empty(ZX, device=device)
     description = f"AOT-BioMaps -- Stable LS Reconstruction ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
 
-    for k in trange(numIterations, desc=description):
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for it in iterator:
         # Calcul du résidu (inplace)
         torch.matmul(A_flat, lambda_k, out=r_k)
         r_k = y_flat - r_k
-        if isSavingEachIteration and k in save_indices:
+        if isSavingEachIteration and it in save_indices:
             lambda_history.append(lambda_k.clone().reshape(Z, X) * (norm_y / norm_A))
-            saved_indices.append(k)
+            saved_indices.append(it)
 
         # Gradient préconditionné (inplace)
         torch.matmul(A_flat.T, r_k, out=AT_r)

AOT_biomaps/AOT_Recon/AOT_Optimizers/MAPEM.py

@@ -2,13 +2,94 @@ from AOT_biomaps.AOT_Recon.ReconEnums import PotentialType
 from AOT_biomaps.AOT_Recon.AOT_PotentialFunctions.Quadratic import _Omega_QUADRATIC_CPU, _Omega_QUADRATIC_GPU
 from AOT_biomaps.AOT_Recon.AOT_PotentialFunctions.RelativeDifferences import _Omega_RELATIVE_DIFFERENCE_CPU, _Omega_RELATIVE_DIFFERENCE_GPU
 from AOT_biomaps.AOT_Recon.AOT_PotentialFunctions.Huber import _Omega_HUBER_PIECEWISE_CPU, _Omega_HUBER_PIECEWISE_GPU
-from AOT_biomaps.AOT_Recon.ReconTools import _build_adjacency_sparse
+from AOT_biomaps.AOT_Recon.ReconTools import _build_adjacency_sparse, check_gpu_memory, calculate_memory_requirement
 from AOT_biomaps.Config import config
+
+import warnings
 import numpy as np
 import torch
 from tqdm import trange
 
-def _MAPEM_CPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSavingEachIteration, withTumor, max_saves=5000):
+def MAPEM(
+    SMatrix, 
+    y, 
+    Omega,
+    beta,
+    delta=None,
+    gamma=None,
+    sigma=None,
+    numIterations=100,
+    isSavingEachIteration=True,
+    withTumor=True,
+    device=None,
+    max_saves=5000,
+    show_logs=True):
+    """
+    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.
+    """
+    try:
+        tumor_str = "WITH" if withTumor else "WITHOUT"
+        # Auto-select device and method
+        if device is None:
+            if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
+                device = torch.device(f"cuda:{config.select_best_gpu()}")
+                use_gpu = True
+            else:
+                device = torch.device("cpu")
+                use_gpu = False
+        else:
+            use_gpu = device.type == "cuda"
+        # Dispatch to the appropriate implementation
+        if use_gpu:
+                return _MAPEM_GPU(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True)
+        else:
+                return _MAPEM_CPU(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, max_saves, show_logs=True)
+    except Exception as e:
+        print(f"Error in MLEM: {type(e).__name__}: {e}")
+        return None, None
+
+def MAPEM_STOP(
+    SMatrix, 
+    y, 
+    Omega,
+    beta,
+    delta=None,
+    gamma=None,
+    sigma=None,
+    numIterations=100,
+    isSavingEachIteration=True,
+    withTumor=True,
+    device=None,
+    max_saves=5000,
+    show_logs=True):
+    """
+    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.
+    """
+    try:
+        tumor_str = "WITH" if withTumor else "WITHOUT"
+        # Auto-select device and method
+        if device is None:
+            if torch.cuda.is_available() and check_gpu_memory(config.select_best_gpu(), calculate_memory_requirement(SMatrix, y), show_logs=show_logs):
+                device = torch.device(f"cuda:{config.select_best_gpu()}")
+                use_gpu = True
+            else:
+                device = torch.device("cpu")
+                use_gpu = False
+        else:
+            use_gpu = device.type == "cuda"
+        # Dispatch to the appropriate implementation
+        if use_gpu:
+                return _MAPEM_GPU_STOP(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True)
+        else:
+                return _MAPEM_CPU_STOP(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, max_saves, show_logs=True)
+    except Exception as e:
+        print(f"Error in MLEM: {type(e).__name__}: {e}")
+        return None, None
+
+
+def _MAPEM_CPU_STOP(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, max_saves, show_logs=True):
     """
     MAPEM version CPU simple - sans GPU - torch uniquement
     """
@@ -42,7 +123,6 @@ def _MAPEM_CPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
         theta_list = [I_0]
         results = [I_0.numpy()]
         saved_indices = [0]
-        previous = -np.inf
         normalization_factor = SMatrix.sum(dim=(0, 3)).reshape(-1)
         adj_index, adj_values = _build_adjacency_sparse(Z, X)
 
@@ -56,13 +136,14 @@ def _MAPEM_CPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
                 save_indices.append(numIterations - 1)
 
         if Omega == PotentialType.HUBER_PIECEWISE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
         elif Omega == PotentialType.RELATIVE_DIFFERENCE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
         elif Omega == PotentialType.QUADRATIC:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
 
-        for p in trange(numIterations, desc=description):
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
             theta_p = theta_list[-1]
             theta_p_flat = theta_p.reshape(-1)
             q_flat = A_flat @ theta_p_flat
@@ -80,14 +161,13 @@ def _MAPEM_CPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
             theta_next_flat = torch.clamp(theta_next_flat, min=0)
             theta_next = theta_next_flat.reshape(Z, X)
             theta_list[-1] = theta_next
-            if isSavingEachIteration and p in save_indices:
+            if isSavingEachIteration and it in save_indices:
                 results.append(theta_next.numpy())
-                saved_indices.append(p+1)
+                saved_indices.append(it+1)
             log_likelihood = (y_flat * torch.log(q_flat + 1e-8) - (q_flat + 1e-8)).sum()
             penalized_log_likelihood = log_likelihood - beta * U_value
-            current = penalized_log_likelihood.item()
-            if (p + 1) % 100 == 0:
-                print(f"Iter {p+1}: logL={log_likelihood:.3e}, U={U_value:.3e}, penalized logL={penalized_log_likelihood:.3e}")
+            if (it + 1) % 100 == 0:
+                print(f"Iter {it+1}: logL={log_likelihood:.3e}, U={U_value:.3e}, penalized logL={penalized_log_likelihood:.3e}")
 
         if isSavingEachIteration:
             return results, saved_indices
@@ -97,7 +177,7 @@ def _MAPEM_CPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
         print(f"An error occurred in _MAPEM_CPU_STOP: {e}")
         return None, None
 
-def _MAPEM_GPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSavingEachIteration, withTumor, max_saves=5000):
+def _MAPEM_GPU_STOP(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
     """
     Maximum A Posteriori (MAP) estimation for Bayesian reconstruction.
     This method computes the MAP estimate of the parameters given the data.
@@ -123,7 +203,6 @@ def _MAPEM_GPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
         else:
             raise ValueError(f"Unknown potential type: {Omega}")
 
-        device = torch.device(f"cuda:{config.select_best_gpu()}")
         A_matrix_torch = torch.tensor(SMatrix, dtype=torch.float32).to(device)
         y_torch = torch.tensor(y, dtype=torch.float32).to(device)
         T, Z, X, N = SMatrix.shape
@@ -150,13 +229,14 @@ def _MAPEM_GPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
                 save_indices.append(numIterations - 1)
 
         if Omega == PotentialType.HUBER_PIECEWISE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
         elif Omega == PotentialType.RELATIVE_DIFFERENCE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
         elif Omega == PotentialType.QUADRATIC:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) + STOP condition (penalized log-likelihood) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) + STOP condition (penalized log-likelihood) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
 
-        for p in trange(numIterations, desc=description):
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
             theta_p = matrix_theta_torch[-1]
             theta_p_flat = theta_p.reshape(-1)
             q_flat = A_flat @ theta_p_flat
@@ -176,18 +256,18 @@ def _MAPEM_GPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
             theta_p_plus_1_flat = torch.clamp(theta_p_plus_1_flat, min=0)
             theta_next = theta_p_plus_1_flat.reshape(Z, X)
             matrix_theta_torch[-1] = theta_next
-            if isSavingEachIteration and p in save_indices:
+            if isSavingEachIteration and it in save_indices:
                 matrix_theta_from_gpu_MAPEM.append(theta_next.cpu().numpy())
-                saved_indices.append(p+1)
+                saved_indices.append(it+1)
             log_likelihood = (y_flat * (torch.log(q_flat + torch.finfo(torch.float32).tiny)) - (q_flat + torch.finfo(torch.float32).tiny)).sum()
             penalized_log_likelihood = log_likelihood - beta * U_value
-            if p == 0 or (p + 1) % 100 == 0:
+            if it == 0 or (it + 1) % 100 == 0:
                 current = penalized_log_likelihood.item()
                 if current <= previous:
                     nb_false_successive += 1
                 else:
                     nb_false_successive = 0
-                print(f"Iter {p + 1}: lnL without term ln(m_i !) inside={log_likelihood.item():.8e}, Gibbs energy function U={U_value.item():.4e}, penalized lnL without term ln(m_i !) inside={penalized_log_likelihood.item():.8e}, p lnL (current {current:.8e} - previous {previous:.8e} > 0)={(current - previous > 0)}, nb_false_successive={nb_false_successive}")
+                print(f"Iter {it + 1}: lnL without term ln(m_i !) inside={log_likelihood.item():.8e}, Gibbs energy function U={U_value.item():.4e}, penalized lnL without term ln(m_i !) inside={penalized_log_likelihood.item():.8e}, p lnL (current {current:.8e} - previous {previous:.8e} > 0)={(current - previous > 0)}, nb_false_successive={nb_false_successive}")
                 previous = current
 
         del A_matrix_torch, y_torch, A_flat, y_flat, I_0, normalization_factor, normalization_factor_flat
@@ -202,7 +282,7 @@ def _MAPEM_GPU_STOP(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma,
         torch.cuda.empty_cache()
         return None, None
 
-def _MAPEM_CPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSavingEachIteration, withTumor, max_saves=5000):
+def _MAPEM_CPU(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, max_saves, show_logs=True):
     try:
         if not isinstance(Omega, PotentialType):
             raise TypeError(f"Omega must be of type PotentialType, got {type(Omega)}")
@@ -225,7 +305,6 @@ def _MAPEM_CPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
             raise ValueError(f"Unknown potential type: {Omega}")
 
         T, Z, X, N = SMatrix.shape
-        J = Z * X
         A_flat = np.transpose(SMatrix, (0, 3, 1, 2)).reshape(T * N, Z * X)
         y_flat = y.reshape(-1)
         theta_0 = np.ones((Z, X), dtype=np.float32)
@@ -246,13 +325,14 @@ def _MAPEM_CPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
                 save_indices.append(numIterations - 1)
 
         if Omega == PotentialType.HUBER_PIECEWISE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
         elif Omega == PotentialType.RELATIVE_DIFFERENCE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
         elif Omega == PotentialType.QUADRATIC:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single CPU ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC β:{beta:.4f}, σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single CPU ----"
 
-        for p in trange(numIterations, desc=description):
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
             theta_p = matrix_theta_np[-1]
             theta_p_flat = theta_p.reshape(-1)
             q_flat = A_flat @ theta_p_flat
@@ -270,9 +350,9 @@ def _MAPEM_CPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
             theta_p_plus_1_flat = np.clip(theta_p_plus_1_flat, 0, None)
             theta_next = theta_p_plus_1_flat.reshape(Z, X)
             matrix_theta_np.append(theta_next)
-            if isSavingEachIteration and p in save_indices:
+            if isSavingEachIteration and it in save_indices:
                 I_reconMatrix.append(theta_next.copy())
-                saved_indices.append(p+1)
+                saved_indices.append(it+1)
 
         if isSavingEachIteration:
             return I_reconMatrix, saved_indices
@@ -282,7 +362,7 @@ def _MAPEM_CPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
         print(f"An error occurred in _MAPEM_CPU: {e}")
         return None, None
 
-def _MAPEM_GPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSavingEachIteration, withTumor, max_saves=5000):
+def _MAPEM_GPU(SMatrix, y, Omega, beta, delta, gamma, sigma, numIterations, isSavingEachIteration, tumor_str, device, max_saves, show_logs=True):
     """
     Maximum A Posteriori (MAP) estimation for Bayesian reconstruction using GPU.
     This method computes the MAP estimate of the parameters given the data.
@@ -308,7 +388,6 @@ def _MAPEM_GPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
         else:
             raise ValueError(f"Unknown potential type: {Omega}")
 
-        device = torch.device(f"cuda:{config.select_best_gpu()}")
         A_matrix_torch = torch.tensor(SMatrix, dtype=torch.float32).to(device)
         y_torch = torch.tensor(y, dtype=torch.float32).to(device)
         T, Z, X, N = SMatrix.shape
@@ -333,13 +412,14 @@ def _MAPEM_GPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
                 save_indices.append(numIterations - 1)
 
         if Omega == PotentialType.HUBER_PIECEWISE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse HUBER β:{beta:.4f}, δ:{delta:.4f}) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
         elif Omega == PotentialType.RELATIVE_DIFFERENCE:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse RD β:{beta:.4f}, γ:{gamma:.4f}) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
         elif Omega == PotentialType.QUADRATIC:
-            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC σ:{sigma:.4f}) ---- {'WITH' if withTumor else 'WITHOUT'} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
+            description = f"AOT-BioMaps -- Bayesian Reconstruction Tomography: MAP-EM (Sparse QUADRATIC σ:{sigma:.4f}) ---- {tumor_str} TUMOR ---- processing on single GPU no.{torch.cuda.current_device()} ----"
 
-        for p in trange(numIterations, desc=description):
+        iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+        for it in iterator:
             theta_p = matrix_theta_torch[-1]
             theta_p_flat = theta_p.reshape(-1)
             q_flat = A_flat @ theta_p_flat
@@ -359,9 +439,9 @@ def _MAPEM_GPU(SMatrix, y, Omega, numIterations, beta, delta, gamma, sigma, isSa
             theta_p_plus_1_flat = torch.clamp(theta_p_plus_1_flat, min=0)
             theta_next = theta_p_plus_1_flat.reshape(Z, X)
             matrix_theta_torch.append(theta_next)
-            if isSavingEachIteration and p in save_indices:
+            if isSavingEachIteration and it in save_indices:
                 I_reconMatrix.append(theta_next.cpu().numpy())
-                saved_indices.append(p+1)
+                saved_indices.append(it+1)
 
         del A_matrix_torch, y_torch, A_flat, y_flat, theta_0, normalization_factor, normalization_factor_flat
         torch.cuda.empty_cache()