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

AOT_biomaps/AOT_Recon/AlgebraicRecon.py

@@ -45,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:
@@ -760,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, 
@@ -774,7 +771,6 @@ 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:
@@ -790,8 +786,7 @@ class AlgebraicRecon(Recon):
                                                         denominator_threshold=self.denominatorThreshold,
                                                         max_saves=self.maxSaves,
                                                         show_logs=show_logs,
-                                                        smatrixType=self.smatrixType,
-                                                        Z=self.Z_dim
+                                                        smatrixType=self.smatrixType
                                                 )
             else:
                 self.reconLaser, self.indices = LS(SMatrix=self.SMatrix, 
@@ -805,8 +800,7 @@ class AlgebraicRecon(Recon):
                                                         denominator_threshold=self.denominatorThreshold,
                                                         max_saves=self.maxSaves,
                                                         show_logs=show_logs,
-                                                        smatrixType=self.smatrixType,
-                                                        Z=self.Z_dim
+                                                        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}")

AOT_biomaps/AOT_Recon/ReconTools.py

@@ -380,6 +380,21 @@ def filter_radon(f, N, filter_type, Fc):
 
     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):
     """
@@ -409,4 +424,66 @@ def get_apodization_vector_gpu(matrix_sparse_obj):
     
     print(f"✅ Vecteur de fenêtrage (Z*X={Z*X}) généré et transféré sur GPU.")
     
-    return fenetre_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.279'
+__version__ = '2.9.300'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -135,6 +135,27 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.279.dist-info → aot_biomaps-2.9.300.dist-info}/METADATA

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

{aot_biomaps-2.9.279.dist-info → aot_biomaps-2.9.300.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=RfEi98jeLI6dtUnjRISgt1myI41kJwTXMkpSpf2VkH4,4220
+AOT_biomaps/__init__.py,sha256=GMzj8PLP9_pgyMqMfNa2NB6nka1mq-xDKBhb3hxBw8Q,4262
 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
@@ -18,30 +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/AOT_biomaps_kernels.cubin,sha256=iIp_WxETL4_BCJ0zErD4xm_Kpeey3ymjafdg9kmLd-s,82528
-AOT_biomaps/AOT_Recon/AlgebraicRecon.py,sha256=ZroHGhk6Yod4_6yNSlcB5Ew5XLAGO8Bc0dW_xCVJaig,47184
+AOT_biomaps/AOT_Recon/AOT_biomaps_kernels.cubin,sha256=Li4HdWpr65ONf82FqFAjZ8w3ob9UuJucDWGAAvBF77Q,83680
+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=RQbtK6aR0fIfIQ4wSRPIro8LEvjFG4uVCYwYSepxp44,16302
+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=SvUXNnavusUFuJSPZ-Au4BQZaV2z_aRyx6w5-TpRJ9E,22719
+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=n_YYZ8NbubpTe5dn_6UjCBsW6Koa0OkF5VdKzseWQeU,21279
-AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py,sha256=5w4klYKAct9_gnlyocIiJfDrQUdz_VhXQVSpfjrjvNU,7927
+AOT_biomaps/AOT_Recon/AOT_Optimizers/MLEM.py,sha256=TK-yE3zNLzGoau2dXALy__s5mavKt213HAaJ-gYfbzg,22427
+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=rZigEUe0d1reCBU-IT4LexbO5uUyps-ZkzhdH3j0PLc,12408
-AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=WTqHBeglUxRx-jy6CcoETgqYSSHYTwi2zR5NrJcPXGU,14449
+AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_CSR.py,sha256=RACc2P5oxmp0uPLAGnNj9mEtAxa_OlepNgCawKij3jI,12062
+AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=leJcC1dsWlvHqsZFJqdGD49w28AHIAVbUAVBumw0OIA,14378
 AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/__init__.py,sha256=8nou-hqjQjuCTLhoL5qv4EM_lMPFviAZAZKSPhi84jE,67
-aot_biomaps-2.9.279.dist-info/METADATA,sha256=cMJJ5rqoscZbvoGZ27y57VZ0aGzT7-2DLp_O4CFLyRI,700
-aot_biomaps-2.9.279.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.279.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.279.dist-info/RECORD,,
+aot_biomaps-2.9.300.dist-info/METADATA,sha256=2J-56TTNn-gQSZ0idm0PTSNQWc1KSmzvNXrfoH27O50,700
+aot_biomaps-2.9.300.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aot_biomaps-2.9.300.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.300.dist-info/RECORD,,