AOT-biomaps 2.9.281__tar.gz → 2.9.291__tar.gz

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py

@@ -181,13 +181,12 @@ def _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tu
             print(f"Dim X: {X}, Dim Z: {Z}, TN: {TN}, ZX: {ZX}")
 
         stream = drv.Stream()
-        mod = drv.module_from_file('AOT_biomaps_kernels.cubin')
         
         # Récupération des Kernels
-        projection_kernel = mod.get_function('projection_kernel__CSR')
-        backprojection_kernel = mod.get_function('backprojection_kernel__CSR')
-        axpby_kernel = mod.get_function("vector_axpby_kernel")
-        minus_axpy_kernel = mod.get_function("vector_minus_axpy_kernel")
+        projection_kernel = SMatrix.sparse_mod.get_function('projection_kernel__CSR')
+        backprojection_kernel = SMatrix.sparse_mod.get_function('backprojection_kernel__CSR')
+        axpby_kernel = SMatrix.sparse_mod.get_function("vector_axpby_kernel")
+        minus_axpy_kernel = SMatrix.sparse_mod.get_function("vector_minus_axpy_kernel")
         
         # --- Allocation des buffers (Pointeurs Bruts) ---
         y = y.T.flatten().astype(dtype)
@@ -231,7 +230,7 @@ def _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tu
         drv.memcpy_dtod(p_flat_gpu, r_flat_gpu, ZX * np.dtype(dtype).itemsize)
         
         # 6. rho_prev = ||r_0||^2
