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

AOT_biomaps/AOT_Acoustic/AcousticTools.py

@@ -157,8 +157,6 @@ def calculate_envelope_squared(field):
         print(f"Erreur dans calculate_envelope_squared: {e}")
         raise
 
-
-
 def getPattern(pathFile):
     """
     Get the pattern from a file path.

AOT_biomaps/AOT_Experiment/ExperimentTools.py

@@ -0,0 +1,60 @@
+import numpy as np
+
+def calc_mat_os(xm, fx, dx, bool_active_list, signal_type):
+    num_els = len(xm)
+    
+    # Cas limite : Fréquence nulle (Décimation 0)
+    if fx == 0:
+        if signal_type == 'cos':
+            # cos(0) = 1 -> Tout est actif
+            mask = np.ones(num_els, dtype=bool)
+        else:
+            # sin(0) = 0 -> Tout est inactif
+            mask = np.zeros(num_els, dtype=bool)
+    else:
+        # Calcul normal pour fx > 0
+        half_period_elements = round(1 / (2 * fx * dx))
+        
+        # Sécurité : si fx est tellement grand que half_period < 1
+        half_period_elements = max(1, half_period_elements)
+        
+        indices = np.arange(num_els)
+        if signal_type == 'cos':
+            mask = ((indices // half_period_elements) % 2 == 0)
+        else:
+            # Déphasage de 90° pour le sinus : on décale d'une demi-demi-période
+            shift = half_period_elements // 2
+            mask = (((indices + shift) // half_period_elements) % 2 == 0)
+            
+    return np.tile(mask[:, np.newaxis], (1, bool_active_list.shape[1]))
+
+def convert_to_hex_list(matrix):
+    """
+    Convertit une matrice binaire en liste de strings hexa (paquets de 4 bits).
+    Chaque colonne devient une chaîne de caractères.
+    """
+    n_els, n_scans = matrix.shape
+    
+    # 1. Padding pour s'assurer que n_els est multiple de 4
+    remainder = n_els % 4
+    if remainder != 0:
+        padding = np.zeros((4 - remainder, n_scans))
+        matrix = np.vstack([matrix, padding])
+    
+    # 2. Reshape pour isoler des blocs de 4 bits (nibbles)
+    # Shape résultante : (Nombre de blocs, 4 bits, Nombre de scans)
+    blocks = matrix.reshape(-1, 4, n_scans)
+    
+    # 3. Calcul de la valeur décimale de chaque bloc (0 à 15)
+    # On considère le premier élément comme le bit de poids faible (LSB)
+    weights = np.array([1, 2, 4, 8]).reshape(1, 4, 1)
+    dec_values = np.sum(blocks * weights, axis=1).astype(int)
+    
+    # 4. Conversion en caractères Hexadécimaux
+    # On définit la table de conversion pour la rapidité
+    hex_table = np.array(list("0123456789abcdef"))
+    hex_matrix = hex_table[dec_values]
+    
+    # 5. Assemblage des chaînes (de l'élément N vers 0 pour l'ordre Shift Register standard)
+    return ["".join(hex_matrix[::-1, col]) for col in range(n_scans)]
+

AOT_biomaps/AOT_Experiment/Tomography.py

@@ -2,6 +2,7 @@ from ._mainExperiment import Experiment
 from AOT_biomaps.AOT_Acoustic.AcousticEnums import WaveType
 from AOT_biomaps.AOT_Acoustic.StructuredWave import StructuredWave
 from AOT_biomaps.Config import config
+from AOT_biomaps.AOT_Experiment.ExperimentTools import calc_mat_os, convert_to_hex_list
 import os
 import psutil
 import numpy as np
@@ -273,7 +274,7 @@ class Tomography(Experiment):
                     line = f"({coords}, {angles})\n"
                     file.write(line)
 
-    def generateActiveList(self, N):
+    def generateActiveList(self, N, decimations = None, angles = None):
         """
         Génère une liste de patterns d'activation équilibrés et réguliers.
         Args:
