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

AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py

@@ -3,17 +3,6 @@ import numpy as np
 from tqdm import trange
 import os
 import gc
-import subprocess
-import sys
-
-# ==============================================================================
-# ATTENTION: MANUAL CONFIGURATION REQUIRED
-# ==============================================================================
-# The 'sm_XX' value must correspond to the Compute Capability of your NVIDIA GPU.
-# Examples: Kepler (sm_35), Maxwell (sm_50), Pascal (sm_61), Turing (sm_75), Ampere (sm_86).
-# THIS LINE MUST BE MODIFIED BY THE USER to target their specific architecture.
-GPU_COMPUTE_CAPABILITY = "sm_86"
-# ==============================================================================
 
 class SparseSMatrix_SELL:
     def __init__(self, manip, block_rows=64, relative_threshold=0.3, device=0,
@@ -28,104 +17,71 @@ class SparseSMatrix_SELL:
         self.X = manip.AcousticFields[0].field.shape[2]
         self.block_rows = block_rows
         self.relative_threshold = relative_threshold
-        # The module_path is relative to this file's directory
-        self.module_path = os.path.join(os.path.dirname(__file__), module_path)
+        
+        # --- PATH RESOLUTION FIX ---
+        # The cubin file is located in the parent directory (AOT_Recon/)
+        # We use os.path.dirname(os.path.dirname(__file__)) to go up one directory level.
+        cubin_parent_dir = os.path.dirname(os.path.dirname(__file__))
+        self.module_path = os.path.join(cubin_parent_dir, module_path)
+        # --- END FIX ---
+        
         self.slice_height = slice_height
 
-        # SELL arrays (device)
+        # SELL arrays (device) & Size Tracking (CRITICAL FIX: Initialized attributes)
         self.sell_values_gpu = None
         self.sell_colinds_gpu = None
         self.slice_ptr = None
         self.slice_len = None
         self.slice_ptr_gpu = None
         self.slice_len_gpu = None
+        
+        # Attributes to store allocated size in bytes (bypassing the problematic .size attribute)
+        self.sell_values_gpu_size = 0  
+        self.sell_colinds_gpu_size = 0 
+        self.slice_ptr_gpu_size = 0    
+        self.slice_len_gpu_size = 0    
+
         self.total_storage = 0
 
         self.norm_factor_inv = None
         self.norm_factor_inv_gpu = None
+        self.norm_factor_inv_gpu_size = 0
 
         self.sparse_mod = None
         self.load_module()
-    
-    def _compile_cubin(self, source_file="AOT_biomaps_kernels.cu"):
-        """
-        Tries to compile the .cu file into .cubin using nvcc.
-        """
-        print("="*60)
-        print("🛠️ CUDA COMPILATION REQUIRED")
-        print(f"Attempting to compile {source_file} to {os.path.basename(self.module_path)}...")
-
-        # The source file is assumed to be in the same directory as this Python file.
-        source_path = os.path.join(os.path.dirname(__file__), source_file)
-        cubin_path = self.module_path
-        
-        if not os.path.exists(source_path):
-            print(f"❌ CRITICAL ERROR: CUDA source file {source_file} not found at {source_path}.")
-            raise FileNotFoundError(f"Could not find source file {source_file} for compilation. AOT_biomaps installation might be incomplete.")
-
-        # Construction of the nvcc command
-        command = [
-            'nvcc',
-            '-cubin',
-            f'-arch={GPU_COMPUTE_CAPABILITY}', # USES THE VARIABLE DEFINED ABOVE
-            source_path,
-            '-o',
-            cubin_path
-        ]
-        
-        print(f"Executing command: {' '.join(command)}")
-
-        try:
-            # Executes the command and waits for completion
-            result = subprocess.run(
-                command,
-                check=True,
-                capture_output=True,
-                text=True
-            )
-            print(f"🎉 Compilation successful! File created: {os.path.basename(cubin_path)}")
-            # print("Output nvcc:\n", result.stdout) # Uncomment to see detailed output
-            print("="*60)
-            return True
-
-        except subprocess.CalledProcessError as e:
-            print("❌ NVCC COMPILATION ERROR:")
-            print(f"Check GPU architecture: {GPU_COMPUTE_CAPABILITY}")
-            print(f"Standard error:\n{e.stderr}")
-            print("="*60)
-            return False
-        
-        except FileNotFoundError:
-            print("❌ ERROR: The 'nvcc' command was not found.")
-            print("Ensure that the CUDA Toolkit is installed and 'nvcc' is in your PATH (or your Conda environment).")
-            print("="*60)
-            return False
 
     def load_module(self):
-        """Tries to load the CUDA module. If the file is missing, it attempts to compile it."""
+        """Loads the pre-compiled CUDA module (.cubin file)."""
         
+        # Check if the file exists at the calculated absolute path
         if not os.path.exists(self.module_path):
-            print(f"CUDA module {os.path.basename(self.module_path)} missing. Attempting compilation...")
-            
-            if not self._compile_cubin():
-                # If compilation fails, re-raise the original error.
-                raise FileNotFoundError(f"{os.path.basename(self.module_path)} not found and compilation failed. Check nvcc and GPU architecture ({GPU_COMPUTE_CAPABILITY}).")
+            # The path is now correctly calculated to the parent directory.
+            raise FileNotFoundError(f"CUDA module {os.path.basename(self.module_path)} not found at path: {self.module_path}")
             
-        # Try to load after compilation (or if the file existed)
+        # Try to load the module
         try:
             self.sparse_mod = drv.module_from_file(self.module_path)
             print(f"Loaded CUDA module {os.path.basename(self.module_path)}")
         except Exception as e:
             print(f"❌ Error loading CUDA module {os.path.basename(self.module_path)}: {e}")
-            raise RuntimeError(f"File {os.path.basename(self.module_path)} was found, but PyCUDA could not load it.") from e
+            raise RuntimeError(f"File {os.path.basename(self.module_path)} was found, but PyCUDA could not load it. Check compatibility.") from e
 
     def free(self):
         try:
+            # Free device allocations
             attrs = ["sell_values_gpu","sell_colinds_gpu","slice_ptr_gpu","slice_len_gpu","norm_factor_inv_gpu"]
             for a in attrs:
                 if hasattr(self, a) and getattr(self, a) is not None:
                     getattr(self, a).free()
                     setattr(self, a, None)
+            
+            # Reset stored sizes
+            self.sell_values_gpu_size = 0
+            self.sell_colinds_gpu_size = 0
+            self.slice_ptr_gpu_size = 0
+            self.slice_len_gpu_size = 0
+            self.norm_factor_inv_gpu_size = 0
+            
             if hasattr(self, 'ctx') and self.ctx:
                 try: self.ctx.pop()
                 except Exception: pass
@@ -136,11 +92,13 @@ class SparseSMatrix_SELL:
     def allocate(self):
         """
         Build SELL-C-σ directly from manip AcousticFields in streaming blocks.
+        NOTE: This is the logic of allocate_sell_c_sigma_direct from the working class.
         """
-        # Ensures the module is loaded before attempting to retrieve functions
         if self.sparse_mod is None:
-             raise RuntimeError("CUDA module not loaded. Check compilation.")
-             
+            raise RuntimeError("CUDA module not loaded. Check compilation.")
+            
+        # NOTE: Les noms de kernel (count_nnz_rows_kernel, fill_kernel__SELL) sont utilisés
+        # car ils sont présents dans la classe fonctionnelle.
         count_kernel = self.sparse_mod.get_function("count_nnz_rows_kernel")
         fill_kernel  = self.sparse_mod.get_function("fill_kernel__SELL")
 
@@ -152,11 +110,15 @@ class SparseSMatrix_SELL:
         br = int(self.block_rows)
         bytes_per_elem = np.dtype(np.float32).itemsize
         dense_host = np.empty((br, num_cols), dtype=np.float32)
-        dense_gpu  = drv.mem_alloc(dense_host.nbytes)
+        
+        # Allocation 1: Dense block GPU memory
+        dense_gpu_size = dense_host.nbytes
+        dense_gpu  = drv.mem_alloc(dense_gpu_size)
 
         # 1) count nnz per row (on host via small blocks with GPU kernel)
         row_nnz = np.zeros(num_rows, dtype=np.int32)
-        row_nnz_gpu_block = drv.mem_alloc(br * np.dtype(np.int32).itemsize)
+        row_nnz_gpu_block_size = br * np.dtype(np.int32).itemsize
+        row_nnz_gpu_block = drv.mem_alloc(row_nnz_gpu_block_size)
 
         block = 256
         for b in trange(0, num_rows, br, desc="Count NNZ per row"):
@@ -195,22 +157,35 @@ class SparseSMatrix_SELL:
         print(f"SELL: num_rows={num_rows}, num_slices={num_slices}, total_storage(padded)={total_storage}")
 
         # allocate device SELL arrays (values float32, colinds uint32)
-        self.sell_values_gpu = drv.mem_alloc(total_storage * np.dtype(np.float32).itemsize)
-        self.sell_colinds_gpu = drv.mem_alloc(total_storage * np.dtype(np.uint32).itemsize)
+        self.sell_values_gpu_size = total_storage * np.dtype(np.float32).itemsize
+        self.sell_colinds_gpu_size = total_storage * np.dtype(np.uint32).itemsize
+        
+        self.sell_values_gpu = drv.mem_alloc(self.sell_values_gpu_size)
+        self.sell_colinds_gpu = drv.mem_alloc(self.sell_colinds_gpu_size)
+        
         # allocate slice metadata on device
         self.slice_ptr = slice_ptr
         self.slice_len = slice_len
-        self.slice_ptr_gpu = drv.mem_alloc(self.slice_ptr.nbytes)
-        self.slice_len_gpu = drv.mem_alloc(self.slice_len.nbytes)
+        
+        self.slice_ptr_gpu_size = self.slice_ptr.nbytes
+        self.slice_len_gpu_size = self.slice_len.nbytes
+        
+        self.slice_ptr_gpu = drv.mem_alloc(self.slice_ptr_gpu_size)
+        self.slice_len_gpu = drv.mem_alloc(self.slice_len_gpu_size)
+        
         drv.memcpy_htod(self.slice_ptr_gpu, self.slice_ptr)
         drv.memcpy_htod(self.slice_len_gpu, self.slice_len)
 
         # 3) fill SELL arrays by streaming blocks again (use GPU fill kernel)
-        # reuse dense_host and dense_gpu
+        # reuse dense_host and allocate new dense_gpu
         dense_host = np.empty((br, num_cols), dtype=np.float32)
-        dense_gpu  = drv.mem_alloc(dense_host.nbytes)
+        
+        dense_gpu_2_size = dense_host.nbytes
+        dense_gpu  = drv.mem_alloc(dense_gpu_2_size)
+        
         # we also need row_nnz on device per-block; supply global row_nnz on host but the kernel recomputes threshold
-        row_nnz_host_gpu = drv.mem_alloc(br * np.dtype(np.int32).itemsize)
+        row_nnz_host_gpu_size = br * np.dtype(np.int32).itemsize
+        row_nnz_host_gpu = drv.mem_alloc(row_nnz_host_gpu_size)
 
         for b in trange(0, num_rows, br, desc="Fill SELL"):
             R = min(br, num_rows - b)
@@ -231,18 +206,49 @@ class SparseSMatrix_SELL:
                         self.sell_values_gpu,
                         np.int32(R),
                         np.int32(num_cols),
-                        np.int32(b), # rows_global_offset
+                        np.int32(b),          # rows_global_offset
                         np.int32(C),
                         np.float32(self.relative_threshold),
                         block=(block,1,1), grid=grid)
         dense_gpu.free()
         row_nnz_host_gpu.free()
 
