Model/create_table_for_save_as.py

@@ -389,6 +389,10 @@ class CreateTableForSaveAs:
                 )
             )
 
+            logger.debug(f"stg.ind_bottom: {stg.ind_bottom[i]}")
+            logger.debug(np.array([stg.ind_bottom[i]]),
+                         np.array(stg.ind_bottom[i]).shape)
+
         # Commit the transaction after executing INSERT.
         cnx.commit()
 
@@ -442,7 +446,7 @@ class CreateTableForSaveAs:
 
         cur.execute(self.create_SedimentsFile)
 
-        if stg.path_fine != "" and stg.path_sand != "":
+        if stg.path_fine != "" and path_sand != "":
             cur.execute(
                 """
                 INSERT into SedimentsFile(

README.md

@@ -11,13 +11,17 @@ It is divided in six tabs:
 - Calibration : calibration parameter are computed
 - Inversion : inversion method is calculated to provide fine and sand sediments fields
 
-## Installation
+## Software documentation
+
+### Installation
 
 Acoused is developped for Linux and Windows on Python version 3.8 or
 greater. By default, Acoused is developped with Pypi package
 dependencies, but is also possible to use Guix package manager to run
 Acoused.
 
+## Development documentation
+
 ### **TODO** Windows
 
 ### Linux
@@ -45,6 +49,27 @@ script `guix.sh` to run the program.
   guix shell sqlitebrowser -- ./guix.sh
 ```
 
+## License
+
+AcouSed 
+Copyright (C) 2024 - INRAE 
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. 
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details. 
+
+You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+## Authors & Contacts
+
+- Brahim MOUDJED  2022-2025 ([INRAE](https://www.inrae.fr/))
+- Pierre-Antoine ROUBY  2025 ([TECC](https://parouby.fr))
+
+If you have any questions or suggestions, please contact us to celine.berni@inrae.fr and/or jerome.lecoz@inrae.fr.
+
+## Acknowledgment (Funding)
+This study was conducted within the [Rhône Sediment Observatory](https://observatoire-sediments-rhone.fr/) (OSR), a multi-partner research program funded through the Plan Rhône by the European Regional Development Fund (ERDF), Agence de l’Eau RMC, CNR, EDF and three regional councils (Auvergne-Rhône-Alpes, PACA and Occitanie). It was also support by CNR. 
+
 ## Support files & References 
 
 - [ ] [Acoustic inversion method diagram](https://forgemia.inra.fr/theophile.terraz/acoused/-/blob/main/Acoustic_Inversion_theory.pdf?ref_type=heads) 
@@ -55,24 +80,3 @@ script `guix.sh` to run the program.
 - [ ] [Vergne A., Le Coz J., Berni C., & Pierrefeu G. (2020), Water Resources Research, 56(2)](https://doi.org/10.1029/2019WR024877)
 - [ ] [Vergne A., Berni C., Le Coz J., & Tencé F., (2021), Water Resources Research, 57(9)](https://doi.org/10.1029/2021WR029589)
 
-## Authors & Contacts
-
-- Brahim MOUDJED  2022-2025 ([INRAE](https://www.inrae.fr/))
-- Pierre-Antoine ROUBY  2025 ([TECC](https://parouby.fr))
-
-If you have any questions or suggestions, please contact us to celine.berni@inrae.fr and/or jerome.lecoz@inrae.fr.
-
-## Acknowledgment (Funding)
-
-This study was conducted within the [Rhône Sediment Observatory](https://observatoire-sediments-rhone.fr/) (OSR), a multi-partner research program funded through the Plan Rhône by the European Regional Development Fund (ERDF), Agence de l’Eau RMC, CNR, EDF and three regional councils (Auvergne-Rhône-Alpes, PACA and Occitanie). It was also support by CNR.
-
-## License
-
-AcouSed
-Copyright (C) 2024-2025 - INRAE
-
-This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.

View/acoustic_inversion_tab.py

@@ -20,11 +20,16 @@
 
 # -*- coding: utf-8 -*-
 
-import os
-import numpy as np
-import pandas as pd
 
-from copy import deepcopy
+import pandas as pd
+from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QComboBox,
+                             QLabel, QPushButton, QSpacerItem,
+                             QSlider, QLineEdit, QMessageBox, QFileDialog)
+
+from PyQt5.QtCore import QCoreApplication, Qt
+from PyQt5.QtGui import QIcon, QPixmap
+
+import numpy as np
 
 import matplotlib.pyplot as plt
 
@@ -32,14 +37,9 @@ from matplotlib.colors import LogNorm
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar
 
-from PyQt5.QtWidgets import (
+from os import chdir
-    QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QComboBox,
-    QLabel, QPushButton, QSpacerItem, QSlider, QLineEdit,
-    QMessageBox, QFileDialog
-)
 
-from PyQt5.QtCore import QCoreApplication, Qt
+from copy import deepcopy
-from PyQt5.QtGui import QIcon, QPixmap
 
 from View.checkable_combobox import CheckableComboBox
 
@@ -1671,81 +1671,96 @@ class AcousticInversionTab(QWidget):
                 self.figure_measured_vs_inverted_sand.canvas.draw_idle()
 
     def save_result_in_excel_file(self):
+
         if self.combobox_acoustic_data_choice.count() > 0:
+
             name = QFileDialog.getSaveFileName(
-                caption="Save As - Inversion results",
+                caption="Save As - Inversion results", directory="", filter="Excel Files (*.xlsx)",
-                directory="",
+                options=QFileDialog.DontUseNativeDialog)
-                filter="Excel Files (*.xlsx)",
-                options=QFileDialog.DontUseNativeDialog
-            )
 
             if name[0]:
-                dirname = os.path.dirname(name[0])
+                dirname = "/".join(name[0].split("/")[:-1]) + "/"
-                filename = os.path.basename(name[0])
+                filename = name[0].split("/")[-1]
-                os.chdir(dirname)
+                chdir(dirname)
-
-            results = []
 
             for k in range(self.combobox_acoustic_data_choice.count()):
+
                 if stg.time_cross_section[k].shape != (0,):
-                    time_data = stg.time_cross_section
+
+                    if stg.depth_cross_section[k].shape != (0,):
+
+                        t = np.repeat(stg.time_cross_section[k][stg.frequency_for_inversion[1]],
+                                      stg.depth_cross_section[k].shape[1])
+
+                        r = np.zeros((stg.depth_cross_section[k].shape[1] *stg.time_cross_section[k].shape[1],1))
+
+                        for i in range(stg.time_cross_section[k].shape[1]):
+                            for j in range(stg.depth_cross_section[k].shape[1]):
+                                r[i * stg.depth_cross_section[k].shape[1] + j] = (
+                                    stg.depth_cross_section[k][int(stg.frequency_for_inversion[1]), j])
+
+                        if stg.SSC_fine[k].shape == (0,):
+                            stg.SSC_fine[k] = np.zeros(r.shape[0])
+                        if stg.SSC_sand[k].shape == (0,):
+                            stg.SSC_sand[k] = np.zeros(r.shape[0])
+
+                    else:
+
+                        t = np.repeat(stg.time_cross_section[k][stg.frequency_for_inversion[1]], stg.depth[k].shape[1])
+
+                        r = np.zeros((stg.depth[k].shape[1] * stg.time_cross_section[k].shape[1], 1))
+                        for i in range(stg.time_cross_section[k].shape[1]):
+                            for j in range(stg.depth[k].shape[1]):
+                                r[i * stg.depth[k].shape[1] + j] = (
+                                    stg.depth[k][int(stg.frequency_for_inversion[1]), j])
+
+                        if stg.SSC_fine[k].shape == (0,):
+                            stg.SSC_fine[k] = np.zeros(r.shape[0])
+                        if stg.SSC_sand[k].shape == (0,):
+                            stg.SSC_sand[k] = np.zeros(r.shape[0])
+
                 else:
-                    time_data = stg.time
 
-                if stg.depth_cross_section[k].shape != (0,):
+                    if stg.depth_cross_section[k].shape != (0,):
-                    depth_data = stg.depth_cross_section
+
-                else:
+                        t = np.repeat(stg.time[k][stg.frequency_for_inversion[1]], stg.depth_cross_section[k].shape[1])
-                    depth_data = stg.depth
+
+                        r = np.zeros((stg.depth_cross_section[k].shape[1] * stg.time[k].shape[1], 1))
+                        for i in range(stg.time[k].shape[1]):
+                            for j in range(stg.depth_cross_section[k].shape[1]):
+                                r[i * stg.depth_cross_section[k].shape[1] + j] = (
+                                    stg.depth_cross_section[k][int(stg.frequency_for_inversion[1]), j])
+
+                        if stg.SSC_fine[k].shape == (0,):
+                            stg.SSC_fine[k] = np.zeros(r.shape[0])
+                        if stg.SSC_sand[k].shape == (0,):
+                            stg.SSC_sand[k] = np.zeros(r.shape[0])
+
+                    else:
+
+                        t = np.repeat(stg.time[k][stg.frequency_for_inversion[1]], stg.depth[k].shape[1])
+
+                        r = np.zeros(stg.depth[k].shape[1] * stg.time[k].shape[1])
+
+                        for i in range(stg.time[k].shape[1]):
+                            for j in range(stg.depth[k].shape[1]):
+                                r[i * stg.depth[k].shape[1] + j] = (
+                                    stg.depth[k][int(stg.frequency_for_inversion[1]), j])
+
+                        if stg.SSC_fine[k].shape == (0,):
+                            stg.SSC_fine[k] = np.zeros(r.shape[0])
+                        if stg.SSC_sand[k].shape == (0,):
+                            stg.SSC_sand[k] = np.zeros(r.shape[0])
+
+                exec("result_" + str(k)  + "= pd.DataFrame({'Time (sec)': t," +
+                                                           "'Depth (m)': r," +
+                                                           "'SSC_fine (g/L)': stg.SSC_fine[" + str(k) + "].reshape(t.shape[0])," +
+                                                           "'SSC_sand (g/L)': stg.SSC_sand[" + str(k) + "].reshape(t.shape[0])})")
 
 
-                t = np.repeat(
-                    time_data[k][stg.frequency_for_inversion[1]],
-                    depth_data[k].shape[1]
-                )
 
-                r = np.zeros(
+            with pd.ExcelWriter(dirname + filename + '.xlsx') as writer:
-                    depth_data[k].shape[1] * time_data[k].shape[1]
-                )
-
-                for i in range(time_data[k].shape[1]):
-                    for j in range(depth_data[k].shape[1]):
-                        r_id = i * depth_data[k].shape[1] + j
-
-                        r[r_id] = (
-                            depth_data[k][
-                                int(stg.frequency_for_inversion[1]), j
-                            ]
-                        )
-
-                if stg.SSC_fine[k].shape == (0,):
-                    stg.SSC_fine[k] = np.zeros(r.shape[0])
-                if stg.SSC_sand[k].shape == (0,):
-                    stg.SSC_sand[k] = np.zeros(r.shape[0])
-
-                results.append(
-                    pd.DataFrame(
-                        {
-                            'Time (sec)': list(t),
-                            'Depth (m)': list(r),
-                            'SSC_fine (g/L)': list(
-                                stg.SSC_fine[k].reshape(t.shape[0])
-                            ),
-                            'SSC_sand (g/L)': list(
-                                stg.SSC_sand[k].reshape(t.shape[0])
-                            ),
-                        }
-                    )
-                )
-
-            if os.path.splitext(filename)[1] != ".xlsx":
-                filename += ".xlsx"
-
-            with pd.ExcelWriter(
-                    os.path.join(dirname, filename)
-            ) as writer:
                 for k in range(self.combobox_acoustic_data_choice.count()):
-                    results[k].to_excel(
+                    eval("result_" + str(k) + ".to_excel(writer, index=False, " +
-                        writer, index=False,
+                        "engine='xlsxwriter', na_rep='NA', " +
-                        engine='xlsxwriter', na_rep='NA',
+                        "sheet_name=stg.data_preprocessed[" + str(k) + "])")
-                        sheet_name=stg.data_preprocessed[k],
-                    )

View/mainwindow.py

@@ -147,14 +147,12 @@ class Ui_MainWindow(object):
         icon6.addPixmap(QtGui.QPixmap("icons/en.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.actionEnglish.setIcon(icon6)
         self.actionEnglish.setObjectName("actionEnglish")
-        self.actionEnglish.setEnabled(False)
 
         self.actionFrench = QtWidgets.QAction(self.mainwindow)
         icon7 = QtGui.QIcon()
         icon7.addPixmap(QtGui.QPixmap("icons/fr.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.actionFrench.setIcon(icon7)
         self.actionFrench.setObjectName("actionFrench")
-        self.actionFrench.setEnabled(False)
 
         self.action_ABSCalibrationConstant = QtWidgets.QAction(self.mainwindow)
         self.action_ABSCalibrationConstant.setText("ABS constant calibration kt")
@@ -270,10 +268,7 @@ class Ui_MainWindow(object):
         )
 
     def save(self):
-        if stg.dirname_save_as:
+        UpdateTableForSave()
-            UpdateTableForSave()
-        else:
-            self.save_as()
 
     def open(self):
         reader = ReadTableForOpen()

View/sediment_calibration_tab.py

@@ -1716,18 +1716,14 @@ class SedimentCalibrationTab(QWidget):
         self.animaiton_groupbox_compute.start()
 
     def import_calibration_file(self):
+
         filename = QFileDialog.getOpenFileName(
             self, "Open calibration",
-            [
+            [stg.path_calibration_file if stg.path_calibration_file else
-                stg.path_calibration_file
+                                                stg.path_BS_raw_data[
-                if stg.path_calibration_file
+                                                    -1] if self.combobox_acoustic_data_choice.count() > 0 else ""][0],
-                else stg.path_BS_raw_data[-1]
-                if self.combobox_acoustic_data_choice.count() > 0
-                else ""
-            ][0],
             "Calibration file (*.xls, *.ods, *csv)",
-            options=QFileDialog.DontUseNativeDialog
+        options=QFileDialog.DontUseNativeDialog)
-        )
 
         dir_name = os.path.dirname(filename[0])
         name = os.path.basename(filename[0])
@@ -1740,188 +1736,114 @@ class SedimentCalibrationTab(QWidget):
 
         self.lineEdit_import_calibration.setToolTip(dir_name)
 
-        self.compute_depth_2D()
         self.read_calibration_file_and_fill_parameter()
 
     def update_label_freq1_for_calibration(self):
         self.label_freq1.clear()
-        self.label_freq1.setText(
+        self.label_freq1.setText(str(self.combobox_freq1.currentText()))
-            str(self.combobox_freq1.currentText())
-        )
 
     def update_label_freq2_for_calibration(self):
         self.label_freq2.clear()
-        self.label_freq2.setText(
+        self.label_freq2.setText(self.combobox_freq2.currentText())
-            self.combobox_freq2.currentText()
-        )
 
     def update_label_kt_value_for_calibration(self):
-        print("self.combobox_freq1.currentIndex() ",
-              self.combobox_freq1.currentIndex(),
-              self.combobox_freq1.currentText())
-
-        freq_1 = self.combobox_freq1.currentIndex()
-        freq_2 = self.combobox_freq2.currentIndex()
-
         self.label_kt_freq1.clear()
-        if stg.kt_corrected[freq_1] != stg.kt_read[freq_1]:
+        print("self.combobox_freq1.currentIndex() ", self.combobox_freq1.currentIndex(), self.combobox_freq1.currentText())
-            self.label_kt_freq1.setText(
+        if stg.kt_corrected[self.combobox_freq1.currentIndex()] != stg.kt_read[self.combobox_freq1.currentIndex()]:
-                str('%.4f' % stg.kt_corrected[freq_1])
+            self.label_kt_freq1.setText(str('%.4f' % stg.kt_corrected[self.combobox_freq1.currentIndex()]))
-            )
         else:
-            self.label_kt_freq1.setText(
+            self.label_kt_freq1.setText(str('%.4f' % stg.kt_read[self.combobox_freq1.currentIndex()]))
-                str('%.4f' % stg.kt_read[freq_1])
-            )
 
         self.label_kt_freq2.clear()
-        if stg.kt_corrected[freq_2] != stg.kt_read[freq_2]:
+        if stg.kt_corrected[self.combobox_freq2.currentIndex()] != stg.kt_read[self.combobox_freq2.currentIndex()]:
-            self.label_kt_freq2.setText(
+            self.label_kt_freq2.setText(str('%.4f' % stg.kt_corrected[self.combobox_freq2.currentIndex()]))
-                str('%.4f' % stg.kt_corrected[freq_2])
-            )
         else:
-            self.label_kt_freq2.setText(
+            self.label_kt_freq2.setText(str('%.4f' % stg.kt_read[self.combobox_freq2.currentIndex()]))
-                str('%.4f' % stg.kt_read[freq_2])
-            )
 
     def read_calibration_file_and_fill_parameter(self):
         if self.combobox_acoustic_data_choice.count() == 0:
+
             msgBox = QMessageBox()
             msgBox.setWindowTitle("Calibration import error")
             msgBox.setIconPixmap(
-                QPixmap(
+                QPixmap(self._path_icon("no_approved.png")).scaledToHeight(32, Qt.SmoothTransformation))
-                    self._path_icon("no_approved.png")
-                ).scaledToHeight(32, Qt.SmoothTransformation)
-            )
             msgBox.setText("Update data before importing calibration")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
 
-        elif stg.filename_calibration_file == "":
-
-            pass
-
         else:
+
             # --- Read calibration file ---
-            data = pd.read_csv(os.path.join(stg.path_calibration_file, stg.filename_calibration_file), header=0, index_col=0)
+            data = pd.read_csv(stg.path_calibration_file + "/" + stg.filename_calibration_file, header=0, index_col=0)
 
             # --- Fill spinboxes of calibration parameter ---
             self.label_temperature.clear()
-            self.label_temperature.setText(
+            self.label_temperature.setText("T = " + str(stg.temperature) + " °C")
-                "T = " + str(stg.temperature) + " °C"
-            )
 
             self.label_freq1.clear()
             self.label_freq1.setText(data.columns[0])
 
-            data_id = self.combobox_acoustic_data_choice.currentIndex()
+            index_freq1 = np.where(np.asarray(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()]) ==
-
+                                   data.columns[0])[0][0]
-            index_freq1 = np.where(
-                np.asarray(
-                    stg.freq_text[data_id]
-                ) == data.columns[0]
-            )[0][0]
-
             stg.frequencies_for_calibration.clear()
-            stg.frequencies_for_calibration.append(
+            stg.frequencies_for_calibration.append((stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
-                (
+                                                        index_freq1],
-                    stg.freq[data_id][index_freq1],
+                                                    index_freq1))
-                    index_freq1
-                )
-            )
 
             self.label_freq2.clear()
             self.label_freq2.setText(data.columns[1])
 
-            index_freq2 = np.where(
+            index_freq2 = np.where(np.asarray(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()]) ==
-                np.asarray(
+                                   data.columns[1])[0][0]
-                    stg.freq_text[data_id]
+            stg.frequencies_for_calibration.append((stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
-                ) == data.columns[1]
+                                                        index_freq2],
-            )[0][0]
+                                                    index_freq2))
-
-            stg.frequencies_for_calibration.append(
-                (
-                    stg.freq[data_id][index_freq2],
-                    index_freq2
-                )
-            )
 
             stg.frequency_for_inversion = tuple()
-            stg.frequency_for_inversion = (
+            stg.frequency_for_inversion = (stg.freq[self.combobox_acoustic_data_choice.currentIndex()][index_freq2],
-                stg.freq[data_id][index_freq2],
+                                           index_freq2)
-                index_freq2
-            )
 
             self.lineEdit_ks_freq1.clear()
-            self.lineEdit_ks_freq1.setText(
+            self.lineEdit_ks_freq1.setText(str("%.5f" % float(data.iloc[0][0])))
-                str("%.5f" % float(data.iloc[0][0]))
-            )
 
             self.lineEdit_ks_freq2.clear()
-            self.lineEdit_ks_freq2.setText(
+            self.lineEdit_ks_freq2.setText(str("%.5f" % float(data.iloc[0][1])))
-                str("%.5f" % float(data.iloc[0][1]))
-            )
 
             stg.ks.clear()
-            stg.ks = [
+            stg.ks = [float(self.lineEdit_ks_freq1.text()), float(self.lineEdit_ks_freq2.text())]
-                float(self.lineEdit_ks_freq1.text()),
-                float(self.lineEdit_ks_freq2.text())
-            ]
 
             self.lineEdit_sv_freq1.clear()
-            self.lineEdit_sv_freq1.setText(
+            self.lineEdit_sv_freq1.setText(str("%.5f" % float(data.iloc[1][0])))
-                str("%.5f" % float(data.iloc[1][0]))
-            )
 
             self.lineEdit_sv_freq2.clear()
-            self.lineEdit_sv_freq2.setText(
+            self.lineEdit_sv_freq2.setText(str("%.5f" % float(data.iloc[1][1])))
-                str("%.5f" % float(data.iloc[1][1]))
-            )
 
             stg.sv.clear()
-            stg.sv = [
+            stg.sv = [float(self.lineEdit_sv_freq1.text()), float(self.lineEdit_sv_freq2.text())]
-                float(self.lineEdit_sv_freq1.text()),
-                float(self.lineEdit_sv_freq2.text())
-            ]
 
             self.lineEdit_X.clear()
-            self.lineEdit_X.setText(
+            self.lineEdit_X.setText(str("%.2f" % float(data.iloc[2][0])))
-                str("%.2f" % float(data.iloc[2][0]))
-            )
 
             stg.X_exponent.clear()
             stg.X_exponent.append(float(self.lineEdit_X.text()))
 
             self.lineEdit_alphas_freq1.clear()
-            self.lineEdit_alphas_freq1.setText(
+            self.lineEdit_alphas_freq1.setText(str("%.5f" % float(data.iloc[3][0])))
-                str("%.5f" % float(data.iloc[3][0]))
-            )
 
             self.lineEdit_alphas_freq2.clear()
-            self.lineEdit_alphas_freq2.setText(
+            self.lineEdit_alphas_freq2.setText(str("%.5f" % float(data.iloc[3][1])))
-                str("%.5f" % float(data.iloc[3][1]))
-            )
 
             stg.alpha_s.clear()
-            stg.alpha_s = [
+            stg.alpha_s = [float(self.lineEdit_alphas_freq1.text()), float(self.lineEdit_alphas_freq2.text())]
-                float(self.lineEdit_alphas_freq1.text()),
-                float(self.lineEdit_alphas_freq2.text())
-            ]
 
             self.lineEdit_zeta_freq1.clear()
-            self.lineEdit_zeta_freq1.setText(
+            self.lineEdit_zeta_freq1.setText(str("%.5f" % float(data.iloc[4][0])))
-                str("%.5f" % float(data.iloc[4][0]))
-            )
 
             self.lineEdit_zeta_freq2.clear()
-            self.lineEdit_zeta_freq2.setText(
+            self.lineEdit_zeta_freq2.setText(str("%.5f" % float(data.iloc[4][1])))
-                str("%.5f" % float(data.iloc[4][1]))
-            )
 
             stg.zeta.clear()
-            stg.zeta = [
+            stg.zeta = [float(self.lineEdit_zeta_freq1.text()), float(self.lineEdit_zeta_freq2.text())]
-                float(self.lineEdit_zeta_freq1.text()),
-                float(self.lineEdit_zeta_freq2.text())
-            ]
 
             self.compute_kt2D_kt3D()
             self.compute_J_cross_section()
@@ -2009,8 +1931,8 @@ class SedimentCalibrationTab(QWidget):
         self.compute_zeta()
 
     def compute_ks(self):
-        data_id = self.combobox_acoustic_data_choice.currentIndex()
 
+        # --- Compute ks ---
         psd_number_of_particles = (
             self.inv_hc.compute_particle_size_distribution_in_number_of_particles(
                 num_sample=stg.sand_sample_target[0][1],
@@ -2021,13 +1943,17 @@ class SedimentCalibrationTab(QWidget):
 
         ks_freq1 = self.inv_hc.ks(
             proba_num=psd_number_of_particles,
-            freq=stg.freq[data_id][self.combobox_freq1.currentIndex()],
+            freq=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
+                self.combobox_freq1.currentIndex()
+            ],
             C=stg.water_velocity
         )
 
         ks_freq2 = self.inv_hc.ks(
             proba_num=psd_number_of_particles,
-            freq=stg.freq[data_id][self.combobox_freq2.currentIndex()],
+            freq=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
+                self.combobox_freq2.currentIndex()
+            ],
             C=stg.water_velocity
         )
 
@@ -2035,12 +1961,12 @@ class SedimentCalibrationTab(QWidget):
 
         logger.debug(
             "ks for frequency of "
-            + f"{stg.freq[data_id][self.combobox_freq1.currentIndex()]} : "
+            + f"{stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()]} : "
             + f"{ks_freq1} m/kg^0.5 \n"
         )
         logger.debug(
             "ks for frequency of "
-            + f"{stg.freq[data_id][self.combobox_freq2.currentIndex()]} : " +
+            + f"{stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()]} : " +
             f"{ks_freq2} m/kg^0.5"
         )
 
@@ -2051,21 +1977,13 @@ class SedimentCalibrationTab(QWidget):
         self.lineEdit_ks_freq2.setText(str("%.5f" % ks_freq2))
 
     def compute_sv(self):
-        data_id = self.combobox_acoustic_data_choice.currentIndex()
-
         sv_freq1 = self.inv_hc.sv(ks=stg.ks[0], M_sand=stg.Ctot_sand[stg.sand_sample_target[0][1]])
         sv_freq2 = self.inv_hc.sv(ks=stg.ks[1], M_sand=stg.Ctot_sand[stg.sand_sample_target[0][1]])
 
         stg.sv = [sv_freq1, sv_freq2]
 
-        print(
+        print(f"sv for frequency of {stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()]} : {sv_freq1:.8f} /m \n")
-            f"sv for frequency of {stg.freq[data_id][self.combobox_freq1.currentIndex()]}"
+        print(f"sv for frequency of {stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()]} : {sv_freq2:.8f} /m")
-            + f" : {sv_freq1:.8f} /m \n"
-        )
-        print(
-            f"sv for frequency of {stg.freq[data_id][self.combobox_freq2.currentIndex()]}"
-            + f" : {sv_freq2:.8f} /m"
-        )
 
         self.lineEdit_sv_freq1.clear()
         self.lineEdit_sv_freq1.setText(str("%.5f" % sv_freq1))
@@ -2074,13 +1992,9 @@ class SedimentCalibrationTab(QWidget):
         self.lineEdit_sv_freq2.setText(str("%.5f" % sv_freq2))
 
     def compute_X(self):
-        data_id = self.combobox_acoustic_data_choice.currentIndex()
+        X_exponent = self.inv_hc.X_exponent(freq1=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()],
-
+                                            freq2=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()],
-        X_exponent = self.inv_hc.X_exponent(
+                                            sv_freq1=stg.sv[0], sv_freq2=stg.sv[1])
-            freq1=stg.freq[data_id][self.combobox_freq1.currentIndex()],
-            freq2=stg.freq[data_id][self.combobox_freq2.currentIndex()],
-            sv_freq1=stg.sv[0], sv_freq2=stg.sv[1]
-        )
 
         stg.X_exponent.clear()
         stg.X_exponent.append(X_exponent)
@@ -2123,90 +2037,190 @@ class SedimentCalibrationTab(QWidget):
             )
 
     def compute_J_cross_section(self):
-        lst_bs_data = [
-            stg.BS_stream_bed_pre_process_average,
-            stg.BS_stream_bed_pre_process_SNR,
-            stg.BS_stream_bed,
-            stg.BS_cross_section_pre_process_average,
-            stg.BS_cross_section_pre_process_SNR,
-            stg.BS_cross_section,
-            stg.BS_raw_data_pre_process_average,
-            stg.BS_raw_data_pre_process_SNR,
-            stg.BS_raw_data
-        ]
-
         for i in range(self.combobox_acoustic_data_choice.count()):
 
             J_cross_section_freq1 = np.array([])
             J_cross_section_freq2 = np.array([])
 
-            for data in lst_bs_data:
+            # --- Compute J ---
-                if data[i].shape != (0,):
+            if stg.BS_stream_bed_pre_process_average[i].shape != (0,):
-                    bs_data = data
-                    break
 
-            print(f"{stg.depth_2D[i].shape}")
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
-            print(f"{stg.depth_2D[i]}")
+                    BS=stg.BS_stream_bed_pre_process_average[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
 
-            J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
-                BS = bs_data[i][
+                    BS=stg.BS_stream_bed_pre_process_average[i][
-                    stg.frequencies_for_calibration[0][1], :, :
+                       stg.frequencies_for_calibration[1][1], :, :],
-                ],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1],
-                r2D = stg.depth_2D[i][
+                        :, :],
-                        stg.frequencies_for_calibration[0][1], :, :
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
-                ],
-                kt = stg.kt3D[i][
-                    stg.frequencies_for_calibration[0][1], :, :
-                ]
-            )
 
-            J_cross_section_freq2 = self.inv_hc.j_cross_section(
+            elif stg.BS_stream_bed_pre_process_SNR[i].shape != (0,):
-                BS = bs_data[i][
+
-                    stg.frequencies_for_calibration[1][1], :, :
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
-                ],
+                    BS=stg.BS_stream_bed_pre_process_SNR[i][
-                r2D = stg.depth_2D[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
-                    stg.frequencies_for_calibration[1][1], :, :
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1],
-                ],
+                        :, :],
-                kt = stg.kt3D[i][
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
-                    stg.frequencies_for_calibration[1][1], :, :
+
-                ]
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
-            )
+                    BS=stg.BS_stream_bed_pre_process_SNR[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_stream_bed[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_stream_bed[i][stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_stream_bed[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_cross_section_pre_process_average[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section_pre_process_average[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section_pre_process_average[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_cross_section_pre_process_SNR[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section_pre_process_SNR[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section_pre_process_SNR[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1],
+                        :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_cross_section[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i, :, :][stg.frequencies_for_calibration[0][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_cross_section[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i, :, :][stg.frequencies_for_calibration[1][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_raw_data_pre_process_average[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data_pre_process_average[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data_pre_process_average[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_raw_data_pre_process_SNR[i].shape != (0,):
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data_pre_process_SNR[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data_pre_process_SNR[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+
+            elif stg.BS_raw_data:
+
+                J_cross_section_freq1 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data[i][
+                       stg.frequencies_for_calibration[0][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+
+                J_cross_section_freq2 = self.inv_hc.j_cross_section(
+                    BS=stg.BS_raw_data[i][
+                       stg.frequencies_for_calibration[1][1], :, :],
+                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1], :, :],
+                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
 
             stg.J_cross_section[i][0] = J_cross_section_freq1
             stg.J_cross_section[i][1] = J_cross_section_freq2
 
     def compute_alpha_s(self):
-        data_id = self.combobox_acoustic_data_choice.currentIndex()
-        freq_1 = self.combobox_freq1.currentIndex()
-        freq_2 = self.combobox_freq2.currentIndex()
 
-        depth_data = stg.depth
+        # --- Compute alpha_s ---
-        if stg.depth_cross_section[data_id].shape != (0,):
+        if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-            depth_data = stg.depth_cross_section
 
-        alpha_s_freq1 = self.inv_hc.alpha_s(
+            alpha_s_freq1 = self.inv_hc.alpha_s(
-            sv=stg.sv[0],
+                sv=stg.sv[0],
-            j_cross_section=stg.J_cross_section[data_id][0][
+                j_cross_section=stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][0][
-                stg.sand_sample_target_indice[0][0],
+                    stg.sand_sample_target_indice[0][0], stg.sand_sample_target_indice[0][1]],
-                stg.sand_sample_target_indice[0][1]
+                depth=stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][
-            ],
+                    self.combobox_freq1.currentIndex(), stg.sand_sample_target_indice[0][0]],
-            depth=depth_data[data_id][
+                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
-                freq_1, stg.sand_sample_target_indice[0][0]
+                    self.combobox_freq1.currentIndex()])
-            ],
-            alpha_w=stg.water_attenuation[data_id][freq_1]
-        )
 
-        alpha_s_freq2 = self.inv_hc.alpha_s(
+            alpha_s_freq2 = self.inv_hc.alpha_s(
-            sv=stg.sv[1],
+                sv=stg.sv[1],
-            j_cross_section=stg.J_cross_section[data_id][1][
+                j_cross_section=stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][1][
-                stg.sand_sample_target_indice[1][0],
+                    stg.sand_sample_target_indice[1][0], stg.sand_sample_target_indice[1][1]],
-                stg.sand_sample_target_indice[1][1]
+                depth=stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][
-            ],
+                    self.combobox_freq2.currentIndex(), stg.sand_sample_target_indice[1][0]],
-            depth=depth_data[data_id][
+                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
-                freq_2, stg.sand_sample_target_indice[1][0]
+                    self.combobox_freq2.currentIndex()])
-            ],
+
-            alpha_w=stg.water_attenuation[data_id][freq_2]
+        else:
-        )
+
+            alpha_s_freq1 = self.inv_hc.alpha_s(
+                sv=stg.sv[0],
+                j_cross_section=stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][0][
+                    stg.sand_sample_target_indice[0][0], stg.sand_sample_target_indice[0][1]],
+                depth=stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
+                    self.combobox_freq1.currentIndex(), stg.sand_sample_target_indice[0][0]],
+                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
+                    self.combobox_freq1.currentIndex()])
+
+            alpha_s_freq2 = self.inv_hc.alpha_s(
+                sv=stg.sv[1],
+                j_cross_section=stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][1][
+                    stg.sand_sample_target_indice[1][0], stg.sand_sample_target_indice[1][1]],
+                depth=stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
+                    self.combobox_freq2.currentIndex(), stg.sand_sample_target_indice[1][0]],
+                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
+                    self.combobox_freq2.currentIndex()])
 
         stg.alpha_s = [alpha_s_freq1, alpha_s_freq2]
 

View/signal_processing_tab.py

@@ -447,8 +447,8 @@ class SignalProcessingTab(QWidget):
         # --------------------------------------------------------------------------------------------------------------
 
         self.pushbutton_update.clicked.connect(self.update_SignalPreprocessingTab)
-        # self.pushbutton_update.clicked.connect(self.compute_average_profile_tail)
+        self.pushbutton_update.clicked.connect(self.compute_average_profile_tail)
-        # self.pushbutton_update.clicked.connect(self.plot_averaged_profile_tail)
+        self.pushbutton_update.clicked.connect(self.plot_averaged_profile_tail)
 
         self.combobox_acoustic_data_choice.currentIndexChanged.connect(self.combobox_acoustic_data_choice_change_index)
 
@@ -501,39 +501,26 @@ class SignalProcessingTab(QWidget):
                 - the user remove a file (in the list widget) in the first tab (Acoustic data), so that the combobox
                     of data to be processed is updated,
                 - the user change the limits of one or all the records in the first tab (Acoustic data) """
-        if len(stg.filename_BS_raw_data) == 0:
 
-            msgBox = QMessageBox()
+        self.combobox_acoustic_data_choice.clear()
-            msgBox.setWindowTitle("Compute noise from profile tail error")
+        self.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data)
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Download acoustic data in previous tab before updating data")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            msgBox.exec()
 