@@ -281,13 +282,136 @@ class Tomography(Experiment):
         Returns:
             list: Liste de strings au format "hex_angle".
         """
+        if decimations is not None and angles is not None:
+            self._genereate_patterns_from_decimations(decimations, angles)
         if N < 1:
             raise ValueError("N must be a positive integer.")
         self.patterns = self._generate_patterns(N)
         if not self._check_patterns(self.patterns):
             raise ValueError("Generated patterns failed validation.")
+        
+    
+
+    def selectAngles(self, angles):
+
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        newAcousticFields = []
+        index = []
+        for i,field in enumerate(self.AcousticFields):
+            if field.angle in angles:
+                newAcousticFields.append(field)
+                index.append(i)
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, index]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
+        self.AcousticFields = newAcousticFields
+
+    def selectPatterns(self, pattern_names):
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        newAcousticFields = []
+        index = []
+        for i,field in enumerate(self.AcousticFields):
+            if field.pattern.activeList in pattern_names:
+                newAcousticFields.append(field)
+                index.append(i)
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, index]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, index]
+        self.AcousticFields = newAcousticFields
+
+    def selectRandom(self,N):
+        if self.AOsignal_withTumor is None and self.AOsignal_withoutTumor is None:
+            raise ValueError("AO signals are not initialized. Please load or generate the AO signals first.")
+        if self.AcousticFields is None or len(self.AcousticFields) == 0:
+            raise ValueError("AcousticFields is not initialized. Please generate the system matrix first.")
+        if N > len(self.AcousticFields):
+            raise ValueError("N is larger than the number of available AcousticFields.")
+        indices = np.random.choice(len(self.AcousticFields), size=N, replace=False)
+        newAcousticFields = [self.AcousticFields[i] for i in indices]
+        if self.AOsignal_withTumor is not None:
+            self.AOsignal_withTumor = self.AOsignal_withTumor[:, indices]    
+        if self.AOsignal_withoutTumor is not None:
+            self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:, indices]
+        self.AcousticFields = newAcousticFields
+
+    def _genereate_patterns_from_decimations(self, decimations, angles):
+        if isinstance(decimations, list): decimations = np.array(decimations)
+        if isinstance(angles, list): angles = np.array(angles)
+
+        angles = np.sort(angles)
+        decimations = np.sort(decimations)
+
+        num_elements = self.params.acoustic['num_elements']
+        dx_mm = self.params.general['dx'] * 1e3
+
+        # --- Calcul du nombre de Scans ---
+        if 0 in decimations:
+            Nscans = 4 * angles.shape[0] * (decimations.shape[0] - 1) + angles.shape[0]
+            offSet = angles.shape[0]
+        else:
+            Nscans = 4 * angles.shape[0] * decimations.shape[0]
+            offSet = 0
+
+        ActiveLIST = np.ones((num_elements, Nscans))
+        Xm = np.arange(1, num_elements + 1) * dx_mm
+        dFx = 1 / (num_elements * dx_mm)
 
-    def _generate_patterns(self, N):
+        # On traite séparément les décimations non nulles pour la boucle
+        active_decimations = decimations[decimations != 0]
+
+        for i_dec in range(len(active_decimations)):
+            idx_base = (np.arange(len(angles))) + (i_dec * 4 * len(angles)) + offSet
+            
+            Icos   = idx_base
+            Incos  = idx_base + len(angles)
+            Isin   = idx_base + 2 * len(angles)
+            Insin  = idx_base + 3 * len(angles)
+
+            fx = dFx * active_decimations[i_dec]
+
+            # Remplissage des 4 phases
+            valid_icos = Icos[Icos < Nscans]
+            if valid_icos.size > 0:
+                ActiveLIST[:, valid_icos] = calc_mat_os(Xm, fx, dx_mm, ActiveLIST[:, valid_icos], 'cos')
+                if (Incos < Nscans).any():
+                    ActiveLIST[:, Incos[Incos < Nscans]] = 1 - ActiveLIST[:, valid_icos]
+
+            valid_isin = Isin[Isin < Nscans]
+            if valid_isin.size > 0:
+                ActiveLIST[:, valid_isin] = calc_mat_os(Xm, fx, dx_mm, ActiveLIST[:, valid_isin], 'sin')
+                if (Insin < Nscans).any():
+                    ActiveLIST[:, Insin[Insin < Nscans]] = 1 - ActiveLIST[:, valid_isin]
+
+        # --- Conversion au format attendu ---
+        # 1. On convertit toute la matrice en liste de strings Hexa
+        hexa_list = convert_to_hex_list(ActiveLIST)
+
+        # 2. Fonction interne de formatage d'angle (pour coller à votre ancien code)
+        def format_angle(a):
+            return f"{'1' if a < 0 else '0'}{abs(a):02d}"
+
+        # 3. Construction de la liste de dictionnaires
+        patterns = []
+        for i in range(Nscans):
+            # On retrouve l'angle correspondant à l'index i
+            # La logique est cyclique sur la taille de 'angles'
+            angle_val = angles[i % len(angles)]
+            
+            hex_pattern = hexa_list[i]
+            pair = f"{hex_pattern}_{format_angle(angle_val)}"
+            patterns.append({"fileName": pair})
+
+        return patterns
+    
+    def _generate_patterns(self, N,angles = None):
         def format_angle(a):
             return f"{'1' if a < 0 else '0'}{abs(a):02d}"
 
@@ -298,7 +422,13 @@ class Tomography(Experiment):
             return hex_string
 
         num_elements = self.params.acoustic['num_elements']
-        angle_choices = list(range(-20, 21))
+        if angles is None:
+            angle_choices = list(range(-20, 21))
+        else:
+            # convert np.array to list if necessary
+            if isinstance(angles, np.ndarray):
+                angles = angles.tolist()
+            angle_choices = angles
 
         # 1. Trouver TOUS les diviseurs PAIRS de num_elements (y compris num_elements)
         divs = [d for d in range(2, num_elements + 1) if num_elements % d == 0 and d % 2 == 0]
@@ -390,6 +520,80 @@ class Tomography(Experiment):
 
         return True
 
+    def applyApodisation(self, alpha=0.3, divergence_deg=0.5):
+        """
+        Applique une apodisation dynamique sur les champs acoustiques stockés dans l'objet.
+        L'apodisation suit l'angle d'émission et la divergence naturelle du faisceau pour
+        supprimer les lobes de diffraction (artefacts de bord) sans toucher au signal utile.
+        Args:
+            probe_width (float): Largeur physique active de la sonde (ex: 40e-3 pour 40mm).
+            alpha (float): Paramètre de Tukey (0.0=rectangle, 1.0=hann). 0.3 est un bon compromis.
+            divergence_deg (float): Angle d'ouverture du masque pour suivre l'élargissement du faisceau.
+                                    0.0 = Droit, 0.5 = Légère ouverture (conseillé).
+        """
+        print(f"Applying apodization (Alpha={alpha}, Div={divergence_deg}°) on {len(self.AcousticFields)} fields...")
+        
+        probe_width = self.params.acoustic['num_elements'] * self.params.acoustic['element_width']
+
+        for i in trange(len(self.AcousticFields), desc="Apodisation"):
+            # 1. Récupération des données et de l'angle
+            field = self.AcousticFields[i].field  # Peut être (Z, X) ou (Time, Z, X)
+            angle = self.AcousticFields[i].angle  # L'angle de l'onde plane
+
+            # 2. Récupération ou construction des axes physiques
+            nz, nx = field.shape[-2:]
+
+            if hasattr(self, 'x_axis') and self.x_axis is not None:
+                x_axis = self.x_axis
+            else:
+                # Génération par défaut centrée sur 0 (ex: -20mm à +20mm)
+                x_axis = np.linspace(-probe_width/2, probe_width/2, nx)
+
+            if hasattr(self, 'z_axis') and self.z_axis is not None:
+                z_axis = self.z_axis
+            else:
+                # Génération par défaut (ex: 0 à 40mm, basé sur un pitch standard ou arbitraire)
+                estimated_depth = 40e-3  # Valeur arbitraire si inconnue
+                z_axis = np.linspace(0, estimated_depth, nz)
+
+            # 3. Préparation des grilles pour le masque
+            Z, X = np.meshgrid(z_axis, x_axis, indexing='ij')
+
+            # 4. Calcul de la géométrie orientée (Steering)
+            angle_rad = np.deg2rad(angle)
+            X_aligned = X - Z * np.tan(angle_rad)
+
+            # 5. Calcul de la largeur dynamique du masque (Divergence)
+            div_rad = np.deg2rad(divergence_deg)
+            current_half_width = (probe_width / 2.0) + Z * np.tan(div_rad)
+
+            # 6. Normalisation et création du masque Tukey
+            X_norm = np.divide(X_aligned, current_half_width, out=np.zeros_like(X_aligned), where=current_half_width!=0)
+
+            mask = np.zeros_like(X_norm)
+            plateau_threshold = 1.0 * (1 - alpha)
+
+            # Zone centrale (plateau = 1)
+            mask[np.abs(X_norm) <= plateau_threshold] = 1.0
+
+            # Zone de transition (cosinus)
+            transition_indices = (np.abs(X_norm) > plateau_threshold) & (np.abs(X_norm) <= 1.0)
+            if np.any(transition_indices):
+                x_trans = np.abs(X_norm[transition_indices]) - plateau_threshold
+                width_trans = 1.0 * alpha
+                mask[transition_indices] = 0.5 * (1 + np.cos(np.pi * x_trans / width_trans))
+
+            # 7. Application du masque (Gestion 2D vs 3D)
+            if field.ndim == 3:
+                field_apodized = field * mask[np.newaxis, :, :]
+            else:
+                field_apodized = field * mask
+
+            # 8. Mise à jour de l'objet
+            self.AcousticFields[i].field = field_apodized
+
+        print("Apodisation done.")
+
     # PRIVATE METHODS
     def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False, nameBlock=None):
         if self.patterns is None:

AOT_biomaps/AOT_Recon/AOT_Optimizers/MLEM.py

@@ -58,11 +58,11 @@ def MLEM(
     # Dispatch to the appropriate implementation
     if use_gpu:
             if smatrixType == SMatrixType.CSR:
-                return MLEM_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs)
+                return MLEM_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, max_saves, denominator_threshold, show_logs)
             elif smatrixType == SMatrixType.SELL:
-                return MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs)
+                return MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, max_saves, denominator_threshold, show_logs)
             elif smatrixType == SMatrixType.DENSE:
-                return _MLEM_single_GPU(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold,show_logs)
+                return _MLEM_single_GPU(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, max_saves, denominator_threshold,show_logs)
             else:
                 raise ValueError("Unsupported SMatrixType for GPU MLEM.")
     else:
@@ -228,49 +228,60 @@ def _MLEM_CPU_opti(SMatrix, y, numIterations, isSavingEachIteration, tumor_str,
         print(f"Error in optimized CPU MLEM: {type(e).__name__}: {e}")
         return None, None
     
-def MLEM_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs=True):
+def MLEM_sparseCSR_pycuda(
+    SMatrix,
+    y,
+    numIterations,
+    isSavingEachIteration,
+    tumor_str,
+    max_saves,
+    denominator_threshold,
+    show_logs=True,
+):
     """