-        # At this point sell_values_gpu and sell_colinds_gpu are filled.
-
         # 4) compute norm_factor_inv via GPU accumulate (col sums)
         self.compute_norm_factor()
+    
+    def apply_apodization_gpu(self, window_vector_gpu):
+        """
+        Applique le fenêtrage directement sur self.sell_values_gpu 
+        en utilisant les indices de colonnes (pixels) pour référencer 
+        la fenêtre. Opération : A_values[i] *= W_vec[A_colinds[i]].
+        """
+        if self.sparse_mod is None:
+            raise RuntimeError("Le module CUDA n'a pas été chargé.")
+            
+        try:
+            apodize_kernel = self.sparse_mod.get_function("apply_apodisation_kernel__SELL")
+        except drv.LogicError as e:
+            raise RuntimeError(
+                f"Le kernel CUDA 'multiply_sell_by_window_kernel' est manquant dans le .cubin. "
+                f"Veuillez le compiler et l'ajouter. Erreur : {e}"
+            )
 
+        # Le total_storage inclut les éléments non-nuls et le padding SELL.
+        threads = 256
+        blocks = (self.total_storage + threads - 1) // threads
+        
+        # Lancement du kernel. Il travaille sur total_storage éléments.
+        apodize_kernel(
+            self.sell_values_gpu, 
+            self.sell_colinds_gpu, 
+            window_vector_gpu, 
+            np.int64(self.total_storage), 
+            block=(threads, 1, 1), 
+            grid=(blocks, 1, 1)
+        )
+        drv.Context.synchronize()
+        print("✅ Multiplication par le fenêtrage effectuée in-place sur GPU (SELL-C-σ).")
+    # --- Ajout de la fonction de normalisation (qui fonctionne) ---
     def compute_norm_factor(self):
         """
         Accumulate column sums on GPU using accumulate_columns_atomic, then compute inverse.
@@ -252,10 +258,13 @@ class SparseSMatrix_SELL:
         ZX = int(self.Z * self.X)
 
         # allocate col sum on device
-        col_sum_gpu = drv.mem_alloc(ZX * np.dtype(np.float32).itemsize)
+        col_sum_gpu_size = ZX * np.dtype(np.float32).itemsize
+        col_sum_gpu = drv.mem_alloc(col_sum_gpu_size)
         drv.memset_d32(col_sum_gpu, 0, ZX)
 
-        acc_kernel = self.sparse_mod.get_function("accumulate_columns_atomic__SELL")
+        # FIX: Kernel name is "accumulate_columns_atomic"
+        acc_kernel = self.sparse_mod.get_function("accumulate_columns_atomic")
+        
         threads = 256
         blocks = (self.total_storage + threads - 1) // threads
         acc_kernel(self.sell_values_gpu, self.sell_colinds_gpu, np.int64(self.total_storage), col_sum_gpu,
@@ -271,7 +280,9 @@ class SparseSMatrix_SELL:
         self.norm_factor_inv = (1.0 / norm).astype(np.float32)
         if self.norm_factor_inv_gpu is not None:
             self.norm_factor_inv_gpu.free()
-        self.norm_factor_inv_gpu = drv.mem_alloc(self.norm_factor_inv.nbytes)
+            
+        self.norm_factor_inv_gpu_size = self.norm_factor_inv.nbytes
+        self.norm_factor_inv_gpu = drv.mem_alloc(self.norm_factor_inv_gpu_size)
         drv.memcpy_htod(self.norm_factor_inv_gpu, self.norm_factor_inv)
 
     def compute_density(self):
@@ -288,7 +299,7 @@ class SparseSMatrix_SELL:
         # Conservative estimate of non-zeros (excluding padding)
         nnz_ell_estimated = int(0.9 * self.total_storage)
 
-        return nnz_ell_estimated / total_elements # Returns only the density
+        return nnz_ell_estimated / total_elements  # Returns only the density
 
     def getMatrixSize(self):
         """
