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(

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

@@ -268,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,189 +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()
+
         else:
+
             # --- Read calibration file ---
-            data = pd.read_csv(
+            data = pd.read_csv(stg.path_calibration_file + "/" + stg.filename_calibration_file, header=0, index_col=0)
-                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(
+            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()
@@ -2010,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],
@@ -2022,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
         )
 
@@ -2036,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"
         )
 
@@ -2052,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))
@@ -2075,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)
@@ -2124,89 +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]
 
@@ -2220,25 +2234,19 @@ 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(
+            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("Sediment sound attenuation is negative !")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
 
         else:
+
             msgBox = QMessageBox()
             msgBox.setWindowTitle("Alpha computation validation")
-            msgBox.setIconPixmap(
+            msgBox.setIconPixmap(QPixmap(self._path_icon("approved.png")).scaledToHeight(32, Qt.SmoothTransformation))
-                QPixmap(
-                    self._path_icon("approved.png")
-                ).scaledToHeight(32, Qt.SmoothTransformation)
-            )
             msgBox.setText("Sediment sound attenuation is positive.")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
@@ -2739,3 +2747,4 @@ 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]))
+