-    SMatrix: instance of SparseMatrixGPU (already allocated)
-    y: measured data (1D np.float32 of length TN)
-
-    Assumptions:
-    - SMatrix.values_gpu and SMatrix.col_ind_gpu and SMatrix.row_ptr_gpu are device pointers
-    - SMatrix.norm_factor_inv_gpu exists
-    - SMatrix.ctx is the PyCUDA context for the target GPU.
+    Robust MLEM implementation for CSR SMatrix using PyCUDA kernels.
+    Expects SMatrix to be SparseSMatrix_CSR with attributes:
+      - values_gpu, col_ind_gpu, row_ptr_gpu (device pointers)
+      - norm_factor_inv_gpu (device pointer)
+      - sparse_mod (loaded module with kernels)
+      - ctx (PyCUDA context)
+    Returns (saved_theta_list, saved_indices) if isSavingEachIteration else (final_theta, None)
     """
-    
-    # We use a final_result placeholder to ensure it's defined outside the try block
     final_result = None
-    
+
+    # Local holders to free in finally
+    y_gpu = q_flat_gpu = e_flat_gpu = c_flat_gpu = theta_flat_gpu = None
+
     try:
         if not isinstance(SMatrix, SparseSMatrix_CSR):
             raise TypeError("SMatrix must be a SparseSMatrix_CSR object")
 
-        # --- CONTEXT FIX: Push the context associated with SMatrix ---
-        # This ensures all subsequent PyCUDA operations use the correct GPU/context.
-        if SMatrix.ctx:
+        # push context (if provided)
+        popped_ctx = False
+        if getattr(SMatrix, "ctx", None):
             SMatrix.ctx.push()
-        # -----------------------------------------------------------
+            popped_ctx = True
 
         dtype = np.float32
-        TN = SMatrix.N * SMatrix.T
-        ZX = SMatrix.Z * SMatrix.X
-        # Ensure Z and X are correctly defined for reshaping
-        Z = SMatrix.Z 
-        X = SMatrix.X
-
-        if show_logs:
-            # We assume SMatrix was initialized using the correct device index.
-            print(f"Executing on GPU device index: {SMatrix.device.primary_context.device.name()}")
-            print(f"Dim X: {X}, Dim Z: {Z}, TN: {TN}, ZX: {ZX}")
-
-        # streams
+        TN = int(SMatrix.N * SMatrix.T)
+        ZX = int(SMatrix.Z * SMatrix.X)
+        Z = int(SMatrix.Z)
+        X = int(SMatrix.X)
+
+        # Make sure required GPU pointers exist
+        if getattr(SMatrix, "values_gpu", None) is None or getattr(SMatrix, "col_ind_gpu", None) is None or getattr(SMatrix, "row_ptr_gpu", None) is None:
+            raise RuntimeError("SMatrix is missing GPU buffers (values_gpu / col_ind_gpu / row_ptr_gpu)")
+
+        if getattr(SMatrix, "norm_factor_inv_gpu", None) is None:
+            raise RuntimeError("SMatrix.norm_factor_inv_gpu not available on GPU")
+
+        # stream for async operations
         stream = drv.Stream()
 
-        # allocate device buffers
-        y = y.T.flatten().astype(np.float32)
-        y_gpu = drv.mem_alloc(y.nbytes)
-        drv.memcpy_htod_async(y_gpu, y.astype(dtype), stream)
+        # prepare device buffers
+        y_arr = np.ascontiguousarray(y.T.flatten().astype(np.float32))
+        y_gpu = drv.mem_alloc(y_arr.nbytes)
+        drv.memcpy_htod_async(y_gpu, y_arr, stream)
 
         theta_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
         initial_theta = np.full(ZX, 0.1, dtype=dtype)
@@ -282,61 +293,111 @@ def MLEM_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumo
         e_flat_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
         c_flat_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
 
-        # Assuming the cubin file is found globally or managed by the caller
-        projection_kernel = SMatrix.sparse_mod.get_function('projection_kernel__CSR')
-        backprojection_kernel = SMatrix.sparse_mod.get_function('backprojection_kernel__CSR')
-        ratio_kernel = SMatrix.sparse_mod.get_function('ratio_kernel')
-        update_kernel = SMatrix.sparse_mod.get_function('update_theta_kernel')
+        # Ensure kernels exist
+        projection_kernel = SMatrix.sparse_mod.get_function("projection_kernel__CSR")
+        backprojection_kernel = SMatrix.sparse_mod.get_function("backprojection_kernel__CSR")
+        ratio_kernel = SMatrix.sparse_mod.get_function("ratio_kernel")
+        update_kernel = SMatrix.sparse_mod.get_function("update_theta_kernel")
         block_size = 256
 
-        saved_theta, saved_indices = [], []
+        # prepare save indices once
         if numIterations <= max_saves:
             save_indices = list(range(numIterations))
         else:
-            save_indices = list(range(0, numIterations, max(1, numIterations // max_saves)))
+            step = max(1, numIterations // max_saves)
+            save_indices = list(range(0, numIterations, step))
             if save_indices[-1] != numIterations - 1:
                 save_indices.append(numIterations - 1)
 
+        saved_theta = []
+        saved_indices = []
+
         description = f"AOT-BioMaps -- ML-EM (CSR-sparse SMatrix) ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
         iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+
+        # grid sizes
+        grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
+        grid_cols = ((ZX + block_size - 1) // block_size, 1, 1)
+
         for it in iterator:
             # projection: q = A * theta
-            projection_kernel(q_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
-                              theta_flat_gpu, np.int32(TN),
-                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1),
-                              stream=stream)
+            projection_kernel(
+                q_flat_gpu,
+                SMatrix.values_gpu,
+                SMatrix.row_ptr_gpu,
+                SMatrix.col_ind_gpu,
+                theta_flat_gpu,
+                np.int32(TN),
+                block=(block_size, 1, 1),
+                grid=grid_rows,
+                stream=stream,
+            )
 
             # ratio: e = y / max(q, threshold)
-            ratio_kernel(e_flat_gpu, y_gpu, q_flat_gpu, np.float32(denominator_threshold), np.int32(TN),
-                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
-
-            # backprojection: c = A^T * e
+            ratio_kernel(
+                e_flat_gpu,
+                y_gpu,
+                q_flat_gpu,
+                np.float32(denominator_threshold),
+                np.int32(TN),
+                block=(block_size, 1, 1),
+                grid=grid_rows,
+                stream=stream,
+            )
+
+            # backprojection: c = A^T * e  (zero c first)
             drv.memset_d32_async(c_flat_gpu, 0, ZX, stream)
-            backprojection_kernel(c_flat_gpu, SMatrix.values_gpu, SMatrix.row_ptr_gpu, SMatrix.col_ind_gpu,
-                                  e_flat_gpu, np.int32(TN),
-                                  block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+            backprojection_kernel(
+                c_flat_gpu,
+                SMatrix.values_gpu,
+                SMatrix.row_ptr_gpu,
+                SMatrix.col_ind_gpu,
+                e_flat_gpu,
+                np.int32(TN),
+                block=(block_size, 1, 1),
+                grid=grid_rows,
+                stream=stream,
+            )
 
             # update: theta *= norm_factor_inv * c
-            update_kernel(theta_flat_gpu, c_flat_gpu, norm_factor_inv_gpu, np.int32(ZX),
-                          block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
-
+            update_kernel(
+                theta_flat_gpu,
+                c_flat_gpu,
+                norm_factor_inv_gpu,
+                np.int32(ZX),
+                block=(block_size, 1, 1),
+                grid=grid_cols,
+                stream=stream,
+            )
+
+            # periodic synchronization for stability / logging
             if show_logs and (it % 10 == 0 or it == numIterations - 1):
-                drv.Context.synchronize()
+                stream.synchronize()
 
+            # save snapshot if required
             if isSavingEachIteration and it in save_indices:
+                # ensure kernels finished
+                stream.synchronize()
                 theta_host = np.empty(ZX, dtype=dtype)
                 drv.memcpy_dtoh(theta_host, theta_flat_gpu)
                 saved_theta.append(theta_host.reshape(Z, X))
-                saved_indices.append(it)
-
-        drv.Context.synchronize()
-
-        final_result = np.empty(ZX, dtype=dtype)
-        drv.memcpy_dtoh(final_result, theta_flat_gpu)
-        final_result = final_result.reshape(Z, X)
-
-        # free local allocations
-        y_gpu.free(); q_flat_gpu.free(); e_flat_gpu.free(); c_flat_gpu.free(); theta_flat_gpu.free()
+                saved_indices.append(int(it))
+
+        # make sure everything finished
+        stream.synchronize()
+        final_theta_host = np.empty(ZX, dtype=dtype)
+        drv.memcpy_dtoh(final_theta_host, theta_flat_gpu)
+        final_result = final_theta_host.reshape(Z, X)
+
+        # free local allocations (will also be freed in finally if exception)
+        try:
+            y_gpu.free()
+            q_flat_gpu.free()
+            e_flat_gpu.free()
+            c_flat_gpu.free()
+            theta_flat_gpu.free()
+        except Exception:
+            pass
 
         return (saved_theta, saved_indices) if isSavingEachIteration else (final_result, None)
 
@@ -344,32 +405,50 @@ def MLEM_sparseCSR_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumo
         print(f"Error in MLEM_sparseCSR_pycuda: {type(e).__name__}: {e}")
         gc.collect()
         return None, None
-    
-    finally:
-        # --- CONTEXT FIX: Pop the context ---
-        if SMatrix and hasattr(SMatrix, 'ctx') and SMatrix.ctx:
-            SMatrix.ctx.pop()
-        # ------------------------------------
 
-def MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tumor_str, device, max_saves, denominator_threshold, show_logs=True):
+    finally:
+        # free buffers if still allocated
+        for buf in ("y_gpu", "q_flat_gpu", "e_flat_gpu", "c_flat_gpu", "theta_flat_gpu"):
+            try:
+                val = locals().get(buf, None)
+                if val is not None:
+                    val.free()
+            except Exception:
+                pass
+        # pop context safely
+        try:
+            if SMatrix and hasattr(SMatrix, "ctx") and SMatrix.ctx and popped_ctx:
+                SMatrix.ctx.pop()
+        except Exception:
+            pass
+
+def MLEM_sparseSELL_pycuda(
+    SMatrix,
+    y,
+    numIterations,
+    isSavingEachIteration,
+    tumor_str,
+    max_saves,
+    denominator_threshold,
+    show_logs=True,
+):
     """
     MLEM using SELL-C-σ kernels already present on device.
     y must be float32 length TN.
