AOT-biomaps 2.9.377__tar.gz → 2.9.379__tar.gz

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/AOT_biomaps/AOT_Acoustic/StructuredWave.py

@@ -190,7 +190,7 @@ class StructuredWave(AcousticField):
         """
         return f"{'1' if self.angle < 0 else '0'}{abs(self.angle):02d}"
 
-    def _apply_delay(self,dx=None):
+    def _apply_delay(self,dt=None,dx=None,c0=None):
         """
         Apply a temporal delay to the signal for each transducer element.
 
@@ -198,9 +198,13 @@ class StructuredWave(AcousticField):
             ndarray: Array of delayed signals.
         """
         try:
+            print(f"dx in _apply_delay: {dx}")
             is_positive = self.angle >= 0
             if dx is None:
                 dx = self.params['dx']
+            if c0 is None:
+                c0 = self.params['c0']
+            actual_dt = dt if dt is not None else self.kgrid.dt
             # Calculate the total number of grid points for all elements
             total_grid_points = self.params['num_elements'] * int(round(self.params['element_width'] / dx))
 
@@ -212,10 +216,10 @@ class StructuredWave(AcousticField):
 
             # Calculate delays based on physical positions
             for i in range(total_grid_points):
-                delays[i] = (element_positions[i] * np.tan(np.deg2rad(abs(self.angle)))) / self.params['c0']  # Delay in seconds
+                delays[i] = (element_positions[i] * np.tan(np.deg2rad(abs(self.angle)))) / c0  # Delay in seconds
 
 
-            delay_samples = np.round(delays / self.kgrid.dt).astype(int)
+            delay_samples = np.round(delays / actual_dt).astype(int)
             max_delay = np.max(np.abs(delay_samples))
 
             delayed_signals = np.zeros((total_grid_points, len(self.burst) + max_delay))
@@ -332,76 +336,119 @@ class StructuredWave(AcousticField):
                 f_hdr2.write(headerFieldGlob)
         except Exception as e:
             print(f"Error saving HDR/IMG files: {e}")
-    
-    def _SetUpSource(self, source, Nx, dx, factorT):
-        """
-        Set up source for both 2D and 3D structured waves.
-        """
-        active_list = np.array([int(char) for char in ''.join(f"{int(self.pattern.activeList[i:i+2], 16):08b}" for i in range(0, len(self.pattern.activeList), 2))])
-        element_width_grid_points = int(round(self.params['element_width'] / dx))
-
-        if source.p_mask.ndim == 2:
-            element_width_grid_points = int(round(self.params['element_width'] / dx))
-            total_elements_width = self.params['num_elements'] * element_width_grid_points
-
-            # Vérifier que les éléments rentrent dans le grid
-            if total_elements_width > Nx:
-                raise ValueError(f"La largeur totale des éléments ({total_elements_width}) dépasse Nx ({Nx}).")
-
-            remaining_space = Nx - total_elements_width
-            if remaining_space < 0:
-                raise ValueError(f"Pas assez d'espace pour placer les éléments: total_elements_width ({total_elements_width}) > Nx ({Nx}).")
-
-            spacing = remaining_space // (self.params['num_elements'] + 1)
-            center_index = np.argmin(np.abs(np.linspace(self.params['Xrange'][0], self.params['Xrange'][1], Nx)))
-
-            activeListGrid = np.zeros(total_elements_width, dtype=int)
-            current_position = center_index - (total_elements_width + (self.params['num_elements'] - 1) * spacing) // 2
-
-            # Placement des éléments actifs
-            for i in range(self.params['num_elements']):
-                if active_list[i] == 1:
-                    x_pos = max(0, current_position)  # Éviter les indices négatifs
-                    x_end = x_pos + element_width_grid_points
-                    if x_end > Nx:
-                        x_end = Nx  # Limiter à Nx
-                    source.p_mask[x_pos:x_end,0] = 1
-
-                    start_idx = i * element_width_grid_points
-                    end_idx = start_idx + element_width_grid_points
-                    if end_idx > total_elements_width:
-                        end_idx = total_elements_width
-                    activeListGrid[start_idx:end_idx] = 1
-
-                current_position += element_width_grid_points + spacing
-
-            # Chargement des signaux retardés
-            if factorT != 1:
-                delayedSignal = self._apply_delay(dx=dx)
-            else:
-                delayedSignal = self.delayedSignal
-
-            # Vérification de la taille de delayedSignal
-            num_active_elements = np.sum(activeListGrid == 1)
-            if delayedSignal.shape[0] < num_active_elements:
-                raise ValueError(f"delayedSignal a une taille insuffisante: {delayedSignal.shape[0]} < {num_active_elements}.")
-
-            # Assigner source.p
-            source.p =  float(self.params['voltage']) * float(self.params['sensitivity']) * delayedSignal[activeListGrid == 1, :]
-
 
-        elif source.p_mask.ndim == 3:
-            # --- 3D ---
-            center_index_x = Nx // 2
-            center_index_y = self.params['Ny'] // 2
-            spacing = (Nx - self.params['num_elements'] * element_width_grid_points) // (self.params['num_elements'] + 1)
-            current_position = center_index_x - (self.params['num_elements'] * element_width_grid_points + (self.params['num_elements'] - 1) * spacing) // 2
-
-            for i in range(self.params['num_elements']):
-                if active_list[i] == 1:
-                    x_pos = current_position
-                    source.p_mask[x_pos:x_pos + element_width_grid_points, center_index_y, 0] = 1
-                current_position += element_width_grid_points + spacing
-
-            delayed_signals = self._apply_delay()
-            source.p =  float(self.params['voltage']) * float(self.params['sensitivity']) * delayed_signals.T
+    def _SetUpSource(self, source, Nx, dt, dx, c0, factorT):
+        active_list = np.array([int(char) for char in ''.join(f"{int(self.pattern.activeList[i:i+2], 16):08b}" for i in range(0, len(self.pattern.activeList), 2))])
+        
+        # Largeur d'un élément en pixels
+        el_width_px = int(round(self.params['element_width'] / dx))
+        # Largeur totale de la sonde en pixels
+        total_sonde_px = self.params['num_elements'] * el_width_px
+        
+        # On récupère pva_nx depuis l'appel ou on le recalcule
+        pva_nx = int(np.round(self.params['width_phantom'] / dx))
+        air_margin = (Nx - pva_nx) // 2
+        
+        # Position de départ pour que la sonde soit centrée sur le PHANTOM
+        # On commence à la fin de la marge d'air, et on centre la sonde dans le pva_nx
+        current_position = air_margin + (pva_nx - total_sonde_px) // 2
+
+        activeListGrid = np.zeros(total_sonde_px, dtype=int)
+
+        for i in range(self.params['num_elements']):
+            if active_list[i] == 1:
+                x_start = current_position
+                x_end = x_start + el_width_px
+                
+                # On remplit le masque k-Wave (z=0)
+                source.p_mask[x_start:x_end, 0] = 1
+                
+                # On marque les indices actifs pour injecter le signal delayed
+                idx_start = i * el_width_px
+                idx_end = idx_start + el_width_px
+                activeListGrid[idx_start:idx_end] = 1
+
+            current_position += el_width_px # Pas de "spacing" variable, les éléments sont collés
+
+        # Injection du signal
+        if factorT != 1:
+            delayedSignal = self._apply_delay(self, dt=dt, dx=dx, c0=c0)
+        else:
+            delayedSignal = self.delayedSignal
+
+        # On injecte uniquement là où p_mask == 1
+        source.p = float(self.params['voltage']) * float(self.params['sensitivity']) * delayedSignal[activeListGrid == 1, :]
+        return source
+    
+    # def _SetUpSource(self, source, Nx, dx, factorT):
+    #     """
+    #     Set up source for both 2D and 3D structured waves.
+    #     """
+    #     active_list = np.array([int(char) for char in ''.join(f"{int(self.pattern.activeList[i:i+2], 16):08b}" for i in range(0, len(self.pattern.activeList), 2))])
+    #     element_width_grid_points = int(round(self.params['element_width'] / dx))
+
+    #     if source.p_mask.ndim == 2:
+    #         element_width_grid_points = int(round(self.params['element_width'] / dx))
+    #         total_elements_width = self.params['num_elements'] * element_width_grid_points
+
+    #         # Vérifier que les éléments rentrent dans le grid
+    #         if total_elements_width > Nx:
+    #             raise ValueError(f"La largeur totale des éléments ({total_elements_width}) dépasse Nx ({Nx}).")
+
+    #         remaining_space = Nx - total_elements_width
+    #         if remaining_space < 0:
+    #             raise ValueError(f"Pas assez d'espace pour placer les éléments: total_elements_width ({total_elements_width}) > Nx ({Nx}).")
+
+    #         spacing = remaining_space // (self.params['num_elements'] + 1)
+    #         center_index = np.argmin(np.abs(np.linspace(self.params['Xrange'][0], self.params['Xrange'][1], Nx)))
+
+    #         activeListGrid = np.zeros(total_elements_width, dtype=int)
+    #         current_position = center_index - (total_elements_width + (self.params['num_elements'] - 1) * spacing) // 2
+
+    #         # Placement des éléments actifs
+    #         for i in range(self.params['num_elements']):
+    #             if active_list[i] == 1:
+    #                 x_pos = max(0, current_position)  # Éviter les indices négatifs
+    #                 x_end = x_pos + element_width_grid_points
+    #                 if x_end > Nx:
+    #                     x_end = Nx  # Limiter à Nx
+    #                 source.p_mask[x_pos:x_end,0] = 1
+
+    #                 start_idx = i * element_width_grid_points
+    #                 end_idx = start_idx + element_width_grid_points
+    #                 if end_idx > total_elements_width:
+    #                     end_idx = total_elements_width
+    #                 activeListGrid[start_idx:end_idx] = 1
+
+    #             current_position += element_width_grid_points + spacing
+
+    #         # Chargement des signaux retardés
+    #         if factorT != 1:
+    #             delayedSignal = self._apply_delay(dx=dx)
+    #         else:
+    #             delayedSignal = self.delayedSignal
+
+    #         # Vérification de la taille de delayedSignal
+    #         num_active_elements = np.sum(activeListGrid == 1)
+    #         if delayedSignal.shape[0] < num_active_elements:
+    #             raise ValueError(f"delayedSignal a une taille insuffisante: {delayedSignal.shape[0]} < {num_active_elements}.")
+
+    #         # Assigner source.p
+    #         source.p =  float(self.params['voltage']) * float(self.params['sensitivity']) * delayedSignal[activeListGrid == 1, :]
+
+
+    #     elif source.p_mask.ndim == 3:
+    #         # --- 3D ---
+    #         center_index_x = Nx // 2
+    #         center_index_y = self.params['Ny'] // 2
+    #         spacing = (Nx - self.params['num_elements'] * element_width_grid_points) // (self.params['num_elements'] + 1)
+    #         current_position = center_index_x - (self.params['num_elements'] * element_width_grid_points + (self.params['num_elements'] - 1) * spacing) // 2
+
+    #         for i in range(self.params['num_elements']):
+    #             if active_list[i] == 1:
+    #                 x_pos = current_position
+    #                 source.p_mask[x_pos:x_pos + element_width_grid_points, center_index_y, 0] = 1
+    #             current_position += element_width_grid_points + spacing
+
+    #         delayed_signals = self._apply_delay()
+    #         source.p =  float(self.params['voltage']) * float(self.params['sensitivity']) * delayed_signals.T

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/AOT_biomaps/AOT_Acoustic/_mainAcoustic.py