@@ -299,7 +310,7 @@ class SparseSMatrix_SELL:
 
         total_bytes = 0
 
-        # Host-side arrays
+        # Host-side arrays (using .nbytes which works for NumPy arrays)
         if hasattr(self, 'slice_ptr') and self.slice_ptr is not None:
             total_bytes += self.slice_ptr.nbytes
         if hasattr(self, 'slice_len') and self.slice_len is not None:
@@ -307,16 +318,11 @@ class SparseSMatrix_SELL:
         if hasattr(self, 'norm_factor_inv') and self.norm_factor_inv is not None:
             total_bytes += self.norm_factor_inv.nbytes
 
-        # GPU-side arrays
-        if hasattr(self, 'sell_values_gpu') and self.sell_values_gpu:
-            total_bytes += self.sell_values_gpu.size
-        if hasattr(self, 'sell_colinds_gpu') and self.sell_colinds_gpu:
-            total_bytes += self.sell_colinds_gpu.size
-        if hasattr(self, 'slice_ptr_gpu') and self.slice_ptr_gpu:
-            total_bytes += self.slice_ptr_gpu.size
-        if hasattr(self, 'slice_len_gpu') and self.slice_len_gpu:
-            total_bytes += self.slice_len_gpu.size
-        if hasattr(self, 'norm_factor_inv_gpu') and self.norm_factor_inv_gpu:
-            total_bytes += self.norm_factor_inv_gpu.size
-
-        return total_bytes / (1024 ** 3) # Returns only the size in GB
+        # GPU-side arrays (using the stored size attributes instead of the problematic .size)
+        total_bytes += self.sell_values_gpu_size
+        total_bytes += self.sell_colinds_gpu_size
+        total_bytes += self.slice_ptr_gpu_size
+        total_bytes += self.slice_len_gpu_size
+        total_bytes += self.norm_factor_inv_gpu_size
+        
+        return total_bytes / (1024 ** 3)  # Returns only the size in GB