+
+    Version propre : diagnostics retirés.
     """
     final_result = None
 
     try:
-        # check if SMatrix is SparseSMatrix_SELL object
         if not isinstance(SMatrix, SparseSMatrix_SELL):
             raise TypeError("SMatrix must be a SparseSMatrix_SELL object")
         if SMatrix.sell_values_gpu is None:
             raise RuntimeError("SELL not built. Call allocate_sell_c_sigma_direct() first.")
-            
-        # --- CONTEXT FIX: Push the context associated with SMatrix ---
-        # This ensures all subsequent PyCUDA operations use the correct GPU/context.
+
+        # Context
         if SMatrix.ctx:
             SMatrix.ctx.push()
-        # -----------------------------------------------------------
 
         TN = int(SMatrix.N * SMatrix.T)
         ZX = int(SMatrix.Z * SMatrix.X)
@@ -383,7 +462,7 @@ def MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tum
 
         stream = drv.Stream()
 
-        # device buffers
+        # Device buffers
         y = y.T.flatten().astype(np.float32)
         y_gpu = drv.mem_alloc(y.nbytes)
         drv.memcpy_htod_async(y_gpu, y.astype(dtype), stream)
@@ -402,6 +481,7 @@ def MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tum
         grid_rows = ((TN + block_size - 1) // block_size, 1, 1)
         grid_cols = ((ZX + block_size - 1) // block_size, 1, 1)
 
+        # Prepare save indices
         saved_theta, saved_indices = [], []
         if numIterations <= max_saves:
             save_indices = list(range(numIterations))
@@ -412,52 +492,60 @@ def MLEM_sparseSELL_pycuda(SMatrix, y, numIterations, isSavingEachIteration, tum
 
         description = f"AOT-BioMaps -- ML-EM (SELL-c-σ-sparse SMatrix) ---- {tumor_str} TUMOR ---- GPU {torch.cuda.current_device()}"
         iterator = trange(numIterations, desc=description) if show_logs else range(numIterations)
+
+        # --- MLEM Loop ---
         for it in iterator:
-            # projection
-            proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, slice_ptr_gpu, slice_len_gpu,
-                    theta_gpu, np.int32(TN), slice_height,
-                    block=(block_size,1,1), grid=grid_rows, stream=stream)
 
-            # ratio
+            proj(q_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu,
+                 slice_ptr_gpu, slice_len_gpu,
+                 theta_gpu, np.int32(TN), slice_height,
+                 block=(block_size,1,1), grid=grid_rows, stream=stream)
+
             ratio(e_gpu, y_gpu, q_gpu, np.float32(denominator_threshold), np.int32(TN),
-                    block=(block_size,1,1), grid=grid_rows, stream=stream)
+                  block=(block_size,1,1), grid=grid_rows, stream=stream)
 
-            # zero c
             drv.memset_d32_async(c_gpu, 0, ZX, stream)
 
-            # backprojection accumulate
-            backproj(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, slice_ptr_gpu, slice_len_gpu,
-                        e_gpu, c_gpu, np.int32(TN), slice_height,
-                        block=(block_size,1,1), grid=grid_rows, stream=stream)
+            backproj(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu,
+                     slice_ptr_gpu, slice_len_gpu,
+                     e_gpu, c_gpu, np.int32(TN), slice_height,
+                     block=(block_size,1,1), grid=grid_rows, stream=stream)
 
-            # update
             update(theta_gpu, c_gpu, SMatrix.norm_factor_inv_gpu, np.int32(ZX),
-                    block=(block_size,1,1), grid=grid_cols, stream=stream)
+                   block=(block_size,1,1), grid=grid_cols, stream=stream)
 
-            stream.synchronize()
             if isSavingEachIteration and it in save_indices:
                 out = np.empty(ZX, dtype=np.float32)
                 drv.memcpy_dtoh(out, theta_gpu)
                 saved_theta.append(out.reshape((SMatrix.Z, SMatrix.X)))
                 saved_indices.append(it)
 
-        # final copy
+        stream.synchronize()
         res = np.empty(ZX, dtype=np.float32)
         drv.memcpy_dtoh(res, theta_gpu)
 
-        # free temporaries
-        y_gpu.free(); q_gpu.free(); e_gpu.free(); c_gpu.free(); theta_gpu.free()
-        
+        # free
+        try:
+            y_gpu.free()
+            q_gpu.free()
+            e_gpu.free()
+            c_gpu.free()
+            theta_gpu.free()
+        except Exception:
+            pass
+
         final_result = res.reshape((SMatrix.Z, SMatrix.X))
         return (saved_theta, saved_indices) if isSavingEachIteration else (final_result, None)
-        
+
     except Exception as e:
         print(f"Error in MLEM_sparseSELL_pycuda: {type(e).__name__}: {e}")
         gc.collect()
         return None, None
-    
+
     finally:
-        # --- CONTEXT FIX: Pop the context ---
         if SMatrix and hasattr(SMatrix, 'ctx') and SMatrix.ctx:
-            SMatrix.ctx.pop()
-        # ------------------------------------
+            try:
+                SMatrix.ctx.pop()
+            except Exception:
+                pass
+            

AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py

@@ -92,13 +92,11 @@ 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.
+        Corrected: per-block row_nnz copy, zeroing of host block, proper sync.
         """
         if self.sparse_mod is None:
             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")
 