-        else:
+        if stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 0:
 
-            self.combobox_acoustic_data_choice.clear()
+            self.groupbox_download_noise_file.setChecked(True)
-            self.combobox_acoustic_data_choice.addItems(stg.filename_BS_raw_data)
+            self.groupbox_compute_noise_from_profile_tail.setChecked(False)
+            self.groupbox_download_noise_file_toggle()
 
-            if stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 0:
+        elif stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 1:
 
-                self.groupbox_download_noise_file.setChecked(True)
+            self.groupbox_download_noise_file.setChecked(False)
-                self.groupbox_compute_noise_from_profile_tail.setChecked(False)
+            self.groupbox_compute_noise_from_profile_tail.setChecked(True)
-                self.groupbox_download_noise_file_toggle()
+            self.groupbox_option_profile_tail_toggle()
 
-            elif stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 1:
+        self.combobox_freq_noise_from_profile_tail.clear()
+        self.combobox_freq_noise_from_profile_tail.addItems(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()])
 
-                self.groupbox_download_noise_file.setChecked(False)
+        self.combobox_acoustic_data_choice.currentIndexChanged.connect(self.combobox_acoustic_data_choice_change_index)
-                self.groupbox_compute_noise_from_profile_tail.setChecked(True)
-                self.groupbox_option_profile_tail_toggle()
-
-            self.combobox_freq_noise_from_profile_tail.clear()
-            self.combobox_freq_noise_from_profile_tail.addItems(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()])
-
-            self.combobox_acoustic_data_choice.currentIndexChanged.connect(self.combobox_acoustic_data_choice_change_index)
-
-            self.compute_average_profile_tail()
-            self.plot_averaged_profile_tail()
 
     def activate_list_of_pre_processed_data(self):
         for i in range(self.combobox_acoustic_data_choice.count()):