AOT_biomaps/AOT_Recon/AlgebraicRecon.py

@@ -1,4 +1,6 @@
 import concurrent
+
+from AOT_biomaps.AOT_Recon.ReconTools import get_apodization_vector_gpu
 from ._mainRecon import Recon
 from .ReconEnums import ReconType, OptimizerType, ProcessType, SMatrixType
 from .AOT_Optimizers import MLEM, LS
@@ -43,8 +45,6 @@ class AlgebraicRecon(Recon):
 
         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.")
         if self.numSubsets <= 0:
@@ -729,6 +729,8 @@ class AlgebraicRecon(Recon):
         """
         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()}")
@@ -756,7 +758,6 @@ class AlgebraicRecon(Recon):
                                                         max_saves=self.maxSaves,
                                                         show_logs=show_logs,
                                                         smatrixType=self.smatrixType,
-                                                        Z=self.Z_dim
                                                         )
             else:
                 self.reconLaser, self.indices = MLEM(SMatrix=self.SMatrix, 
@@ -770,30 +771,36 @@ class AlgebraicRecon(Recon):
                                                         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,
-                                                alpha=self.alpha,
-                                                max_saves=self.maxSaves,
-                                                show_logs=show_logs
+                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
                                                 )
             else:
-                self.reconLaser, self.indices = LS(SMatrix=self.SMatrix,
-                                                y=self.experiment.AOsignal_withoutTumor, 
-                                                numIterations=self.numIterations, 
-                                                isSavingEachIteration=self.isSavingEachIteration, 
-                                                withTumor=withTumor,
-                                                alpha=self.alpha,
-                                                max_saves=self.maxSaves,
-                                                show_logs=show_logs
+                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
                                                 )
         else:
             raise ValueError(f"Only MLEM and LS are supported for simple algebraic reconstruction. {self.optimizer.value} need Bayesian reconstruction")

AOT_biomaps/AOT_Recon/PrimalDualRecon.py

@@ -1,5 +1,5 @@
 from AOT_biomaps.AOT_Recon.AlgebraicRecon import AlgebraicRecon
-from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType
+from AOT_biomaps.AOT_Recon.ReconEnums import ReconType, ProcessType, SMatrixType
 from AOT_biomaps.AOT_Recon.AOT_Optimizers import CP_KL, CP_TV
 from AOT_biomaps.AOT_Recon.ReconEnums import OptimizerType
 
@@ -13,11 +13,20 @@ 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, theta=1.0, L=None, **kwargs):
+    def __init__(self, alpha, beta, theta=1.0, L=None, k_security=0.8, use_power_method=True, auto_alpha_gamma=0.05, apply_positivity_clamp=True, tikhonov_as_gradient=False, use_laplacian=True, laplacian_beta_scale=1.0,  **kwargs):
         super().__init__(**kwargs)
         self.reconType = ReconType.Convex
+        self.alpha = alpha               # TV regularization parameter (if None, alpha is auto-scaled)
+        self.beta=beta # Tikhonov 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.k_security=k_security
+        self.use_power_method=use_power_method
+        self.auto_alpha_gamma=auto_alpha_gamma    # gamma for auto alpha: alpha = gamma * data_term / tv_term
+        self.apply_positivity_clamp=apply_positivity_clamp
+        self.tikhonov_as_gradient=tikhonov_as_gradient  # if True, apply -tau*2*beta*x instead of prox multiplicative
+        self.use_laplacian=use_laplacian      # enable Laplacian (Hessian scalar) penalty
+        self.laplacian_beta_scale=laplacian_beta_scale # multiply beta for laplacian term if you want separate scaling
 
     def run(self, processType=ProcessType.PYTHON, withTumor=True):
         """
