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

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/AOT_Recon/ReconTools.py

@@ -1,9 +1,11 @@
 import os
+from AOT_biomaps.AOT_Recon.AOT_SparseSMatrix import SparseSMatrix_CSR, SparseSMatrix_SELL
 import torch
 import numpy as np
+import pycuda.driver as drv
 from numba import njit, prange
 from torch_sparse import coalesce
-import cupyx.scipy.sparse as cpsparse
+from scipy.signal.windows import hann
 
 def load_recon(hdr_path):
     """
@@ -152,36 +154,72 @@ def ssim(img1, img2, win_size=7, k1=0.01, k2=0.03, L=1.0):
 def calculate_memory_requirement(SMatrix, y):
     """
     Calcule la mémoire requise (en Go) pour :
-    - SMatrix : np.ndarray (dense) ou cpsparse.csr_matrix (sparse)
+    - SMatrix : Matrice (np.ndarray, CuPy CSR, SparseSMatrix_CSR ou SparseSMatrix_SELL)
     - y : vecteur (NumPy ou CuPy, float32)
 
     Args:
-        SMatrix: np.ndarray ou cpsparse.csr_matrix
-        y: vecteur (float32)
+        SMatrix: Matrix object (np.ndarray, cpsparse.csr_matrix, SparseSMatrix_CSR, or SparseSMatrix_SELL)
+        y: Vector (float32)
     """
-    # 1. Mémoire pour SMatrix
-    if isinstance(SMatrix, cpsparse.csr_matrix):
-        # Matrice CSR CuPy
-        nnz = SMatrix.nnz
-        num_cols = SMatrix.shape[1]
-        size_SMatrix = nnz * (4 + 4) + (num_cols + 1) * 4  # data (float32) + indices (int32) + indptr (int32)
+    total_bytes = 0
+
+    # --- 1. Memory for SMatrix ---
+    
+    # 1.1. Custom Sparse Matrix (SELL/CSR)
+    if isinstance(SMatrix, (SparseSMatrix_SELL, SparseSMatrix_CSR)):
+        # We rely on the getMatrixSize method, which we fixed to track all host/GPU bytes.
+        # This is the most reliable way to estimate memory for custom GPU-backed structures.
+        try:
+            matrix_size_gb = SMatrix.getMatrixSize()
+            if isinstance(matrix_size_gb, dict) and 'error' in matrix_size_gb:
+                raise ValueError(f"SMatrix allocation error: {matrix_size_gb['error']}")
+            
+            # Convert GB back to bytes (1 GB = 1024^3 bytes)
+            size_SMatrix = matrix_size_gb * (1024 ** 3)
+            total_bytes += size_SMatrix
+            print(f"SMatrix (Custom Sparse) size: {matrix_size_gb:.3f} GB")
+
+        except AttributeError:
+            raise AttributeError("Custom Sparse Matrix must implement the getMatrixSize() method.")
+    
+    # 1.2. NumPy Dense Array (Standard)
     elif isinstance(SMatrix, np.ndarray):
-        # Tableau NumPy dense (float32)
+        # Dense NumPy array (float32)
         size_SMatrix = SMatrix.nbytes
+        total_bytes += size_SMatrix
+        print(f"SMatrix (NumPy Dense) size: {size_SMatrix / (1024 ** 3):.3f} GB")
+
+    # 1.3. CuPy CSR Matrix (Standard Sparse CuPy)
+    # Note: Requires CuPy to be imported, which is usually done outside this function.
+    # Assuming 'cpsparse.csr_matrix' is available in the environment if this path is taken.
+    elif 'cupy.sparse' in str(type(SMatrix)): # Using string check for type safety outside CuPy context
+        # CuPy CSR matrix structure: data (float32), indices (int32), indptr (int32)
+        nnz = SMatrix.nnz
+        num_rows = SMatrix.shape[0]
+        size_data = nnz * 4        # float32 = 4 bytes
+        size_indices = nnz * 4     # int32 = 4 bytes
+        size_indptr = (num_rows + 1) * 4 # int32 = 4 bytes
+        size_SMatrix = size_data + size_indices + size_indptr
+        total_bytes += size_SMatrix
+        print(f"SMatrix (CuPy CSR) size: {size_SMatrix / (1024 ** 3):.3f} GB")
+
     else:
-        raise ValueError("SMatrix doit être un np.ndarray ou une matrice CSR CuPy.")
+        raise ValueError("SMatrix must be a np.ndarray, cpsparse.csr_matrix, or a custom SparseSMatrix object (CSR/SELL).")
 
-    # 2. Mémoire pour y (float32)
+    # --- 2. Memory for Vector y ---
+    
+    # Check if y is a CuPy array or NumPy array (assuming float32 based on docstring)
     if hasattr(y, 'nbytes'):
         size_y = y.nbytes
+        total_bytes += size_y
+        print(f"Vector y size: {size_y / (1024 ** 3):.3f} GB")
     else:
-        size_y = np.prod(y.shape) * 4  # float32
+        # Fallback if object doesn't expose nbytes (e.g., custom buffer), but usually array objects do.
+        raise ValueError("Vector y must be an array type exposing the .nbytes attribute.")
 
-    # Total en Go
-    total_bytes = size_SMatrix + size_y
-    total_GB = total_bytes / 1024**3
 
-    return total_GB
+    # --- 3. Final Result ---
+    return total_bytes / (1024 ** 3)
 
 
 def check_gpu_memory(device_index, required_memory, show_logs=True):
@@ -341,3 +379,111 @@ def filter_radon(f, N, filter_type, Fc):
     FILTER = FILTER * np.exp(-2 * (np.abs(f) / Fc)**10)
 
     return FILTER
+
+def compute_TV_cpu(x, Z, X, isotropic=False):
+    """
+    Compute total variation of x (1D flattened of shape Z*X).
+    isotropic=False -> anisotropic (sum |dx| + |dy|)
+    isotropic=True -> isotropic sqrt(dx^2 + dy^2)
+    """
+    x2d = x.reshape(Z, X)
+    dx = np.diff(x2d, axis=1)
+    dy = np.diff(x2d, axis=0)
+    if isotropic:
+        # pad to original size for consistent measure (we only need sum of norms)
+        mags = np.sqrt(dx**2 + dy**2)
+        return float(np.sum(mags))
+    else:
+        return float(np.sum(np.abs(dx)) + np.sum(np.abs(dy)))
+
+def get_apodization_vector_gpu(matrix_sparse_obj):
+    """
+    Génère un vecteur de fenêtrage 2D (Hanning) pour l'apodisation 
+    de la matrice système A et le transfère sur le GPU.
+    Ce vecteur doit être multiplié par les colonnes de A (pixels Z*X).
+    """
+    Z = matrix_sparse_obj.Z
+    X = matrix_sparse_obj.X
+    
+    # 1. Génération des fenêtres 1D sur l'axe X et Z
+    # Forte apodisation latérale (X) pour cibler l'artefact de bordure.
+    fenetre_x = hann(X).astype(np.float32)
+    
+    # Fenêtre uniforme en profondeur (Z), car l'artefact est surtout latéral.
+    fenetre_z = np.ones(Z, dtype=np.float32)
+    
+    # 2. Création de la matrice de fenêtre 2D (Z, X)
+    fenetre_2d = np.outer(fenetre_z, fenetre_x)
+    
+    # 3. Vectorisation (Z*X)
+    fenetre_vectorisee = fenetre_2d.flatten()
+    
+    # 4. Transfert sur GPU (mémoire contiguë)
+    fenetre_gpu = drv.mem_alloc(fenetre_vectorisee.nbytes)
+    drv.memcpy_htod(fenetre_gpu, fenetre_vectorisee)
+    
+    print(f"✅ Vecteur de fenêtrage (Z*X={Z*X}) généré et transféré sur GPU.")
+    
+    return fenetre_gpu
+
+def _call_axpby(axpby_kernel, out_ptr, x_ptr, y_ptr, a, b, N, stream, block):
+    grid = ((int(N) + block - 1) // block, 1, 1)
+    axpby_kernel(out_ptr, x_ptr, y_ptr,
+                    np.float32(a), np.float32(b),
+                    np.int32(N),
+                    block=(block, 1, 1), grid=grid, stream=stream)
+
+def _call_minus_axpy(minus_kernel, out_ptr, z_ptr, a, N, stream, block):
+    grid = ((int(N) + block - 1) // block, 1, 1)
+    minus_kernel(out_ptr, z_ptr, np.float32(a), np.int32(N),
+                    block=(block, 1, 1), grid=grid, stream=stream)
+
+def power_method_estimate_L__SELL(SMatrix, stream, n_it=20, block_size=256):
+    """Estimate ||A||^2 using power method (uses your projection/backprojection kernels)."""
+    TN = int(SMatrix.N * SMatrix.T)
+    ZX = int(SMatrix.Z * SMatrix.X)
+    proj = SMatrix.sparse_mod.get_function("projection_kernel__SELL")
+    back = SMatrix.sparse_mod.get_function("backprojection_kernel__SELL")
+    TN_i = np.int32(TN)
+    ZX_i = np.int32(ZX)
+    slice_h = np.int32(SMatrix.slice_height)
+    grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
+    block_1D = (block_size, 1, 1)
+
+    dtype = np.float32
+    x_host = np.random.randn(ZX).astype(dtype)
+    x_host /= np.linalg.norm(x_host) + 1e-12
+    x_gpu = drv.mem_alloc(x_host.nbytes)
+    drv.memcpy_htod_async(x_gpu, x_host, stream)
+    q_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
+    ATq_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+    ATq_host = np.empty(ZX, dtype=dtype)
+
+    for _ in range(n_it):
+        proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                x_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+        drv.memset_d32_async(ATq_gpu, 0, ZX, stream)
+        back(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                q_gpu, ATq_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+        stream.synchronize()
+        drv.memcpy_dtoh(ATq_host, ATq_gpu)
+        norm = np.linalg.norm(ATq_host)
+        if norm < 1e-12:
+            break
+        x_host = ATq_host / norm
+        drv.memcpy_htod_async(x_gpu, x_host, stream)
+    # final Rayleigh quotient
+    proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+            x_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+    drv.memset_d32_async(ATq_gpu, 0, ZX, stream)
+    back(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+            q_gpu, ATq_gpu, TN_i, slice_h, block=block_1D, grid=grid_rows, stream=stream)
+    stream.synchronize()
+    drv.memcpy_dtoh(ATq_host, ATq_gpu)
+    L_sq = float(np.dot(x_host, ATq_host))
+    for g in (x_gpu, q_gpu, ATq_gpu):
+        try:
+            g.free()
+        except:
+            pass
+    return max(L_sq, 1e-6)

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.261'
+__version__ = '2.9.318'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -125,3 +125,60 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

{aot_biomaps-2.9.261.dist-info → aot_biomaps-2.9.318.dist-info}/METADATA

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

{aot_biomaps-2.9.261.dist-info → aot_biomaps-2.9.318.dist-info}/RECORD

@@ -1,6 +1,6 @@
 AOT_biomaps/Config.py,sha256=ghEOP1n8aO1pR-su13wMeAZAxZRfry5hH67NbtZ8SqI,3614
 AOT_biomaps/Settings.py,sha256=v8fPhnvvcfBJP29m1RLOTEr3jndGLGwbUiORXmsj2Bo,2853
-AOT_biomaps/__init__.py,sha256=EAyX3lRoiynQtskCWC5xS9exXzUs8hl6NuOWBYnaHfQ,4184
+AOT_biomaps/__init__.py,sha256=JzWlV3kQ0eqvYRCkDaPawjpBhG0lagMhcLDnBLaY5Fs,4298
 AOT_biomaps/AOT_Acoustic/AcousticEnums.py,sha256=s5kXa6jKzbS4btwbubrVcynLOr0yg5tth5vL_FGfbMk,1802
 AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=al7xXKMY5e-qQQ7nrQVPVAmqYiB320OluNlY6ti8iKc,7539
 AOT_biomaps/AOT_Acoustic/FocusedWave.py,sha256=3kGKKDx_3Msy5COYqIwzROPORGWvNjw8UsDanBfkMXE,11037
@@ -10,7 +10,7 @@ AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=jTLVlOhYLWJb5MxZPxhq3OFVlz2Mco
 AOT_biomaps/AOT_Acoustic/__init__.py,sha256=t9M2rRqa_L9pk7W2FeELTkHEMuP4DBr4gBRldMqsQbg,491
 AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=RdmhRF1i0KAlpsP7_wnZ7F4J27br3eUc4XR91Qq7C64,44158
 AOT_biomaps/AOT_Experiment/Focus.py,sha256=B2nBawmv-NG2AWJx9zgQ8GlN6aFB9FwTSqX-M-phKXg,3193
-AOT_biomaps/AOT_Experiment/Tomography.py,sha256=Ri83b4GMrxJO60qWsK9JInS9a7HU2Q8uqpjD3Xkl9OY,24488
+AOT_biomaps/AOT_Experiment/Tomography.py,sha256=JO-yLOSnCd8Da2HC9uJ1uI0GD-_Ca1PX9URzAk_EAiQ,31149
 AOT_biomaps/AOT_Experiment/__init__.py,sha256=H9zMLeBLA6uhbaHohAa-2u5mDDxqJi8oE5c6tShdQp8,308
 AOT_biomaps/AOT_Experiment/_mainExperiment.py,sha256=zSfuNrsz7nhiKrGIdK6CAXjlI2T6qYC5-JXHFgPNzhc,24674
 AOT_biomaps/AOT_Optic/Absorber.py,sha256=jEodzRy7gkEH-wbazVasRQiri0dU16BfapmR-qnTSvM,867
@@ -18,29 +18,30 @@ AOT_biomaps/AOT_Optic/Laser.py,sha256=uzQwxswjU0kZWix3CmZLoWmhsBa3VhN27STprNv-xB
 AOT_biomaps/AOT_Optic/OpticEnums.py,sha256=b349_JyjHqQohmjK4Wke-A_HLGaqb3_BKbyUqFC4jxY,499
 AOT_biomaps/AOT_Optic/__init__.py,sha256=HSUVhfz0NzwHHZZ9KP9Xyfu33IgP_rYJX86J-gEROlo,321
 AOT_biomaps/AOT_Optic/_mainOptic.py,sha256=Wk63CcgWbU-ygMfjNK80islaUbGGJpTXgZY3_C2KQNY,8179
-AOT_biomaps/AOT_Recon/AlgebraicRecon.py,sha256=DG9mLMYXRX6cMYjbRRoXAAuGxQQIQKq3lat6rYn5XWM,46099
+AOT_biomaps/AOT_Recon/AOT_biomaps_kernels.cubin,sha256=JWy-bdtBTZdnNlDbJGZKwXyF-2u1wICtmlOC_YxEL6o,82528
+AOT_biomaps/AOT_Recon/AlgebraicRecon.py,sha256=CGBXZyYEZ3TOTFOKSt-h7NGuFbuI9PNr3YTWTbSLxDo,46832
 AOT_biomaps/AOT_Recon/AnalyticRecon.py,sha256=RaQ5AJ1HUmSct0BgjZ0GWSJg7SALCn3Q0laqj1yyhAE,7123
 AOT_biomaps/AOT_Recon/BayesianRecon.py,sha256=RnnPa-tTcvirwiNPnCRZnSM4NWeEEltYET-piBbp34g,12671
 AOT_biomaps/AOT_Recon/DeepLearningRecon.py,sha256=RfVcEsi4GeGqJn0_SPxwQPQx6IQjin79WKh2UarMRLI,1383
-AOT_biomaps/AOT_Recon/PrimalDualRecon.py,sha256=-7dqUxKXbHt7yR1I1kGcu1TOXn05ik6QoDDsuM0QvNU,10310
+AOT_biomaps/AOT_Recon/PrimalDualRecon.py,sha256=JbFhxiyUoSTnlJgHbOWIfUUwhwfZoi39RJMnfkagegY,16504
 AOT_biomaps/AOT_Recon/ReconEnums.py,sha256=KAf55RqHAr2ilt6pxFrUBGQOn-7HA8NP6TyL-1FNiXo,19714
-AOT_biomaps/AOT_Recon/ReconTools.py,sha256=NRTr13hEohXIyAw6p56CEsVFR4O0bDM-ijcPOs-cpxw,12936
+AOT_biomaps/AOT_Recon/ReconTools.py,sha256=A4IQV7IETu9MgYr7hjLNPTImzjf8CEU4cZ2e0EgJNWA,19878
 AOT_biomaps/AOT_Recon/__init__.py,sha256=xs_argJqXKFl76xP7-jiUc1ynOEEtY7XZ0gDxD5uVZc,246
 AOT_biomaps/AOT_Recon/_mainRecon.py,sha256=exoa2UBMfMHjemxAU9dW0mhEfsP6Oe1qjSfrTrgbIcY,13125
 AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py,sha256=qA1n722GLQJH3V8HcLr5q_GxEwBS_NRlIT3E6JZk-Ag,9479
-AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py,sha256=N7v1xN9I-adIe3c20LN9Drc4-fBSLc9SEmJS8B3Zmag,4343
+AOT_biomaps/AOT_Recon/AOT_Optimizers/LS.py,sha256=bCu1rKzFXPbYQ7jV3L3E_jVQpb6LIEC5MIlN1-mCNdY,22814
 AOT_biomaps/AOT_Recon/AOT_Optimizers/MAPEM.py,sha256=vQLCB0L4FSXJKn2_6kdIdWrI6WZ82KuqUh7CSqBGVuo,25766
-AOT_biomaps/AOT_Recon/AOT_Optimizers/MLEM.py,sha256=PoizVH4ifMyfJ7QSLsHP1gwKuUh9LLGPs_OaaZavpiM,19597
-AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py,sha256=5w4klYKAct9_gnlyocIiJfDrQUdz_VhXQVSpfjrjvNU,7927
+AOT_biomaps/AOT_Recon/AOT_Optimizers/MLEM.py,sha256=4omsqzHEZJfv0mEfmxfK71IovDbRstVE4x3Flf4cR3o,22441
+AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py,sha256=oSojwug5mcZedKOWAV7YPMlCp0Qy_Aed0fjHRuyZWpo,28622
 AOT_biomaps/AOT_Recon/AOT_Optimizers/__init__.py,sha256=tNGVulINaqQZzcs5cvCMAT5ypGdoFWRnxtl9y7ePECk,106
 AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/Huber.py,sha256=dRd1t5OBag_gVmfji3L0QrA1GJ_702LcCkLH32Bot0M,3285
 AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/Quadratic.py,sha256=wTbzcXxMdEl9ReEXrL43DOJQecokBwJYU_s2kQUASZY,2545
 AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/RelativeDifferences.py,sha256=ZlWaKsNPCMfy4fWxYFT2pSoKMbysQkJH4N1WbbWncq4,2493
 AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/__init__.py,sha256=RwrJdLOFbAFBFnRxo5xdlOyeZgtQRDaRWDN9-uCGUiY,84
-AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_CSR.py,sha256=tk8eZHyTpey4TNDmoFL9w88LjerviQmI5YeV8M2Iuq4,10689
-AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=nH9gBea7p_V5LaewFAG-Bkfp_YepMTExoaQcbRf4_Mk,14426
+AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_CSR.py,sha256=RACc2P5oxmp0uPLAGnNj9mEtAxa_OlepNgCawKij3jI,12062
+AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=ti3dZQsb_Uu62C7Bn65Z-yf-R5NKCFsmnBT5GlLd_HY,15138
 AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/__init__.py,sha256=8nou-hqjQjuCTLhoL5qv4EM_lMPFviAZAZKSPhi84jE,67
-aot_biomaps-2.9.261.dist-info/METADATA,sha256=7mJL-l-m4N7m-ScwYoV1Hey0n6dO6hHESAjzGHXgqm8,700
-aot_biomaps-2.9.261.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.261.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.261.dist-info/RECORD,,
+aot_biomaps-2.9.318.dist-info/METADATA,sha256=ynPqtHAnkFQBks7GrB91EadzCQxdCC7PFc0kHG3H-Zo,700
+aot_biomaps-2.9.318.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aot_biomaps-2.9.318.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.318.dist-info/RECORD,,