@@ -667,65 +654,45 @@ class SignalProcessingTab(QWidget):
 
         # --- Plot averaged signal ---
 
-        if len(stg.filename_BS_raw_data) == 0:
+        if stg.BS_mean[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
 
-            msgBox = QMessageBox()
+            self.verticalLayout_groupbox_plot_profile_tail.removeWidget(self.canvas_profile_tail)
-            msgBox.setWindowTitle("Compute noise from profile tail error")
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Download acoustic data in previous tab before computing noise from profile tail")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            msgBox.exec()
 
-        elif self.combobox_acoustic_data_choice.count() == 0:
+            self.fig_profile_tail, self.axis_profile_tail = plt.subplots(nrows=1, ncols=1, layout='constrained')
+            self.canvas_profile_tail = FigureCanvas(self.fig_profile_tail)
 
-            msgBox = QMessageBox()
+            self.verticalLayout_groupbox_plot_profile_tail.addWidget(self.canvas_profile_tail)
-            msgBox.setWindowTitle("Compute noise from profile tail error")
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Refresh acoustic data before computing noise from profile tail")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            msgBox.exec()
 
-        else:
+            self.axis_profile_tail.plot(
+                    -stg.depth[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq_noise_from_profile_tail.currentIndex()],
+                    stg.BS_mean[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq_noise_from_profile_tail.currentIndex()],
+                    color="blue", linewidth=1)
+            self.axis_profile_tail.plot(
+                    -stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
+                        self.combobox_freq_noise_from_profile_tail.currentIndex()],
+                    float(self.lineEdit_profile_tail_value.text().replace(",", ".")) *
+                        np.ones(stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
+                            self.combobox_freq_noise_from_profile_tail.currentIndex()].shape[0]),
+                    linestyle='dashed', linewidth=2, color='red')
 