@@ -513,7 +513,7 @@ class AcousticField(ABC):
             dx = self.params['dx']
             air_margin = 20 
             if dx >= self.params['element_width']:
-                dx = self.params['element_width'] / 2
+                dx = self.params['element_width']/2
                 if self.params['width_phantom'] is not None:
                     pva_nx = int(np.round((self.params['width_phantom'])/dx))
                     Nx = pva_nx + 2 * air_margin
@@ -530,29 +530,46 @@ class AcousticField(ABC):
                 else:
                     Nx = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / self.params['dx']))
                 if self.params['height_phantom'] is not None:
-                    Nz = int(np.round((self.params['height_phantom'])/self.params['dz']))
+                    Nz = int(np.round((self.params['height_phantom'])/self.params['dx']))
                 else:
-                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / self.params['dz']))
-           
+                    Nz = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / self.params['dx']))
+            
+            Nx_final = int(round((self.params['Xrange'][1] - self.params['Xrange'][0]) / self.params['dx']))
+            Nz_final = int(round((self.params['Zrange'][1] - self.params['Zrange'][0]) / self.params['dx']))
             # --- 2. Time and space factors ---
             factorT = int(np.ceil(self.params['f_AQ'] / self.params['f_saving']))
-            factorX = int(np.ceil(Nx / self.params['Nx']))
-            factorZ = int(np.ceil(Nz / self.params['Nz']))
+            factorX = int(np.ceil(self.params['dx'] / dx))
+            factorZ = factorX
 
             # --- 3. Grid and source initialization ---
             kgrid = kWaveGrid([Nx, Nz], [dx, dx])