@@ -106,34 +104,34 @@ class SparseSMatrix_SELL:
         num_cols = int(self.Z * self.X)
         C = int(self.slice_height)
 
-        # host temporary block
         br = int(self.block_rows)
-        bytes_per_elem = np.dtype(np.float32).itemsize
         dense_host = np.empty((br, num_cols), dtype=np.float32)
         
-        # Allocation 1: Dense block GPU memory
+        # Allocation dense buffer on device (size = br * num_cols)
         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)
+        # 1) count nnz per row (per block)
         row_nnz = np.zeros(num_rows, dtype=np.int32)
         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
+        block = 128
         for b in trange(0, num_rows, br, desc="Count NNZ per row"):
             R = min(br, num_rows - b)
-            # fill dense_host
+            # zero the host block to avoid garbage in tail when R < br
+            dense_host.fill(0.0)
             for i in range(R):
                 rg = b + i
                 n_idx = rg // self.T
                 t_idx = rg % self.T
                 dense_host[i, :] = self.manip.AcousticFields[n_idx].field[t_idx].flatten()
-            # copy only R rows
+            # copy whole buffer (safe because we zeroed tail)
             drv.memcpy_htod(dense_gpu, dense_host)
             grid = ((R + block - 1) // block, 1, 1)
             count_kernel(dense_gpu, row_nnz_gpu_block, np.int32(R), np.int32(num_cols), np.float32(self.relative_threshold),
-                         block=(block,1,1), grid=grid)
+                        block=(block,1,1), grid=grid)
+            drv.Context.synchronize()
             tmp = np.empty(R, dtype=np.int32)
             drv.memcpy_dtoh(tmp, row_nnz_gpu_block)
             row_nnz[b:b+R] = tmp
