AOT-biomaps 2.9.188__tar.gz → 2.9.354__tar.gz

{aot_biomaps-2.9.188 → aot_biomaps-2.9.354}/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-2.9.188 → aot_biomaps-2.9.354}/AOT_biomaps/AOT_Acoustic/StructuredWave.py

@@ -292,8 +292,8 @@ class StructuredWave(AcousticField):
                 f"!number format := short float\n"
                 f"!number of bytes per pixel := 4\n"
                 f"scaling factor (mm/pixel) [1] := {self.params['dx'] * 1000}\n"
-                f"scaling factor (mm/pixel) [2] := {self.params['dx'] * 1000}\n"
-                f"scaling factor (s/pixel) [3] := {1 / self.params['f_AQ']}\n"
+                f"scaling factor (mm/pixel) [2] := {self.params['dz'] * 1000}\n"
+                f"scaling factor (s/pixel) [3] := {1 / self.params['f_saving']}\n"
                 f"first pixel offset (mm) [1] := {self.params['Xrange'][0] * 1e3}\n"
                 f"first pixel offset (mm) [2] := {self.params['Zrange'][0] * 1e3}\n"
                 f"first pixel offset (s) [3] := 0\n"

{aot_biomaps-2.9.188 → aot_biomaps-2.9.354}/AOT_biomaps/AOT_Acoustic/_mainAcoustic.py

@@ -19,10 +19,12 @@ from kwave.kspaceFirstOrder3D import kspaceFirstOrder3D
 from kwave.kspaceFirstOrder2D import kspaceFirstOrder2D
 from kwave.options.simulation_options import SimulationOptions
 from kwave.options.simulation_execution_options import SimulationExecutionOptions
+from AOT_biomaps.Settings import Params
 
 from tempfile import gettempdir
 from math import ceil
 from abc import ABC, abstractmethod
+import logging
 
 
 
@@ -75,7 +77,7 @@ class AcousticField(ABC):
             print(f"Initialization error: {e}")
             raise
         if params != None:
