Merge branch 'dev-parouby' into dev

Model/create_table_for_save_as.py

@@ -389,10 +389,6 @@ 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()
 
@@ -446,7 +442,7 @@ class CreateTableForSaveAs:
 
         cur.execute(self.create_SedimentsFile)
 
-        if stg.path_fine != "" and path_sand != "":
+        if stg.path_fine != "" and stg.path_sand != "":
             cur.execute(
                 """
                 INSERT into SedimentsFile(

View/acoustic_inversion_tab.py

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

View/mainwindow.py

@@ -268,7 +268,10 @@ class Ui_MainWindow(object):
         )
 
     def save(self):
+        if stg.dirname_save_as:
             UpdateTableForSave()
+        else:
+            self.save_as()
 
     def open(self):
         reader = ReadTableForOpen()

View/sediment_calibration_tab.py

@@ -1716,14 +1716,18 @@ 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_BS_raw_data[
+                stg.path_calibration_file
-                                                    -1] if self.combobox_acoustic_data_choice.count() > 0 else ""][0],
+                if stg.path_calibration_file
+                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])
@@ -1736,114 +1740,189 @@ 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(str(self.combobox_freq1.currentText()))
+        self.label_freq1.setText(
+            str(self.combobox_freq1.currentText())
+        )
 
     def update_label_freq2_for_calibration(self):
         self.label_freq2.clear()
-        self.label_freq2.setText(self.combobox_freq2.currentText())
+        self.label_freq2.setText(
+            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()
-        print("self.combobox_freq1.currentIndex() ", self.combobox_freq1.currentIndex(), self.combobox_freq1.currentText())
+        if stg.kt_corrected[freq_1] != stg.kt_read[freq_1]:
-        if stg.kt_corrected[self.combobox_freq1.currentIndex()] != stg.kt_read[self.combobox_freq1.currentIndex()]:
+            self.label_kt_freq1.setText(
-            self.label_kt_freq1.setText(str('%.4f' % stg.kt_corrected[self.combobox_freq1.currentIndex()]))
+                str('%.4f' % stg.kt_corrected[freq_1])
+            )
         else:
-            self.label_kt_freq1.setText(str('%.4f' % stg.kt_read[self.combobox_freq1.currentIndex()]))
+            self.label_kt_freq1.setText(
+                str('%.4f' % stg.kt_read[freq_1])
+            )
 
         self.label_kt_freq2.clear()
-        if stg.kt_corrected[self.combobox_freq2.currentIndex()] != stg.kt_read[self.combobox_freq2.currentIndex()]:
+        if stg.kt_corrected[freq_2] != stg.kt_read[freq_2]:
-            self.label_kt_freq2.setText(str('%.4f' % stg.kt_corrected[self.combobox_freq2.currentIndex()]))
+            self.label_kt_freq2.setText(
+                str('%.4f' % stg.kt_corrected[freq_2])
+            )
         else:
-            self.label_kt_freq2.setText(str('%.4f' % stg.kt_read[self.combobox_freq2.currentIndex()]))
+            self.label_kt_freq2.setText(
+                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(self._path_icon("no_approved.png")).scaledToHeight(32, Qt.SmoothTransformation))
+                QPixmap(
+                    self._path_icon("no_approved.png")
+                ).scaledToHeight(32, Qt.SmoothTransformation)
+            )
             msgBox.setText("Update data before importing calibration")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
-
         else:
-
             # --- Read calibration file ---
-            data = pd.read_csv(stg.path_calibration_file + "/" + stg.filename_calibration_file, header=0, index_col=0)
+            data = pd.read_csv(
+                os.path.join(
+                    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("T = " + str(stg.temperature) + " °C")
+            self.label_temperature.setText(
+                "T = " + str(stg.temperature) + " °C"
+            )
 
             self.label_freq1.clear()
             self.label_freq1.setText(data.columns[0])
 
-            index_freq1 = np.where(np.asarray(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()]) ==
+            data_id = 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.freq[self.combobox_acoustic_data_choice.currentIndex()][
+            stg.frequencies_for_calibration.append(
-                                                        index_freq1],
+                (
-                                                    index_freq1))
+                    stg.freq[data_id][index_freq1],
+                    index_freq1
+                )
+            )
 
             self.label_freq2.clear()
             self.label_freq2.setText(data.columns[1])
 
-            index_freq2 = np.where(np.asarray(stg.freq_text[self.combobox_acoustic_data_choice.currentIndex()]) ==
+            index_freq2 = np.where(
-                                   data.columns[1])[0][0]
+                np.asarray(
-            stg.frequencies_for_calibration.append((stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
+                    stg.freq_text[data_id]
-                                                        index_freq2],
+                ) == data.columns[1]
-                                                    index_freq2))
+            )[0][0]
+
+            stg.frequencies_for_calibration.append(
+                (
+                    stg.freq[data_id][index_freq2],
+                    index_freq2
+                )
+            )
 
             stg.frequency_for_inversion = tuple()
-            stg.frequency_for_inversion = (stg.freq[self.combobox_acoustic_data_choice.currentIndex()][index_freq2],
+            stg.frequency_for_inversion = (
-                                           index_freq2)
+                stg.freq[data_id][index_freq2],
+                index_freq2
+            )
 
             self.lineEdit_ks_freq1.clear()
-            self.lineEdit_ks_freq1.setText(str("%.5f" % float(data.iloc[0][0])))
+            self.lineEdit_ks_freq1.setText(
+                str("%.5f" % float(data.iloc[0][0]))
+            )
 
             self.lineEdit_ks_freq2.clear()
-            self.lineEdit_ks_freq2.setText(str("%.5f" % float(data.iloc[0][1])))
+            self.lineEdit_ks_freq2.setText(
+                str("%.5f" % float(data.iloc[0][1]))
+            )
 
             stg.ks.clear()
-            stg.ks = [float(self.lineEdit_ks_freq1.text()), float(self.lineEdit_ks_freq2.text())]
+            stg.ks = [
+                float(self.lineEdit_ks_freq1.text()),
+                float(self.lineEdit_ks_freq2.text())
+            ]
 
             self.lineEdit_sv_freq1.clear()
-            self.lineEdit_sv_freq1.setText(str("%.5f" % float(data.iloc[1][0])))
+            self.lineEdit_sv_freq1.setText(
+                str("%.5f" % float(data.iloc[1][0]))
+            )
 
             self.lineEdit_sv_freq2.clear()
-            self.lineEdit_sv_freq2.setText(str("%.5f" % float(data.iloc[1][1])))
+            self.lineEdit_sv_freq2.setText(
+                str("%.5f" % float(data.iloc[1][1]))
+            )
 
             stg.sv.clear()
-            stg.sv = [float(self.lineEdit_sv_freq1.text()), float(self.lineEdit_sv_freq2.text())]
+            stg.sv = [
+                float(self.lineEdit_sv_freq1.text()),
+                float(self.lineEdit_sv_freq2.text())
+            ]
 
             self.lineEdit_X.clear()
-            self.lineEdit_X.setText(str("%.2f" % float(data.iloc[2][0])))
+            self.lineEdit_X.setText(
+                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(str("%.5f" % float(data.iloc[3][0])))
+            self.lineEdit_alphas_freq1.setText(
+                str("%.5f" % float(data.iloc[3][0]))
+            )
 
             self.lineEdit_alphas_freq2.clear()
-            self.lineEdit_alphas_freq2.setText(str("%.5f" % float(data.iloc[3][1])))
+            self.lineEdit_alphas_freq2.setText(
+                str("%.5f" % float(data.iloc[3][1]))
+            )
 
             stg.alpha_s.clear()
-            stg.alpha_s = [float(self.lineEdit_alphas_freq1.text()), float(self.lineEdit_alphas_freq2.text())]
+            stg.alpha_s = [
+                float(self.lineEdit_alphas_freq1.text()),
+                float(self.lineEdit_alphas_freq2.text())
+            ]
 
             self.lineEdit_zeta_freq1.clear()
-            self.lineEdit_zeta_freq1.setText(str("%.5f" % float(data.iloc[4][0])))
+            self.lineEdit_zeta_freq1.setText(
+                str("%.5f" % float(data.iloc[4][0]))
+            )
 
             self.lineEdit_zeta_freq2.clear()
-            self.lineEdit_zeta_freq2.setText(str("%.5f" % float(data.iloc[4][1])))
+            self.lineEdit_zeta_freq2.setText(
+                str("%.5f" % float(data.iloc[4][1]))
+            )
 
             stg.zeta.clear()
-            stg.zeta = [float(self.lineEdit_zeta_freq1.text()), float(self.lineEdit_zeta_freq2.text())]
+            stg.zeta = [
+                float(self.lineEdit_zeta_freq1.text()),
+                float(self.lineEdit_zeta_freq2.text())
+            ]
 
             self.compute_kt2D_kt3D()
             self.compute_J_cross_section()
@@ -1931,8 +2010,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],
@@ -1943,17 +2022,13 @@ class SedimentCalibrationTab(QWidget):
 
         ks_freq1 = self.inv_hc.ks(
             proba_num=psd_number_of_particles,
-            freq=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
+            freq=stg.freq[data_id][self.combobox_freq1.currentIndex()],
-                self.combobox_freq1.currentIndex()
-            ],
             C=stg.water_velocity
         )
 
         ks_freq2 = self.inv_hc.ks(
             proba_num=psd_number_of_particles,
-            freq=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][
+            freq=stg.freq[data_id][self.combobox_freq2.currentIndex()],
-                self.combobox_freq2.currentIndex()
-            ],
             C=stg.water_velocity
         )
 
@@ -1961,12 +2036,12 @@ class SedimentCalibrationTab(QWidget):
 
         logger.debug(
             "ks for frequency of "
-            + f"{stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()]} : "
+            + f"{stg.freq[data_id][self.combobox_freq1.currentIndex()]} : "
             + f"{ks_freq1} m/kg^0.5 \n"
         )
         logger.debug(
             "ks for frequency of "
-            + f"{stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()]} : " +
+            + f"{stg.freq[data_id][self.combobox_freq2.currentIndex()]} : " +
             f"{ks_freq2} m/kg^0.5"
         )
 
@@ -1977,13 +2052,21 @@ 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(f"sv for frequency of {stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()]} : {sv_freq1:.8f} /m \n")
+        print(
-        print(f"sv for frequency of {stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()]} : {sv_freq2:.8f} /m")
+            f"sv for frequency of {stg.freq[data_id][self.combobox_freq1.currentIndex()]}"
+            + 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))
@@ -1992,9 +2075,13 @@ class SedimentCalibrationTab(QWidget):
         self.lineEdit_sv_freq2.setText(str("%.5f" % sv_freq2))
 
     def compute_X(self):
-        X_exponent = self.inv_hc.X_exponent(freq1=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq1.currentIndex()],
+        data_id = self.combobox_acoustic_data_choice.currentIndex()
-                                            freq2=stg.freq[self.combobox_acoustic_data_choice.currentIndex()][self.combobox_freq2.currentIndex()],
+
-                                            sv_freq1=stg.sv[0], sv_freq2=stg.sv[1])
+        X_exponent = self.inv_hc.X_exponent(
+            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)
@@ -2037,190 +2124,89 @@ class SedimentCalibrationTab(QWidget):
             )
 
     def compute_J_cross_section(self):
-        for i in range(self.combobox_acoustic_data_choice.count()):
+        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([])
 
-            # --- Compute J ---
+            for data in lst_bs_data:
-            if stg.BS_stream_bed_pre_process_average[i].shape != (0,):
+                if data[i].shape != (0,):
+                    bs_data = data
+                    break
+
+            print(f"{stg.depth_2D[i].shape}")
+            print(f"{stg.depth_2D[i]}")
 
             J_cross_section_freq1 = self.inv_hc.j_cross_section(
-                    BS=stg.BS_stream_bed_pre_process_average[i][
+                BS = bs_data[i][
-                       stg.frequencies_for_calibration[0][1], :, :],
+                    stg.frequencies_for_calibration[0][1], :, :
-                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[0][1],
+                ],
-                        :, :],
+                r2D = stg.depth_2D[i][
-                    kt=stg.kt3D[i][stg.frequencies_for_calibration[0][1], :, :])
+                        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_pre_process_average[i][
+                BS = bs_data[i][
-                       stg.frequencies_for_calibration[1][1], :, :],
+                    stg.frequencies_for_calibration[1][1], :, :
-                    r2D=stg.depth_2D[i][stg.frequencies_for_calibration[1][1],
+                ],
-                        :, :],
+                r2D = stg.depth_2D[i][
-                    kt=stg.kt3D[i][stg.frequencies_for_calibration[1][1], :, :])
+                    stg.frequencies_for_calibration[1][1], :, :
-
+                ],
-            elif stg.BS_stream_bed_pre_process_SNR[i].shape != (0,):
+                kt = stg.kt3D[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][
+            )
-                       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_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()
 
-        # --- Compute alpha_s ---
+        depth_data = stg.depth
-        if stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+        if stg.depth_cross_section[data_id].shape != (0,):
+            depth_data = stg.depth_cross_section
 
         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][
+            j_cross_section=stg.J_cross_section[data_id][0][
-                    stg.sand_sample_target_indice[0][0], stg.sand_sample_target_indice[0][1]],
+                stg.sand_sample_target_indice[0][0],
-                depth=stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][
+                stg.sand_sample_target_indice[0][1]
-                    self.combobox_freq1.currentIndex(), stg.sand_sample_target_indice[0][0]],
+            ],
-                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
+            depth=depth_data[data_id][
-                    self.combobox_freq1.currentIndex()])
+                freq_1, stg.sand_sample_target_indice[0][0]
+            ],
+            alpha_w=stg.water_attenuation[data_id][freq_1]
+        )
 
         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][
+            j_cross_section=stg.J_cross_section[data_id][1][
-                    stg.sand_sample_target_indice[1][0], stg.sand_sample_target_indice[1][1]],
+                stg.sand_sample_target_indice[1][0],
-                depth=stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][
+                stg.sand_sample_target_indice[1][1]
-                    self.combobox_freq2.currentIndex(), stg.sand_sample_target_indice[1][0]],
+            ],
-                alpha_w=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][
+            depth=depth_data[data_id][
-                    self.combobox_freq2.currentIndex()])
+                freq_2, stg.sand_sample_target_indice[1][0]
-
+            ],
-        else:
+            alpha_w=stg.water_attenuation[data_id][freq_2]
-
+        )
-            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]
 
@@ -2234,19 +2220,25 @@ class SedimentCalibrationTab(QWidget):
         self.lineEdit_alphas_freq2.setText(str("%.5f" % alpha_s_freq2))
 
         if (alpha_s_freq1 < 0) or (alpha_s_freq2 < 0):
-
             msgBox = QMessageBox()
             msgBox.setWindowTitle("Alpha computation error")
-            msgBox.setIconPixmap(QPixmap(self._path_icon("no_approved.png")).scaledToHeight(32, Qt.SmoothTransformation))
+            msgBox.setIconPixmap(
+                QPixmap(
+                    self._path_icon("no_approved.png")
+                ).scaledToHeight(32, Qt.SmoothTransformation)
+            )
             msgBox.setText("Sediment sound attenuation is negative !")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
 
         else:
-
             msgBox = QMessageBox()
             msgBox.setWindowTitle("Alpha computation validation")
-            msgBox.setIconPixmap(QPixmap(self._path_icon("approved.png")).scaledToHeight(32, Qt.SmoothTransformation))
+            msgBox.setIconPixmap(
+                QPixmap(
+                    self._path_icon("approved.png")
+                ).scaledToHeight(32, Qt.SmoothTransformation)
+            )
             msgBox.setText("Sediment sound attenuation is positive.")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
@@ -2747,4 +2739,3 @@ class SedimentCalibrationTab(QWidget):
             self.lineEdit_slider_FCB.setText(
                 str(stg.time[self.combobox_acoustic_data_choice.currentIndex()][
                         self.combobox_frequency_FCB.currentIndex(), self.slider_FCB.value()-1]))
-