@@ -148,7 +146,6 @@ class SparseSMatrix_SELL:
             r0 = s * C
             r1 = min(num_rows, r0 + C)
             slice_len[s] = int(np.max(row_nnz[r0:r1])) if (r1>r0) else 0
-        # slice_ptr (int64)
         slice_ptr = np.zeros(num_slices + 1, dtype=np.int64)
         for s in range(num_slices):
             slice_ptr[s+1] = slice_ptr[s] + (slice_len[s] * C)
@@ -160,9 +157,14 @@ class SparseSMatrix_SELL:
         self.sell_values_gpu_size = total_storage * np.dtype(np.float32).itemsize
         self.sell_colinds_gpu_size = total_storage * np.dtype(np.uint32).itemsize
         
+        # allocate and optionally zero them
         self.sell_values_gpu = drv.mem_alloc(self.sell_values_gpu_size)
+        # It's good practice to zero the values buffer to avoid leftover memory
+        drv.memset_d32(self.sell_values_gpu, 0, total_storage)
+
         self.sell_colinds_gpu = drv.mem_alloc(self.sell_colinds_gpu_size)
-        
+        drv.memset_d32(self.sell_colinds_gpu, 0, total_storage)
+
         # allocate slice metadata on device
         self.slice_ptr = slice_ptr
         self.slice_len = slice_len