-            kgrid.setTime(self.kgrid.Nt, 1 / self.params['f_AQ'])
-            
-            medium = kWaveMedium()
-            medium.sound_speed = np.full((Nx, Nz), 343.0)
-            medium.density = np.full((Nx, Nz), 1.2)
-            x_start, x_end = air_margin, air_margin + pva_nx
-            medium.sound_speed[x_start:x_end, :] = self.params['c0'] # 1540 m/s
-            medium.density[x_start:x_end, :] = self.params.get('density', 1000.0)
+
+            # --- CORRECTIF : Définition du Medium avec hétérogénéité ---
+            # Initialisation en float32 (essentiel pour GPU)
+            c_map = np.full((Nx, Nz), 343.0, dtype=np.float32)  # Air par défaut
+            rho_map = np.full((Nx, Nz), 1.2, dtype=np.float32)
+
+            # Insertion du bloc de PVA
+            x_start = air_margin
+            x_end = air_margin + pva_nx
+            c_map[x_start:x_end, :] = self.params['c0']
+            rho_map[x_start:x_end, :] = self.params.get('density', 1000.0)
+
+            medium = kWaveMedium(sound_speed=c_map, density=rho_map)
+
+            # --- CORRECTIF : Recalcul du pas de temps (CFL) ---
+            # k-Wave a besoin d'un dt basé sur la vitesse MAXIMALE (1540 m/s)
+            c_mean = np.mean(c_map[:, 0]) # mean speed at z=0
+            c_max = np.max(c_map)
+            cfl = 0.3 # Valeur de sécurité
+            dt = cfl * dx / c_max
+            kgrid.setTime(self.kgrid.Nt, dt)
 
 
             source = kSource()
             source.p_mask = np.zeros((Nx, Nz))