-            if stg.BS_mean[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            self.axis_profile_tail.set_yscale('log')
+            self.axis_profile_tail.tick_params(axis='both', labelsize=8)
+            self.axis_profile_tail.text(.98, .03, "Depth (m)",
+                                        fontsize=8, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9,
+                                        horizontalalignment='right', verticalalignment='bottom', rotation='horizontal',
+                                        transform=self.axis_profile_tail.transAxes)
+            self.axis_profile_tail.text(.1, .45, "BS signal (v)",
+                                        fontsize=8, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9,
+                                        horizontalalignment='right', verticalalignment='bottom', rotation='vertical',
+                                        transform=self.axis_profile_tail.transAxes)
+            self.axis_profile_tail.text(.98, .85,
+                                        stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()][
+                                            self.combobox_freq_noise_from_profile_tail.currentIndex()],
+                                        fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
+                                        horizontalalignment='right', verticalalignment='bottom',
+                                        transform=self.axis_profile_tail.transAxes)
 
-                self.verticalLayout_groupbox_plot_profile_tail.removeWidget(self.canvas_profile_tail)
+            self.fig_profile_tail.canvas.draw_idle()
-
-                self.fig_profile_tail, self.axis_profile_tail = plt.subplots(nrows=1, ncols=1, layout='constrained')
-                self.canvas_profile_tail = FigureCanvas(self.fig_profile_tail)
-
-                self.verticalLayout_groupbox_plot_profile_tail.addWidget(self.canvas_profile_tail)
-
-                self.axis_profile_tail.plot(
-                        -stg.depth[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq_noise_from_profile_tail.currentIndex()],
-                        stg.BS_mean[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq_noise_from_profile_tail.currentIndex()],
-                        color="blue", linewidth=1)
-                self.axis_profile_tail.plot(
-                        -stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
-                            self.combobox_freq_noise_from_profile_tail.currentIndex()],
-                        float(self.lineEdit_profile_tail_value.text().replace(",", ".")) *
-                            np.ones(stg.depth[self.combobox_acoustic_data_choice.currentIndex()][
-                                self.combobox_freq_noise_from_profile_tail.currentIndex()].shape[0]),
-                        linestyle='dashed', linewidth=2, color='red')
-
-                self.axis_profile_tail.set_yscale('log')
-                self.axis_profile_tail.tick_params(axis='both', labelsize=8)
-                self.axis_profile_tail.text(.98, .03, "Depth (m)",
-                                            fontsize=8, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9,
-                                            horizontalalignment='right', verticalalignment='bottom', rotation='horizontal',
-                                            transform=self.axis_profile_tail.transAxes)
-                self.axis_profile_tail.text(.1, .45, "BS signal (v)",
-                                            fontsize=8, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.9,
-                                            horizontalalignment='right', verticalalignment='bottom', rotation='vertical',
-                                            transform=self.axis_profile_tail.transAxes)
-                self.axis_profile_tail.text(.98, .85,
-                                            stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()][
-                                                self.combobox_freq_noise_from_profile_tail.currentIndex()],
-                                            fontsize=10, fontweight='bold', fontname="Ubuntu", c="black", alpha=0.5,
-                                            horizontalalignment='right', verticalalignment='bottom',
-                                            transform=self.axis_profile_tail.transAxes)
-
-                self.fig_profile_tail.canvas.draw_idle()
 
     # ------------------------------------------------------
 