@@ -177,29 +179,28 @@ class SparseSMatrix_SELL:
         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 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_size = br * np.dtype(np.int32).itemsize
-        row_nnz_host_gpu = drv.mem_alloc(row_nnz_host_gpu_size)
+        # For per-block row_nnz pointer we allocate a buffer of max block size once, then reuse
+        row_nnz_host_gpu = drv.mem_alloc(br * np.dtype(np.int32).itemsize)
 
         for b in trange(0, num_rows, br, desc="Fill SELL"):
             R = min(br, num_rows - b)
+            dense_host.fill(0.0)
             for i in range(R):
                 rg = b + i
                 n_idx = rg // self.T
                 t_idx = rg % self.T
                 dense_host[i, :] = self.manip.AcousticFields[n_idx].field[t_idx].flatten()
+            # copy host block
             drv.memcpy_htod(dense_gpu, dense_host)
-            # We pass a dummy row_nnz pointer (not used in this kernel; left for API)
-            # Kernel expects rows_in_block, rows_global_offset to know where to write.
+            # copy corresponding row_nnz slice (only R entries)
+            drv.memcpy_htod(row_nnz_host_gpu, row_nnz[b:b+R])
+
             grid = ((R + block - 1) // block, 1, 1)
             fill_kernel(dense_gpu,
-                        np.intp(0), # placeholder for row_nnz pointer (not used)
+                        row_nnz_host_gpu,
                         self.slice_ptr_gpu,
                         self.slice_len_gpu,
                         self.sell_colinds_gpu,
@@ -210,12 +211,14 @@ class SparseSMatrix_SELL:
                         np.int32(C),
                         np.float32(self.relative_threshold),
                         block=(block,1,1), grid=grid)
+            drv.Context.synchronize()
+
         dense_gpu.free()
         row_nnz_host_gpu.free()
 
         # 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 
@@ -234,7 +237,7 @@ class SparseSMatrix_SELL:
             )
 
         # Le total_storage inclut les éléments non-nuls et le padding SELL.
-        threads = 256
+        threads = 128
         blocks = (self.total_storage + threads - 1) // threads
         
         # Lancement du kernel. Il travaille sur total_storage éléments.
@@ -248,43 +251,72 @@ class SparseSMatrix_SELL:
         )
         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.
+        Compute the TRUE MLEM normalization norm_factor_inv = 1 / (A^T * 1)
+        by performing a SELL backprojection of a vector of ones.
+        This is the ONLY correct normalization for MLEM.
         """
-        if self.total_storage == 0:
-            raise RuntimeError("sell not built")
         ZX = int(self.Z * self.X)
+        TN = int(self.T * self.N)
 
-        # allocate col sum on device
-        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)
+        # Allocate device vector of ones (projections)
+        ones_gpu = drv.mem_alloc(TN * np.dtype(np.float32).itemsize)
+        drv.memset_d32(ones_gpu, 0x3f800000, TN)   # 1.0f bit pattern
 
-        # 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,
-                   block=(threads,1,1), grid=(blocks,1,1))
+        # Allocate output for backprojection (ZX pixels)
+        c_gpu = drv.mem_alloc(ZX * np.dtype(np.float32).itemsize)
+        drv.memset_d32(c_gpu, 0, ZX)
+
+        # Get SELL backprojection kernel
+        try:
+            bp_kernel = self.sparse_mod.get_function("backprojection_kernel__SELL")
+        except Exception as e:
+            raise RuntimeError("Missing kernel backprojection_kernel__SELL in the cubin") from e
+
+        threads = 256  
+        blocks = (TN + threads - 1) // threads 
+
+        # Launch GPU backprojection
+        bp_kernel(
+            self.sell_values_gpu,
+            self.sell_colinds_gpu,
+            self.slice_ptr_gpu,
+            self.slice_len_gpu,
+            ones_gpu,
+            c_gpu,
+            np.int32(TN),
+            # np.int32(ZX),
+            np.int32(self.slice_height),
+            # np.int64(self.total_storage),
+            block=(threads, 1, 1), # Utilise le nouveau nombre de threads
+            grid=(blocks, 1, 1)
+        )
         drv.Context.synchronize()
 
-        # copy back
-        norm_host = np.empty(ZX, dtype=np.float32)
-        drv.memcpy_dtoh(norm_host, col_sum_gpu)
-        col_sum_gpu.free()
+        # Copy back to host
+        c_host = np.empty(ZX, dtype=np.float32)
+        drv.memcpy_dtoh(c_host, c_gpu)
+        ones_gpu.free()
+        c_gpu.free()
+
+        # Avoid divide-by-zero
+        c_host = np.maximum(c_host, 1e-6)
+
+        # Compute inverse (stored for use in MLEM)
+        self.norm_factor_inv = (1.0 / c_host).astype(np.float32)
 
-        norm = np.maximum(norm_host.astype(np.float64), 1e-6)
-        self.norm_factor_inv = (1.0 / norm).astype(np.float32)
+        # Upload to GPU
         if self.norm_factor_inv_gpu is not None:
             self.norm_factor_inv_gpu.free()
-            
+
         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)
 
+        print("✓ Normalization (A^T*1) computed for MLEM.")
+
     def compute_density(self):
         """
         Returns only the density of the SELL-C-σ matrix.

AOT_biomaps/AOT_Recon/ReconTools.py

@@ -221,7 +221,6 @@ def calculate_memory_requirement(SMatrix, y):
     # --- 3. Final Result ---
     return total_bytes / (1024 ** 3)
 
-
 def check_gpu_memory(device_index, required_memory, show_logs=True):
     """Check if enough memory is available on the specified GPU."""
     free_memory, _ = torch.cuda.mem_get_info(f"cuda:{device_index}")