+            # Appel à la méthode spécialisée
+            source = self._SetUpSource(source, Nx, dt, dx, c_mean,factorT)  # factorT=1 pour simplifier
 
             # --- 4. Sensor setup ---
             sensor = kSensor()
@@ -564,11 +581,14 @@ class AcousticField(ABC):
             # --- 7. Simulation options ---
             simulation_options = SimulationOptions(
             pml_inside=False, # PML ajoutée autour de la grille Air+PVA
-            pml_size=[pml_size, pml_size],
+            pml_size=[1, pml_size],
             use_sg=False,
             save_to_disk=True,
             input_filename=os.path.join(gettempdir(), "KwaveIN.h5"),
-            output_filename=os.path.join(gettempdir(), "KwaveOUT.h5")
+            output_filename=os.path.join(gettempdir(), "KwaveOUT.h5"),
+            smooth_c0 = True,
+            smooth_rho0 = True,
+            smooth_p0 = True
             )
 
             execution_options = SimulationExecutionOptions(
@@ -577,9 +597,6 @@ class AcousticField(ABC):
                 show_sim_log=show_log
             )
 
-            # --- 7. Call specialized function to set up source.p_mask and source.p ---
-            self._SetUpSource(source, Nx, dx, factorT)
-
             # --- 8. Run simulation ---
             sensor_data = kspaceFirstOrder2D(
                 kgrid=kgrid,
@@ -592,11 +609,12 @@ class AcousticField(ABC):
 
             # --- 9. Post-process results ---
             data = sensor_data['p'].reshape(kgrid.Nt, Nz, Nx)
-
             if factorT != 1 or factorX != 1 or factorZ != 1:
-                return reshape_field(data, [factorT, factorX, factorZ])
+                data = reshape_field(data, [factorT, factorX, factorZ])
+                xStart = (Nx//2)//factorX - (Nx_final//2)
+                return data[:, :Nz_final, xStart:xStart+Nx_final]
             else:
-                return data
+                return data[:, :Nz_final, xStart:xStart+Nx_final]
             
         except Exception as e:
             print(f"Error generating 2D acoustic field: {e}")
@@ -681,7 +699,7 @@ class AcousticField(ABC):
             return None
         
     @abstractmethod
-    def _SetUpSource(self, source, Nx, dx, factorT):
+    def _SetUpSource(self, source, Nx, dt, dx, c0, factorT):
         """
         Abstract method: each subclass must implement its own source setup.
         """

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/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.377'
+__version__ = '2.9.379'
 __process__ = config.get_process()
 
 def initialize(process=None):
@@ -238,6 +238,8 @@ def initialize(process=None):
 
 
 
+
+
 
 
 

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/AOT_biomaps.egg-info/PKG-INFO

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

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/PKG-INFO

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

{aot_biomaps-2.9.377 → aot_biomaps-2.9.379}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='AOT_biomaps',
-    version='2.9.377',
+    version='2.9.379',
     packages=find_packages(),
     include_package_data=True,
     
@@ -396,6 +396,8 @@ setup(
 
 
 
+
+