@@ -149,56 +158,100 @@ class PrimalDualRecon(AlgebraicRecon):
             if show_logs:
                 print(f"Loaded reconstruction results and indices from {results_dir}")
 
-    def _convexReconPython(self, withTumor):
+    def _convexReconPython(self, withTumor,show_logs=True):
         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
-                    )
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
+                )
             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
-                    )
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withoutTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
+                )
         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
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
                 )
             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
+                                                    SMatrix = self.SMatrix, 
+                                                    y = self.experiment.AOsignal_withoutTumor, 
+                                                    alpha=self.alpha,               
+                                                    beta=self.beta,             
+                                                    theta=self.theta,
+                                                    numIterations=self.numIterations, 
+                                                    isSavingEachIteration=self.isSavingEachIteration,
+                                                    L=self.L, 
+                                                    withTumor=withTumor,
+                                                    device=self.device,
+                                                    max_saves=self.maxSaves,
+                                                    show_logs=show_logs,
+                                                    smatrixType= self.smatrixType,
+                                                    k_security=self.k_security,
+                                                    use_power_method=self.use_power_method,
+                                                    auto_alpha_gamma=self.auto_alpha_gamma,   
+                                                    apply_positivity_clamp=self.apply_positivity_clamp,
+                                                    tikhonov_as_gradient=self.tikhonov_as_gradient, 
+                                                    use_laplacian=self.use_laplacian,        
+                                                    laplacian_beta_scale=self.laplacian_beta_scale
                 )
         else:
             raise ValueError(f"Optimizer value must be CP_TV or CP_KL, got {self.optimizer}")