@@ -252,7 +251,6 @@ def _backward_projection(SMatrix, e_p, c_p):
                     total += SMatrix[_t, _z, _x, _n] * e_p[_t, _n]
             c_p[_z, _x] = total
 
-
 def _build_adjacency_sparse(Z, X, device, corner=(0.5 - np.sqrt(2) / 4) / np.sqrt(2), face=0.5 - np.sqrt(2) / 4,dtype=torch.float32):
     rows, cols, weights = [], [], []
     for z in range(Z):
@@ -273,7 +271,6 @@ def _build_adjacency_sparse(Z, X, device, corner=(0.5 - np.sqrt(2) / 4) / np.sqr
     index, values = coalesce(index, values, m=Z*X, n=Z*X)
     return index, values
 
-
 def power_method(P, PT, data, Z, X, n_it=10):
     x = torch.randn(Z * X, device=data.device)
     x = x / torch.norm(x)

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.294'
+__version__ = '2.9.321'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -138,6 +138,33 @@ def initialize(process=None):
 
 
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

{aot_biomaps-2.9.294.dist-info → aot_biomaps-2.9.321.dist-info}/METADATA

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

{aot_biomaps-2.9.294.dist-info → aot_biomaps-2.9.321.dist-info}/RECORD

@@ -1,16 +1,17 @@
 AOT_biomaps/Config.py,sha256=ghEOP1n8aO1pR-su13wMeAZAxZRfry5hH67NbtZ8SqI,3614
 AOT_biomaps/Settings.py,sha256=v8fPhnvvcfBJP29m1RLOTEr3jndGLGwbUiORXmsj2Bo,2853
-AOT_biomaps/__init__.py,sha256=86X2xRJNI72niePVEmyZMqO0Y4vQeag7ZSHPM3kc4Pk,4250
+AOT_biomaps/__init__.py,sha256=6TSP5wI6TYb3icQQXws5eVgqxv0-F2F9HDYXj9uot6A,4304
 AOT_biomaps/AOT_Acoustic/AcousticEnums.py,sha256=s5kXa6jKzbS4btwbubrVcynLOr0yg5tth5vL_FGfbMk,1802
-AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=al7xXKMY5e-qQQ7nrQVPVAmqYiB320OluNlY6ti8iKc,7539
+AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=h2sCtGVcDtyLtEF1q7sLZmuWivWmesVGUBPnW-ndQqc,7535
 AOT_biomaps/AOT_Acoustic/FocusedWave.py,sha256=3kGKKDx_3Msy5COYqIwzROPORGWvNjw8UsDanBfkMXE,11037
 AOT_biomaps/AOT_Acoustic/IrregularWave.py,sha256=yZhtxkR6zlciRcEpdTR0BAhvgQl40XHKFaF8f4VXarE,3035
 AOT_biomaps/AOT_Acoustic/PlaneWave.py,sha256=xza-rj5AUWDecLkGDxRcULrwZVWeBvGnEP2d51TyR04,1447
 AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=jTLVlOhYLWJb5MxZPxhq3OFVlz2McoyMPBmfLvnekDU,18209
 AOT_biomaps/AOT_Acoustic/__init__.py,sha256=t9M2rRqa_L9pk7W2FeELTkHEMuP4DBr4gBRldMqsQbg,491
 AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=RdmhRF1i0KAlpsP7_wnZ7F4J27br3eUc4XR91Qq7C64,44158
+AOT_biomaps/AOT_Experiment/ExperimentTools.py,sha256=BkHSX_foyyj5UrHZWQH5F9DGeV8o2fkp3euEbcvE4vA,2399
 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=qH7QlAPp5Er1AhMbWDpbOT6VRJHgrYUdUxazuEMAc_A,34569
 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,20 +19,20 @@ 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=Li4HdWpr65ONf82FqFAjZ8w3ob9UuJucDWGAAvBF77Q,83680
+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=JbFhxiyUoSTnlJgHbOWIfUUwhwfZoi39RJMnfkagegY,16504
 AOT_biomaps/AOT_Recon/ReconEnums.py,sha256=KAf55RqHAr2ilt6pxFrUBGQOn-7HA8NP6TyL-1FNiXo,19714
-AOT_biomaps/AOT_Recon/ReconTools.py,sha256=A4IQV7IETu9MgYr7hjLNPTImzjf8CEU4cZ2e0EgJNWA,19878
+AOT_biomaps/AOT_Recon/ReconTools.py,sha256=py1zKVEa0j7EfmcNZS2lpVQwzlkY6rRWsDQ8izWlme4,19872
 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=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=v5wITKacemu_hY391-cZDSpw4R95XqyLGivQWa-gOOc,21254
+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
@@ -39,9 +40,9 @@ AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/Quadratic.py,sha256=wTbzcXxMdEl9ReE
 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=RACc2P5oxmp0uPLAGnNj9mEtAxa_OlepNgCawKij3jI,12062
-AOT_biomaps/AOT_Recon/AOT_SparseSMatrix/SparseSMatrix_SELL.py,sha256=WTqHBeglUxRx-jy6CcoETgqYSSHYTwi2zR5NrJcPXGU,14449
+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.294.dist-info/METADATA,sha256=8c8tnkhnARdI6acSPSrB1FQloxgjuoNHKslkkgIq7xM,700
-aot_biomaps-2.9.294.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.294.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.294.dist-info/RECORD,,
+aot_biomaps-2.9.321.dist-info/METADATA,sha256=DMnk4rlTFW95pX0welgBZD3GdTkjeFbn3vwXNyUxSHs,700
+aot_biomaps-2.9.321.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aot_biomaps-2.9.321.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.321.dist-info/RECORD,,