@@ -755,87 +722,82 @@ class SignalProcessingTab(QWidget):
 
     def clear_noise_data(self):
 
-        if len(stg.filename_BS_raw_data) == 0:
+        stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] = 0
+        stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()] = 0
 
-            pass
+        stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
 
-        else:
+        stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
 
-            stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.BS_noise_averaged_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.SNR_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.SNR_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.SNR_stream_bed[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.time_noise[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
-            stg.SNR_filter_value[self.combobox_acoustic_data_choice.currentIndex()] = 0
 
-            stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        if stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 0:
-            stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+            self.lineEdit_noise_file.clear()
 
-            stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+        elif stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 1:
-            stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+            self.lineEdit_val1.clear()
+            self.lineEdit_val1.setText("0.00")
 
-            stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+            self.lineEdit_val2.clear()
-            stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
+            self.lineEdit_val2.setText("0.00")
-            print("stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()]", stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()])
-            if stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 0:
-                self.lineEdit_noise_file.clear()
 
-            elif stg.noise_method[self.combobox_acoustic_data_choice.currentIndex()] == 1:
+            self.lineEdit_profile_tail_value.clear()
-                self.lineEdit_val1.clear()
+            self.lineEdit_profile_tail_value.setText("0.0000")
-                self.lineEdit_val1.setText("0.00")
 
-                self.lineEdit_val2.clear()
+            self.verticalLayout_groupbox_plot_profile_tail.removeWidget(self.canvas_profile_tail)
-                self.lineEdit_val2.setText("0.00")
+            self.canvas_profile_tail = FigureCanvas()
+            self.verticalLayout_groupbox_plot_profile_tail.addWidget(self.canvas_profile_tail)
 
-                self.lineEdit_profile_tail_value.clear()
+        self.lineEdit_SNR_criterion.setText("0.00")
-                self.lineEdit_profile_tail_value.setText("0.0000")
+        self.lineEdit_horizontal_average.setText("0.00")
 
-                self.verticalLayout_groupbox_plot_profile_tail.removeWidget(self.canvas_profile_tail)
+        # --- Clear SNR plot ---
-                self.canvas_profile_tail = FigureCanvas()
+        self.verticalLayout_groupbox_plot_SNR.removeWidget(self.toolbar_SNR)
-                self.verticalLayout_groupbox_plot_profile_tail.addWidget(self.canvas_profile_tail)
+        self.verticalLayout_groupbox_plot_SNR.removeWidget(self.scroll_SNR)
 
-            self.lineEdit_SNR_criterion.setText("0.00")
+        self.canvas_SNR = FigureCanvas()
-            self.lineEdit_horizontal_average.setText("0.00")
+        self.toolbar_SNR = NavigationToolBar(self.canvas_SNR, self)
+        self.scroll_SNR.setWidget(self.canvas_SNR)
 
-            # --- Clear SNR plot ---
+        self.verticalLayout_groupbox_plot_SNR.addWidget(self.toolbar_SNR)
-            self.verticalLayout_groupbox_plot_SNR.removeWidget(self.toolbar_SNR)
+        self.verticalLayout_groupbox_plot_SNR.addWidget(self.scroll_SNR)
-            self.verticalLayout_groupbox_plot_SNR.removeWidget(self.scroll_SNR)
 
-            self.canvas_SNR = FigureCanvas()
+        # --- Clear BS plot ---
-            self.toolbar_SNR = NavigationToolBar(self.canvas_SNR, self)
+        self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.removeWidget(self.toolbar_BS)
-            self.scroll_SNR.setWidget(self.canvas_SNR)
+        self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.removeWidget(self.scroll_BS)
 
-            self.verticalLayout_groupbox_plot_SNR.addWidget(self.toolbar_SNR)
+        self.canvas_BS = FigureCanvas()
-            self.verticalLayout_groupbox_plot_SNR.addWidget(self.scroll_SNR)
+        self.toolbar_BS = NavigationToolBar(self.canvas_BS, self)
+        self.scroll_BS.setWidget(self.canvas_BS)
 
-            # --- Clear BS plot ---
+        self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.addWidget(self.toolbar_BS)
-            self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.removeWidget(self.toolbar_BS)
+        self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.addWidget(self.scroll_BS)
-            self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.removeWidget(self.scroll_BS)
 
-            self.canvas_BS = FigureCanvas()
+        self.combobox_frequency_profile.clear()
-            self.toolbar_BS = NavigationToolBar(self.canvas_BS, self)
-            self.scroll_BS.setWidget(self.canvas_BS)
 
-            self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.addWidget(self.toolbar_BS)
+        self.verticalLayout_groupbox_plot_profile.removeWidget(self.toolbar_profile)
-            self.verticalLayout_groupbox_plot_pre_processed_data_2D_field.addWidget(self.scroll_BS)
+        self.verticalLayout_groupbox_plot_profile.removeWidget(self.canvas_profile)
 
-            self.combobox_frequency_profile.clear()
+        self.canvas_profile = FigureCanvas()
+        self.toolbar_profile = NavigationToolBar(self.canvas_profile, self)
 
-            self.verticalLayout_groupbox_plot_profile.removeWidget(self.toolbar_profile)
+        self.verticalLayout_groupbox_plot_profile.addWidget(self.toolbar_profile)
-            self.verticalLayout_groupbox_plot_profile.removeWidget(self.canvas_profile)
+        self.verticalLayout_groupbox_plot_profile.addWidget(self.canvas_profile)
 
-            self.canvas_profile = FigureCanvas()
+        self.slider.setValue(1)
-            self.toolbar_profile = NavigationToolBar(self.canvas_profile, self)
+        self.slider.setMaximum(10)
 
-            self.verticalLayout_groupbox_plot_profile.addWidget(self.toolbar_profile)
+        self.slider.setValue(0)
-            self.verticalLayout_groupbox_plot_profile.addWidget(self.canvas_profile)
+        self.slider.setMaximum(10)
-
-            self.slider.setValue(1)
-            self.slider.setMaximum(10)
-
-            self.slider.setValue(0)
-            self.slider.setMaximum(10)
 
     def open_dialog_box(self):
 
@@ -1259,19 +1221,11 @@ class SignalProcessingTab(QWidget):
 
     def remove_point_with_snr_filter(self):
 
-        if len(stg.filename_BS_raw_data) == 0:
+        if len(stg.BS_noise_raw_data) == 0:
-            msgBox = QMessageBox()
-            msgBox.setWindowTitle("Compute noise from profile tail error")
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Download acoustic data in previous tab before applying SNR filter")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            msgBox.exec()
-
-        elif len(stg.BS_noise_raw_data) == 0:
             msgBox = QMessageBox()
             msgBox.setWindowTitle("SNR filter Error")
             msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Define noise data (file or profile tail) before using SNR filter")
+            msgBox.setText("Load Noise data from acoustic data tab before using SNR filter")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
 
@@ -1550,123 +1504,105 @@ class SignalProcessingTab(QWidget):
 
     def compute_averaged_BS_data(self):
 
-        if len(stg.filename_BS_raw_data) == 0:
+        kernel_avg = np.ones(2 * int(float(self.lineEdit_horizontal_average.text().replace(",", "."))) + 1)
-            msgBox = QMessageBox()
+        print(kernel_avg)
-            msgBox.setWindowTitle("Compute noise from profile tail error")
-            msgBox.setIcon(QMessageBox.Warning)
-            msgBox.setText("Download acoustic data in previous tab before applying SNR filter")
-            msgBox.setStandardButtons(QMessageBox.Ok)
-            msgBox.exec()
 
-        elif len(stg.BS_noise_raw_data) == 0:
+        stg.Nb_cells_to_average_BS_signal[self.combobox_acoustic_data_choice.currentIndex()] = (
-            msgBox = QMessageBox()
+            float(self.lineEdit_horizontal_average.text().replace(",", ".")))
-            msgBox.setWindowTitle("SNR filter Error")
+
-            msgBox.setIcon(QMessageBox.Warning)
+        if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-            msgBox.setText("Define noise data (file or profile tail) before using SNR filter")
+
-            msgBox.setStandardButtons(QMessageBox.Ok)
+            if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-            msgBox.exec()
+
+                x_time = stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+                y_depth = stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+
+            elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+
+                x_time = stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+                y_depth = stg.depth[self.combobox_acoustic_data_choice.currentIndex()]
 
         else:
 
-            kernel_avg = np.ones(2 * int(float(self.lineEdit_horizontal_average.text().replace(",", "."))) + 1)
+            if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-            print(kernel_avg)
 
-            stg.Nb_cells_to_average_BS_signal[self.combobox_acoustic_data_choice.currentIndex()] = (
+                x_time = stg.time[self.combobox_acoustic_data_choice.currentIndex()]
-                float(self.lineEdit_horizontal_average.text().replace(",", ".")))
+                y_depth = stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
 
-            if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
 
-                if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+                x_time = stg.time[self.combobox_acoustic_data_choice.currentIndex()]
+                y_depth = stg.depth[self.combobox_acoustic_data_choice.currentIndex()]
 
-                    x_time = stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+        if stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-                    y_depth = stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
 
-                elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+                stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
 
-                    x_time = stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    y_depth = stg.depth[self.combobox_acoustic_data_choice.currentIndex()]
+                for i in range(y_depth.shape[1]):
 
-            else:
+                    stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+                        convolve(stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
+                                 kernel_avg))
 