-        rho_prev = _dot_product_gpu(mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+        rho_prev = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
 
         # --- Boucle itérative ---
         saved_theta, saved_indices = [], []
@@ -258,7 +257,7 @@ def _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tu
                                   block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
 
             # c. alpha = rho_prev / <p, z>
-            pAp = _dot_product_gpu(mod, p_flat_gpu, z_flat_gpu, ZX, stream)
+            pAp = _dot_product_gpu(SMatrix.sparse_mod, p_flat_gpu, z_flat_gpu, ZX, stream)
             
             if abs(pAp) < 1e-15: break
             alpha = rho_prev / pAp
@@ -273,7 +272,7 @@ def _LS_CG_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tu
                               block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
             
             # f. rho_curr = ||r||^2
-            rho_curr = _dot_product_gpu(mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+            rho_curr = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
             
             if rho_curr < tolerance: break
 
@@ -364,11 +363,10 @@ def _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, t
         tolerance = 1e-12 
 
         # Accès aux paramètres SELL
-        mod = SMatrix.sparse_mod
-        projection_kernel = mod.get_function("projection_kernel__SELL")
-        backprojection_kernel = mod.get_function("backprojection_kernel__SELL")
-        axpby_kernel = mod.get_function("vector_axpby_kernel")
-        minus_axpy_kernel = mod.get_function("vector_minus_axpy_kernel")
+        projection_kernel = SMatrix.sparse_mod.get_function("projection_kernel__SELL")
+        backprojection_kernel = SMatrix.sparse_mod.get_function("backprojection_kernel__SELL")
+        axpby_kernel = SMatrix.sparse_mod.get_function("vector_axpby_kernel")
+        minus_axpy_kernel = SMatrix.sparse_mod.get_function("vector_minus_axpy_kernel")
         slice_height = np.int32(SMatrix.slice_height)
         grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
 
@@ -416,7 +414,7 @@ def _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, t
         drv.memcpy_dtod(p_flat_gpu, r_flat_gpu, ZX * np.dtype(dtype).itemsize)
         
         # 6. rho_prev = ||r_0||^2
-        rho_prev = _dot_product_gpu(mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+        rho_prev = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
 
         # --- Boucle itérative ---
         saved_theta, saved_indices = [], []
@@ -443,7 +441,7 @@ def _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, t
                                   block=(block_size, 1, 1), grid=grid_rows, stream=stream)
 
             # c. alpha = rho_prev / <p, z>
-            pAp = _dot_product_gpu(mod, p_flat_gpu, z_flat_gpu, ZX, stream)
+            pAp = _dot_product_gpu(SMatrix.sparse_mod, p_flat_gpu, z_flat_gpu, ZX, stream)
             
             if abs(pAp) < 1e-15: break
             alpha = rho_prev / pAp
@@ -458,7 +456,7 @@ def _LS_CG_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, t
                               block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
             
             # f. rho_curr = ||r||^2
-            rho_curr = _dot_product_gpu(mod, r_flat_gpu, r_flat_gpu, ZX, stream)
+            rho_curr = _dot_product_gpu(SMatrix.sparse_mod, r_flat_gpu, r_flat_gpu, ZX, stream)
             
             if rho_curr < tolerance: break
 

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py

@@ -1,6 +1,6 @@
-from AOT_biomaps.AOT_Recon.ReconTools import power_method, gradient, div, proj_l2, prox_G, prox_F_star, _call_axpby, _call_minus_axpy, compute_TV_cpu, power_method_estimate_L__SELL
+from AOT_biomaps.AOT_Recon.ReconTools import power_method, gradient, div, proj_l2, prox_G, prox_F_star, _call_axpby, _call_minus_axpy, compute_TV_cpu, power_method_estimate_L__SELL, calculate_memory_requirement, check_gpu_memory
 from AOT_biomaps.Config import config
-from AOT_biomaps.AOT_Recon.ReconEnums import NoiseType
+from AOT_biomaps.AOT_Recon.ReconEnums import NoiseType, SMatrixType
 import torch
 from tqdm import trange
 import numpy as np
@@ -13,6 +13,103 @@ The methods can run on both CPU and GPU, with configurations set in the AOT_biom
 '''
 
 def CP_TV(
+    SMatrix, 
+    y, 
+    alpha=None,               # TV regularization parameter (if None, alpha is auto-scaled)
+    beta=1e-4,              # Tikhonov regularization parameter     
+    theta=1.0,
+    numIterations=5000, 
+    isSavingEachIteration=True,
+    L=None, 
+    withTumor=True,
+    device=None,
+    max_saves=5000,
+    show_logs=True,
+    smatrixType=SMatrixType.SELL,
+    k_security=0.8,
+    use_power_method=True,
+    auto_alpha_gamma=0.05,    # gamma for auto alpha: alpha = gamma * data_term / tv_term
+    apply_positivity_clamp=True,
+    tikhonov_as_gradient=False,  # if True, apply -tau*2*beta*x instead of prox multiplicative
+    use_laplacian=True,         # enable Laplacian (Hessian scalar) penalty
+    laplacian_beta_scale=1.0 # multiply beta for laplacian term if you want separate scaling
+):
+    # 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:
+            if smatrixType == SMatrixType.CSR:
+                raise NotImplementedError("GPU Chambolle Pock (LS-TV) with CSR not implemented.")
+            elif smatrixType == SMatrixType.SELL:
+                return CP_TV_Tikhonov_sparseCSR_pycuda(SMatrix, y, alpha,beta, theta, numIterations, isSavingEachIteration, L, tumor_str, device, max_saves, show_logs, k_security, use_power_method, auto_alpha_gamma, apply_positivity_clamp, tikhonov_as_gradient, use_laplacian, laplacian_beta_scale)
+            elif smatrixType == SMatrixType.DENSE:
+                return CP_TV_dense(SMatrix, y, alpha, theta, numIterations, isSavingEachIteration, L, tumor_str, device, max_saves, show_logs)
+            else:
+                raise ValueError("Unsupported SMatrixType for GPU Chambolle Pock (LS-TV).")
+    else:
+        raise NotImplementedError("CPU Chambolle Pock (LS-TV) not implemented.")
+
+def CP_KL(
+    SMatrix, 
+    y, 
+    alpha=None,               # TV regularization parameter (if None, alpha is auto-scaled)
+    beta=1e-4,              # Tikhonov regularization parameter     
+    theta=1.0,
+    numIterations=5000, 
+    isSavingEachIteration=True,
+    L=None, 
+    withTumor=True,
+    device=None,
+    max_saves=5000,
+    show_logs=True,
+    smatrixType=SMatrixType.SELL,
+    k_security=0.8,
+    use_power_method=True,
+    auto_alpha_gamma=0.05,    # gamma for auto alpha: alpha = gamma * data_term / tv_term
+    apply_positivity_clamp=True,
+    tikhonov_as_gradient=False,  # if True, apply -tau*2*beta*x instead of prox multiplicative
+    use_laplacian=True,         # enable Laplacian (Hessian scalar) penalty
+    laplacian_beta_scale=1.0 # multiply beta for laplacian term if you want separate scaling
+):
+    # 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:
+            if smatrixType == SMatrixType.CSR:
+                raise NotImplementedError("GPU Chambolle Pock (LS-KL) with CSR not implemented.")
+            elif smatrixType == SMatrixType.SELL:
+                raise NotImplementedError("GPU Chambolle Pock (LS-KL) with SELL not implemented.")
+            elif smatrixType == SMatrixType.DENSE:
+                return CP_KL(SMatrix, y, alpha, theta, numIterations, isSavingEachIteration, L, tumor_str, device, max_saves, show_logs)
+            else:
+                raise ValueError("Unsupported SMatrixType for GPU Chambolle Pock (LS-KL).")
+    else:
+        raise NotImplementedError("CPU Chambolle Pock (LS-KL) not implemented.")
+
+
+
+
+def CP_TV_dense(
     SMatrix,
     y,
     alpha=1e-1,
@@ -23,6 +120,7 @@ def CP_TV(
     withTumor=True,
     device=None,
     max_saves=5000,
+    show_logs=True,
 ):
     """
     Chambolle-Pock algorithm for Total Variation (TV) regularization.
@@ -94,10 +192,10 @@ def CP_TV(
     # Description for progress bar
     tumor_str = "WITH TUMOR" if withTumor else "WITHOUT TUMOR"
     device_str = f"GPU no.{torch.cuda.current_device()}" if device.type == "cuda" else "CPU"
-    description = f"AOT-BioMaps -- Primal/Dual Reconstruction (TV) α:{alpha:.4f} L:{L:.4f} -- {tumor_str} -- {device_str}"
+    description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS-TV) α:{alpha:.4f} L:{L:.4f} -- {tumor_str} -- {device_str}"
 
-    # Main loop
-    for iteration in trange(numIterations, desc=description):
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for it in iterator:
         # Update p (TV proximal step)
         grad_x = gradient(x_tilde.reshape(Z, X))
         p = proj_l2(p + sigma * grad_x, alpha)
@@ -115,9 +213,9 @@ def CP_TV(
         x_tilde = x + theta * (x - x_old)
 
         # Save intermediate result if needed
-        if isSavingEachIteration and iteration in save_indices:
+        if isSavingEachIteration and it in save_indices:
             I_reconMatrix.append(x.reshape(Z, X).clone() * (norm_y / norm_A))
-            saved_indices.append(iteration)
+            saved_indices.append(it)
 
     # Return results
     if isSavingEachIteration:
@@ -134,7 +232,7 @@ def CP_TV_Tikhonov_sparseCSR_pycuda(
     numIterations=2000,
     isSavingEachIteration=True,
     L=None,
-    withTumor=True,
+    tumor_str="",
     device=None,
     max_saves=2000,
     show_logs=True,
@@ -203,7 +301,7 @@ def CP_TV_Tikhonov_sparseCSR_pycuda(
     sigma = np.float32(k_security / L_op_norm)
 
     # prepare y and normalization
-    y = y.astype(dtype).reshape(-1)
+    y = y.T.astype(dtype).reshape(-1)
     maxy = float(np.max(np.abs(y))) if y.size > 0 else 0.0
     if maxy > 0:
         y_normed = (y / maxy).copy()
@@ -286,7 +384,6 @@ def CP_TV_Tikhonov_sparseCSR_pycuda(
         step = max(1, numIterations // max_saves)
         save_indices_all = list(range(0, numIterations + 1, step))
 
-    tumor_str = "WITH TUMOR" if withTumor else "WITHOUT TUMOR"
     device_str = f"GPU no.{torch.cuda.current_device()}" if device.type == "cuda" else "CPU"
     if show_logs:
         if (alpha is None or alpha == 0) and (beta is None or beta == 0):
@@ -294,10 +391,13 @@ def CP_TV_Tikhonov_sparseCSR_pycuda(
             description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS) -- {tumor_str} -- {device_str}"
         if alpha is None or alpha == 0:
             print(f"Parameters: L={L_op_norm:.6e} tau={tau:.3e} sigma={sigma:.3e} beta={beta:.4e} lap_enabled={use_lap}")
-            description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS) -- {tumor_str} -- {device_str}"
+            description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS-Tikhonov) -- {tumor_str} -- {device_str}"
         elif beta is None or beta == 0:
             print(f"Parameters: L={L_op_norm:.6e} tau={tau:.3e} sigma={sigma:.3e} alpha={alpha:.4e} beta={beta:.4e} lap_enabled={use_lap}")
-            description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS) -- {tumor_str} -- {device_str}"
+            description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS-TV) -- {tumor_str} -- {device_str}"
+        else:
+            print(f"Parameters: L={L_op_norm:.6e} tau={tau:.3e} sigma={sigma:.3e} alpha={alpha:.4e} beta={beta:.4e} lap_enabled={use_lap}")
+            description = f"AOT-BioMaps -- Primal/Dual Reconstruction (LS-TV-Tikhonov) -- {tumor_str} -- {device_str}"
 
     I_reconMatrix = []
     saved_indices = []
@@ -311,9 +411,6 @@ def CP_TV_Tikhonov_sparseCSR_pycuda(
 
     # main loop
     try:
-
-        
-
         iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
         for it in iterator:
             # 1) dual p update (TV)
@@ -466,9 +563,10 @@ def CP_KL(
     numIterations=5000,
     isSavingEachIteration=True,
     L=None,
-    withTumor=True,
+    tumor_str="",
     device=None,
     max_saves=5000,
+    show_logs=True,
 ):
     """
     Chambolle-Pock algorithm for Kullback-Leibler (KL) divergence regularization.
@@ -527,12 +625,11 @@ def CP_KL(
     saved_indices = [0]
 
     # Description for progress bar
-    tumor_str = "WITH TUMOR" if withTumor else "WITHOUT TUMOR"
     device_str = f"GPU no.{torch.cuda.current_device()}" if device.type == "cuda" else "CPU"
     description = f"AOT-BioMaps -- Primal/Dual Reconstruction (KL) α:{alpha:.4f} L:{L:.4f} -- {tumor_str} -- {device_str}"
 
-    # Main loop
-    for iteration in trange(numIterations, desc=description):
+    iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+    for iteration in iterator:
         # Update q (proximal step for F*)
         q = prox_F_star(q + sigma * P(x_tilde) - sigma * y_flat, sigma, y_flat)
 

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/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}")

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/AOT_biomaps/__init__.py

@@ -85,7 +85,7 @@ from .AOT_Recon.AOT_PotentialFunctions.RelativeDifferences import *
 from .Config import config
 from .Settings import *
 
-__version__ = '2.9.281'
+__version__ = '2.9.291'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -135,6 +135,16 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/AOT_biomaps.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AOT_biomaps
-Version: 2.9.281
+Version: 2.9.291
 Summary: Acousto-Optic Tomography
 Home-page: https://github.com/LucasDuclos/AcoustoOpticTomography
 Author: Lucas Duclos

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AOT_biomaps
-Version: 2.9.281
+Version: 2.9.291
 Summary: Acousto-Optic Tomography
 Home-page: https://github.com/LucasDuclos/AcoustoOpticTomography
 Author: Lucas Duclos

{aot_biomaps-2.9.281 → aot_biomaps-2.9.291}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='AOT_biomaps',
-    version='2.9.281',
+    version='2.9.291',
     packages=find_packages(),
     include_package_data=True,
     
@@ -293,6 +293,16 @@ setup(
 
 
 
+
+
+
+
+
+
+
+
+
+