AOT-biomaps 2.9.384__py3-none-any.whl → 2.9.386__py3-none-any.whl

AOT_biomaps/AOT_Acoustic/_mainAcoustic.py

@@ -563,8 +563,6 @@ class AcousticField(ABC):
             kgrid.setTime(self.kgrid.Nt, dt)  # Garder Nt constant
 
             factorT = int(np.ceil((1/dt) / (self.params['f_saving'])))
-            print(f"factorT: {factorT}")
-            print(f"dt: {dt}")
 
             source = kSource()
             source.p_mask = np.zeros((Nx, Nz))

AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py

@@ -554,7 +554,6 @@ def CP_TV_Tikhonov_sparseSELL_pycuda(
             pass
         raise
 
-
 def CP_KL(
     SMatrix,
     y,
@@ -649,4 +648,248 @@ def CP_KL(
     if isSavingEachIteration:
         return I_reconMatrix, saved_indices
     else:
-        return I_reconMatrix[-1], None
+        return I_reconMatrix[-1], None
+    
+def CP_TV_Tikhonov_Preconditioned_SELL_pycuda(
+    SMatrix,
+    y,
+    alpha=None,             # TV param
+    beta=1e-4,              # Tikhonov param
+    numIterations=2000,
+    isSavingEachIteration=True,
+    tumor_str="",
+    device=None,
+    max_saves=2000,
+    show_logs=True,
+    k_security=1.0,         # Pock condition: tau*sigma * ||A||^2 < 1. Avec precond, souvent k=1.0 suffit.
+    apply_positivity_clamp=True
+):
+    
+    if SMatrix.ctx:
+        SMatrix.ctx.push()
+
+    dtype = np.float32
+    TN = int(SMatrix.N * SMatrix.T)
+    ZX = int(SMatrix.Z * SMatrix.X)
+    Z, X = SMatrix.Z, SMatrix.X
+    block_size = 256
+
+    # --- Récupération des Kernels (Existants + Nouveaux) ---
+    projection_kernel = SMatrix.sparse_mod.get_function("projection_kernel__SELL")
+    backprojection_kernel = SMatrix.sparse_mod.get_function("backprojection_kernel__SELL")
+    axpby_kernel = SMatrix.sparse_mod.get_function("vector_axpby_kernel")
+    minus_axpy_kernel = SMatrix.sparse_mod.get_function("vector_minus_axpy_kernel")
+    gradient_kernel = SMatrix.sparse_mod.get_function("gradient_kernel")
+    divergence_kernel = SMatrix.sparse_mod.get_function("divergence_kernel")
+    proj_tv_kernel = SMatrix.sparse_mod.get_function("proj_tv_kernel")
+    
+    # Nouveaux kernels pour le préconditionnement
+    try:
+        update_dual_data_precond = SMatrix.sparse_mod.get_function("update_dual_data_precond_kernel")
+        update_primal_precond = SMatrix.sparse_mod.get_function("update_primal_precond_kernel")
+        invert_vector_kernel = SMatrix.sparse_mod.get_function("invert_vector_kernel")
+        clamp_positive_kernel = SMatrix.sparse_mod.get_function("clamp_positive_kernel")
+    except Exception as e:
+        print("Erreur: Il manque les kernels C++ de préconditionnement (update_dual_data_precond_kernel, etc).")
+        raise e
+
+    stream = drv.Stream()
+
+    # --- 1. SETUP PRECONDITIONERS (tau_vec, sigma_vec) ---
+    # Au lieu de calculer L, on calcule les sommes lignes/colonnes
+    
+    # Allocations vecteurs de pas
+    sigma_vec_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
+    tau_vec_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+    
+    # Buffer temporaire de 1 pour les sommes
+    ones_TN_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize)
+    ones_ZX_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize)
+    
+    # Remplir de 1.0
+    # On utilise une astuce : axpby(out, out, out, 0, 0) pour clear puis ajout de 1 ? Non, memset n'écrit pas des float 1.0.
+    # On va transférer un array de 1 depuis le host (rapide au setup)
+    drv.memcpy_htod_async(ones_TN_gpu, np.ones(TN, dtype=dtype), stream)
+    drv.memcpy_htod_async(ones_ZX_gpu, np.ones(ZX, dtype=dtype), stream)
+    
+    # A) Calcul de Sigma (Inverse des Row Sums) : A * 1_ZX
+    # On utilise ton kernel de projection existant : q = A * theta (avec theta=1)
+    projection_kernel(sigma_vec_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                      ones_ZX_gpu, np.int32(TN), np.int32(SMatrix.slice_height),
+                      block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+    
+    # Inversion : sigma_vec = 1 / (sum + eps)
+    # Note : sigma_vec doit être divisé par k_security ? Dans Pock precond, tau_i = 1/sum. On garde k_security global si besoin.
+    invert_vector_kernel(sigma_vec_gpu, sigma_vec_gpu, np.float32(1e-6), np.int32(TN),
+                         block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+    # B) Calcul de Tau (Inverse des Col Sums - Carte Sensibilité) : A^T * 1_TN
+    # On utilise ton kernel de backprojection : c += A^T * e (avec e=1)
+    # Important : backproj fait un atomicAdd, il faut mettre à 0 avant
+    drv.memset_d32_async(tau_vec_gpu, 0, ZX, stream)
+    backprojection_kernel(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                          ones_TN_gpu, tau_vec_gpu, np.int32(TN), np.int32(SMatrix.slice_height),
+                          block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+    
+    invert_vector_kernel(tau_vec_gpu, tau_vec_gpu, np.float32(1e-6), np.int32(ZX),
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+    # Nettoyage temp
+    ones_TN_gpu.free()
+    ones_ZX_gpu.free()
+
+    # --- 2. PREPARE DATA ---
+    y = y.T.astype(dtype).reshape(-1)
+    maxy = float(np.max(np.abs(y))) if y.size > 0 else 0.0
+    y_normed = (y / maxy).copy() if maxy > 0 else y.copy()
+
+    # Allocations Variables Principales
+    bufs = []
+    y_gpu = drv.mem_alloc(y_normed.nbytes); bufs.append(y_gpu)
+    drv.memcpy_htod_async(y_gpu, y_normed, stream)
+
+    x_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize); bufs.append(x_gpu)
+    drv.memset_d32_async(x_gpu, 0, ZX, stream)
+    
+    x_old_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize); bufs.append(x_old_gpu)
+    x_tilde_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize); bufs.append(x_tilde_gpu)
+    drv.memset_d32_async(x_tilde_gpu, 0, ZX, stream) # Important: x_tilde init à 0
+
+    # Dual Variables
+    p_gpu = drv.mem_alloc(2 * ZX * np.dtype(dtype).itemsize); bufs.append(p_gpu) # Gradient
+    q_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize); bufs.append(q_gpu)     # Data term
+    drv.memset_d32_async(p_gpu, 0, 2 * ZX, stream)
+    drv.memset_d32_async(q_gpu, 0, TN, stream)
+
+    # Buffers intermédiaires
+    grad_gpu = drv.mem_alloc(2 * ZX * np.dtype(dtype).itemsize); bufs.append(grad_gpu)
+    div_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize); bufs.append(div_gpu)
+    Ax_gpu = drv.mem_alloc(TN * np.dtype(dtype).itemsize); bufs.append(Ax_gpu)
+    ATq_gpu = drv.mem_alloc(ZX * np.dtype(dtype).itemsize); bufs.append(ATq_gpu)
+
+    # --- PARAMETRES & LOGS ---
+    # Pour le TV, on a besoin d'un sigma scalaire pour le dual update du gradient.
+    # Dans le preconditionning diagonal complet, c'est complexe.
+    # Approximation robuste : on utilise sigma_tv fixe.
+    # Cependant, alpha (le poids TV) joue le rôle de seuil.
+    sigma_tv = np.float32(1.0) # Le scaling est absorbé par alpha et tau_vec
+
+    if alpha is None:
+        # Auto-alpha simplifié (ou tu gardes ta logique précédente)
+        alpha = 0.01 # Valeur par défaut si non spécifié
+        print(f"Warning: Alpha not set, using default {alpha}")
+
+    # Description
+    desc = f"Pock-Precond | {tumor_str} | Alpha={alpha} | Beta={beta}"
+    
+    # Saving setup
+    x_host = np.empty(ZX, dtype=dtype)
+    save_indices_all = list(range(0, numIterations + 1, max(1, numIterations // max_saves)))
+    I_reconMatrix = []
+    saved_indices = []
+
+    try:
+        iterator = trange(numIterations, desc=desc) if show_logs else range(numIterations)
+        
+        for it in iterator:
+            
+            # =======================
+            # 1. UPDATE DUAL (P - TV)
+            # =======================
+            # Gradient de x_bar (x_tilde)
+            gradient_kernel(grad_gpu, x_tilde_gpu, np.int32(Z), np.int32(X), np.int32(ZX),
+                            block=(block_size, 1, 1), grid=((X + block_size - 1) // block_size, (Z + block_size - 1) // block_size, 1), stream=stream)
+            
+            # p = p + sigma_tv * grad
+            axpby_kernel(p_gpu, p_gpu, grad_gpu, np.float32(1.0), sigma_tv, np.int32(2 * ZX),
+                         block=(block_size, 1, 1), grid=((2*ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            # Prox TV (Projection boule unité)
+            # Attention : ici le pas "alpha" doit être adapté car on utilise un tau vectoriel ailleurs.
+            # On passe alpha brut.
+            proj_tv_kernel(p_gpu, np.float32(alpha), np.int32(ZX),
+                           block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # ==========================
+            # 2. UPDATE DUAL (Q - DATA)
+            # ==========================
+            # Calcul Ax_bar
+            projection_kernel(Ax_gpu, SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                              x_tilde_gpu, np.int32(TN), np.int32(SMatrix.slice_height),
+                              block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            # Update q avec sigma vectoriel
+            # q = (q + sigma_vec * (Ax - y)) / (1 + sigma_vec)
+            update_dual_data_precond(q_gpu, Ax_gpu, y_gpu, sigma_vec_gpu, np.int32(TN),
+                                     block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # ==========================
+            # 3. UPDATE PRIMAL (X)
+            # ==========================
+            # Sauvegarde x_old
+            drv.memcpy_dtod_async(x_old_gpu, x_gpu, ZX * np.dtype(dtype).itemsize, stream)
+            
+            # Calcul ATq (Backprojection)
+            drv.memset_d32_async(ATq_gpu, 0, ZX, stream)
+            backprojection_kernel(SMatrix.sell_values_gpu, SMatrix.sell_colinds_gpu, SMatrix.slice_ptr_gpu, SMatrix.slice_len_gpu,
+                                  q_gpu, ATq_gpu, np.int32(TN), np.int32(SMatrix.slice_height),
+                                  block=(block_size, 1, 1), grid=((TN + block_size - 1) // block_size, 1, 1), stream=stream)
+            
+            # Calcul Div p
+            divergence_kernel(div_gpu, p_gpu, np.int32(Z), np.int32(X), np.int32(ZX),
+                              block=(block_size, 1, 1), grid=((X + block_size - 1) // block_size, (Z + block_size - 1) // block_size, 1), stream=stream)
+            
+            # Combiner les gradients : ATq - Div p
+            minus_axpy_kernel(ATq_gpu, div_gpu, np.float32(1.0), np.int32(ZX),
+                             block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # Update X avec tau vectoriel
+            # x = x - tau_vec * (ATq - Div p)
+            # Note: ATq_gpu contient maintenant le gradient total
+            update_primal_precond(x_gpu, ATq_gpu, tau_vec_gpu, np.int32(ZX),
+                                  block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # Positivity
+            if apply_positivity_clamp:
+                clamp_positive_kernel(x_gpu, np.int32(ZX),
+                                      block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # Tikhonov (simplifié : decay)
+            if beta > 0:
+                # x = x / (1 + beta * tau_vec) ? 
+                # Approx rapide : x *= (1 - beta * mean_tau) ou juste x *= (1-beta)
+                # Utilisons axpby simple pour un petit decay
+                axpby_kernel(x_gpu, x_gpu, x_gpu, np.float32(1.0 - beta), np.float32(0.0), np.int32(ZX),
+                             block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # ==========================
+            # 4. EXTRAPOLATION
+            # ==========================
+            # x_tilde = x + theta * (x - x_old)
+            axpby_kernel(x_tilde_gpu, x_gpu, x_old_gpu, np.float32(2.0), np.float32(-1.0), np.int32(ZX),
+                         block=(block_size, 1, 1), grid=((ZX + block_size - 1) // block_size, 1, 1), stream=stream)
+
+            # Save
+            if isSavingEachIteration and (it + 1) in save_indices_all:
+                stream.synchronize()
+                drv.memcpy_dtoh(x_host, x_gpu)
+                x_saved = x_host.reshape((Z, X)).copy()
+                if maxy > 0: x_saved *= maxy
+                I_reconMatrix.append(x_saved)
+                saved_indices.append(it + 1)
+
+        # Fin boucle
+        stream.synchronize()
+        # Cleanup (buffers)
+        for b in bufs: b.free()
+        sigma_vec_gpu.free()
+        tau_vec_gpu.free()
+        if SMatrix.ctx: SMatrix.ctx.pop()
+
+        return I_reconMatrix, saved_indices
+
+    except Exception as e:
+        print(f"Error: {e}")
+        if SMatrix.ctx: SMatrix.ctx.pop()
+        return None, None
+    

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.384'
+__version__ = '2.9.386'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -245,6 +245,8 @@ def initialize(process=None):
 
 
 
+
+
 
 
 

{aot_biomaps-2.9.384.dist-info → aot_biomaps-2.9.386.dist-info}/METADATA

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

{aot_biomaps-2.9.384.dist-info → aot_biomaps-2.9.386.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=v5zaM6In37AdyS1xtkJdFUucdfR1ho7Wa6cOfoqtQxI,4430
+AOT_biomaps/__init__.py,sha256=khayoJ2i2AgFcpmXaDxizLDrK8JfWe_LyyfKwJIQ9zU,4434
 AOT_biomaps/AOT_Acoustic/AcousticEnums.py,sha256=s5kXa6jKzbS4btwbubrVcynLOr0yg5tth5vL_FGfbMk,1802
 AOT_biomaps/AOT_Acoustic/AcousticTools.py,sha256=7kuWIIGyzZPQrzRI0zVvdwNUp7qKUE67yCYOMzSb0Ug,8283
 AOT_biomaps/AOT_Acoustic/FocusedWave.py,sha256=3kGKKDx_3Msy5COYqIwzROPORGWvNjw8UsDanBfkMXE,11037
@@ -8,7 +8,7 @@ AOT_biomaps/AOT_Acoustic/IrregularWave.py,sha256=yZhtxkR6zlciRcEpdTR0BAhvgQl40XH
 AOT_biomaps/AOT_Acoustic/PlaneWave.py,sha256=xza-rj5AUWDecLkGDxRcULrwZVWeBvGnEP2d51TyR04,1447
 AOT_biomaps/AOT_Acoustic/StructuredWave.py,sha256=GPh_mD6TUVolKa32tu6juPxvmzgLB7eXBfuXO-8ZhEg,21243
 AOT_biomaps/AOT_Acoustic/__init__.py,sha256=t9M2rRqa_L9pk7W2FeELTkHEMuP4DBr4gBRldMqsQbg,491
-AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=ql-6W9mwIpxC4PGxF2XFa8iWF5SN69VFeYZh3312Fzw,47588
+AOT_biomaps/AOT_Acoustic/_mainAcoustic.py,sha256=fnVWzu0cnbQc6mqnCDemiwdaGR1RGIIpqszvnYM-Dis,47514
 AOT_biomaps/AOT_Experiment/ExperimentTools.py,sha256=aFvJw6J_jfFVTDFnG7J3a61SHEgORdZKZS0UI82VMaY,2637
 AOT_biomaps/AOT_Experiment/Focus.py,sha256=B2nBawmv-NG2AWJx9zgQ8GlN6aFB9FwTSqX-M-phKXg,3193
 AOT_biomaps/AOT_Experiment/Tomography.py,sha256=9mJDwV9WVphoX8drL7MgN3WhS6fjYwS6HWQD3x1CrVs,37625
@@ -33,7 +33,7 @@ AOT_biomaps/AOT_Recon/AOT_Optimizers/DEPIERRO.py,sha256=qA1n722GLQJH3V8HcLr5q_Gx
 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=4omsqzHEZJfv0mEfmxfK71IovDbRstVE4x3Flf4cR3o,22441
-AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py,sha256=oSojwug5mcZedKOWAV7YPMlCp0Qy_Aed0fjHRuyZWpo,28622
+AOT_biomaps/AOT_Recon/AOT_Optimizers/PDHG.py,sha256=K-SnzLIMNJdnSu1GT5a-N_qv_Ve06xILaJM3G69AAV0,41129
 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
@@ -42,7 +42,7 @@ AOT_biomaps/AOT_Recon/AOT_PotentialFunctions/__init__.py,sha256=RwrJdLOFbAFBFnRx
 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.384.dist-info/METADATA,sha256=WlQIgGgKBoWMec_aU1J81_EFhOqHA63nndEPdnYnMh4,700
-aot_biomaps-2.9.384.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aot_biomaps-2.9.384.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
-aot_biomaps-2.9.384.dist-info/RECORD,,
+aot_biomaps-2.9.386.dist-info/METADATA,sha256=9vAXgvhWtKvXT09vFheT2t_6-g2qCQF-ViXfz17KJ5k,700
+aot_biomaps-2.9.386.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+aot_biomaps-2.9.386.dist-info/top_level.txt,sha256=6STF-lT4kaAnBHJYCripmN5mZABoHjMuY689JdiDphk,12
+aot_biomaps-2.9.386.dist-info/RECORD,,

{aot_biomaps-2.9.384.dist-info → aot_biomaps-2.9.386.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any