-            if type(params) != AOT_biomaps.Settings.Params:
+            if type(params) != Params:
                 raise TypeError("params must be an instance of the Params class")
 
             self.params = {
@@ -225,6 +227,7 @@ class AcousticField(ABC):
         Generate the acoustic field based on the specified simulation type and parameters.
         """
         try:
+            logging.getLogger('root').setLevel(logging.ERROR)
             if self.params['typeSim'] == TypeSim.FIELD2.value:
                 raise NotImplementedError("FIELD2 simulation is not implemented yet.")
             elif self.params['typeSim'] == TypeSim.KWAVE.value:
@@ -265,7 +268,7 @@ class AcousticField(ABC):
             print(f"Error in save_field method: {e}")
             raise
 
-    def load_field(self, folderPath, formatSave=FormatSave.HDR_IMG):
+    def load_field(self, folderPath, formatSave=FormatSave.HDR_IMG, nameBlock=None):
         """
         Load the acoustic field from a file in the specified format.
 
@@ -286,7 +289,7 @@ class AcousticField(ABC):
                         raise NotImplementedError("3D KWAVE field loading is not implemented yet.")
                 elif formatSave.value == FormatSave.H5.value:
                     if self.params["dim"] == Dim.D2.value:
-                         self._load_field_h5(folderPath)
+                         self._load_field_h5(folderPath,nameBlock)
                     elif self.params["dim"] == Dim.D3.value:
                         raise NotImplementedError("H5 KWAVE field loading is not implemented yet.")
                 elif formatSave.value == FormatSave.NPY.value:
@@ -652,7 +655,7 @@ class AcousticField(ABC):
         """
         pass
 
-    def _load_field_h5(self, filePath):
+    def _load_field_h5(self, filePath,nameBlock):
         """
         Load the 2D acoustic field from an H5 file.
 
@@ -663,8 +666,10 @@ class AcousticField(ABC):
         - field (numpy.ndarray): The loaded acoustic field.
         """
         try:
-            with h5py.File(filePath+self.getName_field()+".h5", 'r') as f:
-                self.field = f['data'][:]
+            if nameBlock is None:
+                nameBlock = 'data'
+            with h5py.File(os.path.join(filePath, self.getName_field()+".h5"), 'r') as f:
+                self.field = f[nameBlock][:]
         except Exception as e:
             print(f"Error in _load_field_h5 method: {e}")
             raise

aot_biomaps-2.9.354/AOT_biomaps/AOT_Experiment/ExperimentTools.py

@@ -0,0 +1,69 @@
+import numpy as np
+
+def calc_mat_os(xm, fx, bool_active_list, signal_type):
+    """
+    xm : vecteur des positions réelles des éléments (en m)
+    fx : fréquence spatiale (en m^-1)
+    signal_type : 'cos' ou 'sin'
+    """
+    num_els = len(xm)
+    num_cols = bool_active_list.shape[1]
+
+    if signal_type == 'cos':
+        mask = (np.cos(2 * np.pi * fx * xm) > 0).astype(float)
+    elif signal_type == 'sin':
+        mask = (np.sin(2 * np.pi * fx * xm) > 0).astype(float)
+    else:
+        mask = np.ones(num_els)  # Sécurité
+
+    return np.tile(mask[:, np.newaxis], (1, num_cols))
+
+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)]
+
+def hex_to_binary_profile(hex_string, n_piezos=192):
+    hex_string = hex_string.strip().replace(" ", "").replace("\n", "")
+    if set(hex_string.lower()) == {'f'}:
+        return np.ones(n_piezos, dtype=int)
+    
+    try:
+        n_char = len(hex_string)
+        n_bits = n_char * 4
+        binary_str = bin(int(hex_string, 16))[2:].zfill(n_bits)
+        if len(binary_str) < n_piezos:
+             # Tronquer/padder en fonction de la taille réelle de la sonde
+             binary_str = binary_str.ljust(n_piezos, '0') 
+        elif len(binary_str) > n_piezos:
+             binary_str = binary_str[:n_piezos]
+        return np.array([int(b) for b in binary_str])
+    except ValueError:
+        return np.zeros(n_piezos, dtype=int)
+
+

{aot_biomaps-2.9.188 → aot_biomaps-2.9.354}/AOT_biomaps/AOT_Experiment/Tomography.py

@@ -2,16 +2,24 @@ 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, hex_to_binary_profile
 import os
 import psutil
 import numpy as np
 import matplotlib.pyplot as plt
 from tqdm import trange
+import h5py
+from scipy.io import loadmat, savemat
+
 
 class Tomography(Experiment):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.patterns = None
+        self.theta = []
+        self.decimations = []
+        self.ActiveList = []
+        self.DelayLaw = []
 
     # PUBLIC METHODS
     def check(self):
@@ -47,7 +55,7 @@ class Tomography(Experiment):
             return False, f"OpticImage phantom shape {self.OpticImage.phantom.shape} does not match AcousticFields shape {self.AcousticFields[0].field.shape[1:]}."
         return True, "Experiment is correctly initialized."
 
-    def generateAcousticFields(self, fieldDataPath=None, show_log=True):
+    def generateAcousticFields(self, fieldDataPath=None, show_log=True, nameBlock=None):
         """
         Generate the acoustic fields for simulation.
         Args:
@@ -57,7 +65,30 @@ class Tomography(Experiment):
             systemMatrix: A numpy array of the generated fields.
         """
         if self.TypeAcoustic.value == WaveType.StructuredWave.value:
-            self.AcousticFields = self._generateAcousticFields_STRUCT_CPU(fieldDataPath, show_log)
+            self.AcousticFields = self._generateAcousticFields_STRUCT_CPU(fieldDataPath, show_log, nameBlock)
+            for i in range(len(self.AcousticFields)):
+                profile = hex_to_binary_profile(self.AcousticFields[i].getName_field()[6:-4], self.params.acoustic['num_elements'])
+                self.ActiveList.append(profile)
+                angle = self.AcousticFields[i].angle
+                self.theta.append(angle)
+                Delay = 1000 * (1/self.params.acoustic['c0']) * np.sin(np.deg2rad(angle)) * np.arange(1, self.params.acoustic['num_elements']  + 1) * self.params.acoustic['element_width']
+                self.DelayLaw.append(Delay - np.min(Delay))
+
+                if set(self.AcousticFields[i].getName_field()[6:-4].lower().replace(" ", "")) == {'f'}:
+                    fs_key = 0.0 # fs_key est en mm^-1 (0.0 mm^-1)
+                else:   
+                    ft_prof = np.fft.fft(profile)
+                    idx_max = np.argmax(np.abs(ft_prof[1:len(profile)//2])) + 1
+                    freqs = np.fft.fftfreq(len(profile), d=self.params.general['dx'])
+
+                    # freqs est en m^-1 car delta_x est en mètres.
+                    fs_m_inv = abs(freqs[idx_max]) 
+
+                    fs_key = fs_m_inv # Fréquence spatiale en mm^-1
+
+                # fs = n * dfx  => n = fs / dfx with dfx = 1/(N*delta_x)
+                self.decimations.append(int(fs_key / (1/(len(profile)*self.params.general['dx']))))
+
         else:
             raise ValueError("Unsupported wave type.")
 
@@ -271,7 +302,7 @@ class Tomography(Experiment):
                     line = f"({coords}, {angles})\n"
                     file.write(line)
 
-    def generateActiveList(self, N):
+    def generateActiveList(self, N = None, decimations = None, angles = None):
         """
         Génère une liste de patterns d'activation équilibrés et réguliers.
         Args:
@@ -279,13 +310,139 @@ class Tomography(Experiment):
         Returns:
             list: Liste de strings au format "hex_angle".
         """
-        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.")
+        if decimations is not None and angles is not None:
+            self.patterns = self._genereate_patterns_from_decimations(decimations, angles)
+        elif N is not None and N > 1:
+            self.patterns = self._generate_patterns(N)
+            if not self._check_patterns(self.patterns):
+                raise ValueError("Generated patterns failed validation.")
+        else:
+            raise ValueError("Either N (>=2) or both decimations and angles must be provided for pattern generation.")
+      
+    def saveAOsignals_matlab(self, filePath):
+
+        savemat(filePath, {'data': self.AOsignal_withTumor, 'thetas': self.theta, 'decimations': self.decimations, 'ActiveList' : self.ActiveList, 'DelayLaw': self.DelayLaw})
+
+    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']
+        Width = self.params.acoustic['element_width']  # en m
+        kerf = self.params.acoustic.get('kerf', 0.00000)  # en m
+        Nactuators = self.params.acoustic['num_elements']
+
+        # --- Calcul du nombre de Scans ---
+        if 0 in decimations:
+            Nscans = 4 * len(angles) * (len(decimations) - 1) + len(angles)
+        else:
+            Nscans = 4 * len(angles) * len(decimations)
+
+        ActiveLIST = np.ones((num_elements, Nscans))
+
+        # --- Calcul des positions centrées des éléments (en m) ---
+        Xc = (Width + (Nactuators - 1) * (kerf + Width)) / 2
+        Xm = np.array([Width * (i - 1) + Width / 2 - Xc for i in range(1, Nactuators + 1)])
+
+        # --- Gestion de l'onde plane (tous les piezo ON) au début ---
+        if 0 in decimations:
+            I_plane = np.arange(len(angles))
+            ActiveLIST[:, I_plane] = 1  # Tous les piezo ON pour les len(angles) premières colonnes
 
-    def _generate_patterns(self, N):
+        # --- Traitement des décimations non nulles ---
+        active_decimations = decimations[decimations != 0]
+        dFx = 1 / (Nactuators * Width)  # fx de base (en m^-1)
+
+        for i_dec in range(len(active_decimations)):
+            # Décalage des indices pour placer les motifs modulés après l'onde plane
+            I = np.arange(len(angles)) + len(angles) + (i_dec * 4 * len(angles))
+
+            Icos   = I
+            Incos  = I + 1* len(angles)
+            Isin   = I + 3 * len(angles)
+            Insin  = I + 2 * len(angles)
+
+            fx = dFx * active_decimations[i_dec]
+
+            # Appliquer les motifs modulés
+            ActiveLIST[:, Icos] = calc_mat_os(Xm, fx, ActiveLIST[:, Icos[:1]], 'cos')
+            ActiveLIST[:, Incos] = 1 - ActiveLIST[:, Icos]
+            ActiveLIST[:, Isin] = calc_mat_os(Xm, fx, ActiveLIST[:, Isin[:1]], 'sin')
+            ActiveLIST[:, Insin] = 1 - ActiveLIST[:, Isin]
+
+        # --- Conversion au format attendu ---
+        hexa_list = convert_to_hex_list(ActiveLIST)
+
+        def format_angle(a):
+            return f"{'1' if a < 0 else '0'}{abs(a):02d}"
+
+        patterns = []
+        print(f"Generating {Nscans} patterns from decimations and angles...")
+        for i in range(Nscans):
+            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}"
 
@@ -296,7 +453,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]
@@ -388,8 +551,82 @@ 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):
+    def _generateAcousticFields_STRUCT_CPU(self, fieldDataPath=None, show_log=False, nameBlock=None):
         if self.patterns is None:
             raise ValueError("patterns is not initialized. Please load or generate the active list first.")
         listAcousticFields = []
@@ -415,7 +652,7 @@ class Tomography(Experiment):
             if pathField is not None and os.path.exists(pathField):
                 progress_bar.set_postfix_str(f"Loading field - {AcousticField.getName_field()} -- Memory used: {memory.percent}%")
                 try:
-                    AcousticField.load_field(fieldDataPath, self.FormatSave)
+                    AcousticField.load_field(fieldDataPath, self.FormatSave,nameBlock)
                 except:
                     progress_bar.set_postfix_str(f"Error loading field -> Generating field - {AcousticField.getName_field()} -- Memory used: {memory.percent}% ---- processing on {config.get_process().upper()} ----")
                     AcousticField.generate_field(show_log=show_log)
@@ -432,4 +669,73 @@ class Tomography(Experiment):
                     AcousticField.save_field(fieldDataPath)
             listAcousticFields.append(AcousticField)
             progress_bar.set_postfix_str("")
+
         return listAcousticFields
+
+    def load_experimentalAO(self, pathAO, withTumor = True, h5name='AOsignal'):
+        """
+        Load experimental AO signals from specified file paths.
+        Args:
+            path_withTumor: Path to the AO signal with tumor.
+            path_withoutTumor: Path to the AO signal without tumor.
+        """
+        if not os.path.exists(pathAO):
+            raise FileNotFoundError(f"File {pathAO} not found.")
+
+        if pathAO.endswith('.npy'):
+            ao_signal = np.load(pathAO)
+        elif pathAO.endswith('.h5'):
+            with h5py.File(pathAO, 'r') as f:
+                if h5name not in f:
+                    raise KeyError(f"Dataset '{h5name}' not found in the HDF5 file.")
+                ao_signal = f[h5name][:]
+        elif pathAO.endswith('.mat'):
+            mat_data = loadmat(pathAO)
+            if h5name not in mat_data:
+                raise KeyError(f"Dataset '{h5name}' not found in the .mat file.")
+            ao_signal = mat_data[h5name]
+        elif pathAO.endswith('.hdr'):
+            ao_signal = self._loadAOSignal(pathAO)
+        else:
+            raise ValueError("Unsupported file format. Supported formats are: .npy, .h5, .mat, .hdr")
+        
+        if withTumor:
+            self.AOsignal_withTumor = ao_signal
+        else:
+            self.AOsignal_withoutTumor = ao_signal
+
+    def check_experimentalAO(self, activeListPath, withTumor=True):
+        """
+        Check if the experimental AO signals are correctly initialized.
+        """
+        if withTumor:
+            if self.AOsignal_withTumor is None:
+                raise ValueError("Experimental AOsignal with tumor is not initialized. Please load the experimental AO signal with tumor first.")
+        else:
+            if self.AOsignal_withoutTumor is None:
+                raise ValueError("Experimental AOsignal without tumor is not initialized. Please load the experimental AO signal without tumor first.")
+        if self.AcousticFields is not None:
+            # get min time shape between all AO signals
+            print()
+            
+            if self.AcousticFields[0].field.shape[0] > self.AOsignal_withTumor.shape[0]:
+                self.cutAcousticFields(max_t=self.AOsignal_withTumor.shape[0]/float(self.params.acoustic['f_saving']))
+            else:
+                for i in range(len(self.AcousticFields)):
+                    min_time_shape = min(self.AcousticFields[i].field.shape[0])
+                if withTumor:
+                    self.AOsignal_withTumor = self.AOsignal_withTumor[:min_time_shape, :]
+                else:
+                    self.AOsignal_withoutTumor = self.AOsignal_withoutTumor[:min_time_shape, :]
+
+            for field in self.AcousticFields:                        
+                if activeListPath is not None:
+                    with open(activeListPath, 'r') as file:
+                        lines = file.readlines()
+                        expected_name = lines[self.AcousticFields.index(field)].strip()
+                        nameField = field.getName_field()
+                        if nameField.startswith("field_"):
+                            nameField = nameField[len("field_"):]
+                        if nameField != expected_name:
+                            raise ValueError(f"Field name {nameField} does not match the expected name {expected_name} from the active list.")
+        print("Experimental AO signals are correctly initialized.")