-                if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+        elif stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
 
-                    x_time = stg.time[self.combobox_acoustic_data_choice.currentIndex()]
+            stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                    y_depth = stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()]
+                stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
 
-                elif stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
+                for i in range(y_depth.shape[1]):
 
-                    x_time = stg.time[self.combobox_acoustic_data_choice.currentIndex()]
+                    stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
-                    y_depth = stg.depth[self.combobox_acoustic_data_choice.currentIndex()]
+                        convolve(stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
+                                 kernel_avg))
 
-            if stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+        elif stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
 
-                stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+            stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                    stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
+                stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
 
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    for i in range(y_depth.shape[1]):
+                for i in range(y_depth.shape[1]):
 
-                        stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+                    stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
-                            convolve(stg.BS_stream_bed_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
+                        convolve(stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
-                                     kernel_avg))
+                                 kernel_avg))
 
-            elif stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+        elif stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
 
-                stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+            stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                    stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
+                stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()]))
 
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    for i in range(y_depth.shape[1]):
+                for i in range(y_depth.shape[1]):
+                    stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+                        convolve(stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()][f, i, :], kernel_avg))
 
-                        stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+        elif stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-                            convolve(stg.BS_cross_section_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
-                                     kernel_avg))
 
-            elif stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+                stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()]))
 
-                stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()]))
+                for i in range(y_depth.shape[1]):
+                    stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+                        convolve(stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
+                                 kernel_avg))
 
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
+        elif stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-                    for i in range(y_depth.shape[1]):
 
-                        stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+            stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                            convolve(stg.BS_raw_data_pre_process_SNR[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
+                stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()]))
-                                     kernel_avg))
 
-            elif stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
+                for i in range(y_depth.shape[1]):
+                    stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
+                        convolve(stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, i, :], kernel_avg))
 
-                stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
+        self.plot_pre_processed_BS_signal()
-                    stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()]))
+        self.update_plot_pre_processed_profile()
-
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    for i in range(y_depth.shape[1]):
-                        stg.BS_stream_bed_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
-                            convolve(stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()][f, i, :], kernel_avg))
-
-            elif stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-
-                stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                    stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()]))
-
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    for i in range(y_depth.shape[1]):
-                        stg.BS_cross_section_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
-                            convolve(stg.BS_cross_section[self.combobox_acoustic_data_choice.currentIndex()][f, i, :],
-                                     kernel_avg))
-
-            elif stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-
-                stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()] = (deepcopy(
-                    stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()]))
-
-                for f, _ in enumerate(stg.freq[self.combobox_acoustic_data_choice.currentIndex()]):
-                    for i in range(y_depth.shape[1]):
-                        stg.BS_raw_data_pre_process_average[self.combobox_acoustic_data_choice.currentIndex()][f, i, :] = (
-                            convolve(stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()][f, i, :], kernel_avg))
-
-            self.plot_pre_processed_BS_signal()
-            self.update_plot_pre_processed_profile()
 
     def plot_pre_processed_profile(self):