compute interpolation can be done without detect bottom

Model/create_table_for_save_as.py

@@ -37,133 +37,151 @@ logger = logging.getLogger()
 class CreateTableForSaveAs:
 
     def __init__(self):
+        self.create_AcousticFile = """
+        CREATE TABLE AcousticFile(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          acoustic_data INTEGER,
+          acoustic_file STRING,
+          ABS_name STRING,
+          path_BS_noise_data STRING,
+          filename_BS_noise_data STRING,
+          noise_method FLOAT,
+          noise_value FLOAT,
+          data_preprocessed STRING
+        )
+        """
 
-        self.create_AcousticFile = """CREATE TABLE AcousticFile(
-                                                ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                                acoustic_data INTEGER,
-                                                acoustic_file STRING,
-                                                ABS_name STRING,
-                                                path_BS_noise_data STRING,
-                                                filename_BS_noise_data STRING,
-                                                noise_method FLOAT,
-                                                noise_value FLOAT,
-                                                data_preprocessed STRING
-                                                )
-                                                """
+        self.create_Measure = """
+        CREATE TABLE Measure(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          acoustic_data INTEGER,
+          Date DATE,
+          Hour TIME,
+          frequency FLOAT,
+          sound_attenuation FLOAT,
+          kt_read FLOAT,
+          kt_corrected FLOAT,
+          NbProfiles FLOAT,
+          NbProfilesPerSeconds FLOAT,
+          NbCells FLOAT,
+          CellSize FLOAT,
+          PulseLength FLOAT,
+          NbPingsPerSeconds FLOAT,
+          NbPingsAveragedPerProfile FLOAT,
+          GainRx FLOAT,
+          GainTx FLOAT
+        )
+        """
 
-        self.create_Measure = """ CREATE TABLE Measure(
-                                    ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                    acoustic_data INTEGER,
-                                    Date DATE,
-                                    Hour TIME,
-                                    frequency FLOAT,
-                                    sound_attenuation FLOAT,
-                                    kt_read FLOAT,
-                                    kt_corrected FLOAT,
-                                    NbProfiles FLOAT,
-                                    NbProfilesPerSeconds FLOAT,
-                                    NbCells FLOAT,
-                                    CellSize FLOAT,
-                                    PulseLength FLOAT,
-                                    NbPingsPerSeconds FLOAT,
-                                    NbPingsAveragedPerProfile FLOAT,
-                                    GainRx FLOAT,
-                                    GainTx FLOAT
-                                    )
-                                    """
+        self.create_BSRawData = """
+        CREATE TABLE BSRawData(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          acoustic_data INTEGER,
+          time BLOB, depth BLOB, BS_raw_data BLOB,
+          time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape BLOB,
+          time_cross_section BLOB, depth_cross_section BLOB,
+          BS_cross_section BLOB, BS_stream_bed BLO  B,
+          depth_bottom, val_bottom, ind_bottom,
+          time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB,
+          SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB,
+          BS_raw_data_pre_process_SNR BLOB,
+          BS_raw_data_pre_process_average BLOB,
+          BS_cross_section_pre_process_SNR BLOB,
+          BS_cross_section_pre_process_average BLOB,
+          BS_stream_bed_pre_process_SNR BLOB,
+          BS_stream_bed_pre_process_average BLOB,
+          BS_mean BLOB
+        )
+        """
 
-        self.create_BSRawData = '''CREATE TABLE BSRawData(
-                                    ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                    acoustic_data INTEGER,
-                                    time BLOB, depth BLOB, BS_raw_data BLOB,
-                                    time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape BLOB,
-                                    time_cross_section BLOB, depth_cross_section BLOB, BS_cross_section BLOB, BS_stream_bed BLOB,
-                                    depth_bottom, val_bottom, ind_bottom,
-                                    time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB,
-                                    SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB,
-                                    BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB,
-                                    BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB,
-                                    BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB,
-                                    BS_mean BLOB
-                                    )'''
+        self.create_Settings = """
+        CREATE TABLE Settings(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          acoustic_data INTEGER,
+          temperature FLOAT,
+          tmin_index FLOAT, tmin_value FLOAT,
+          tmax_index FLOAT, tmax_value FLOAT,
+          rmin_index FLOAT, rmin_value FLOAT,
+          rmax_index FLOAT, rmax_value FLOAT,
+          freq_bottom_detection_index FLOAT,
+          freq_bottom_detection_value STRING,
+          SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT
+        )
+        """
 
-        self.create_Settings = '''CREATE TABLE Settings(
-                                    ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                    acoustic_data INTEGER,
-                                    temperature FLOAT,
-                                    tmin_index FLOAT, tmin_value FLOAT, tmax_index FLOAT, tmax_value FLOAT,
-                                    rmin_index FLOAT, rmin_value FLOAT, rmax_index FLOAT, rmax_value FLOAT,
-                                    freq_bottom_detection_index FLOAT, freq_bottom_detection_value STRING,
-                                    SNR_filter_value FLOAT, Nb_cells_to_average_BS_signal FLOAT
-                                    )'''
+        self.create_SedimentsFile = """
+        CREATE TABLE SedimentsFile(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          path_fine STRING,
+          filename_fine STRING,
+          radius_grain_fine BLOB,
+          path_sand STRING,
+          filename_sand STRING,
+          radius_grain_sand BLOB,
+          time_column_label STRING,
+          distance_from_bank_column_label STRING,
+          depth_column_label STRING,
+          Ctot_fine_column_label STRING,
+          D50_fine_column_label STRING,
+          Ctot_sand_column_label STRING,
+          D50_sand_column_label STRING
+        )
+        """
 
-        self.create_SedimentsFile = """CREATE TABLE SedimentsFile(
-                                                       ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                                       path_fine STRING,
-                                                       filename_fine STRING,
-                                                       radius_grain_fine BLOB,
-                                                       path_sand STRING,
-                                                       filename_sand STRING,
-                                                       radius_grain_sand BLOB,
-                                                       time_column_label STRING,
-                                                       distance_from_bank_column_label STRING,
-                                                       depth_column_label STRING,
-                                                       Ctot_fine_column_label STRING,
-                                                       D50_fine_column_label STRING,
-                                                       Ctot_sand_column_label STRING,
-                                                       D50_sand_column_label STRING
-                                                       )
-                                                       """
+        self.create_SedimentsData = """
+        CREATE TABLE SedimentsData(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          sample_fine_name STRING,
+          sample_fine_index INTEGER,
+          distance_from_bank_fine FLOAT,
+          depth_fine FLOAT,
+          time_fine FLOAT,
+          Ctot_fine FLOAT,
+          Ctot_fine_per_cent FLOAT,
+          D50_fine FLOAT,
+          frac_vol_fine BLOB,
+          frac_vol_fine_cumul BLOB,
+          sample_sand_name STRING,
+          sample_sand_index INTEGER,
+          distance_from_bank_sand FLOAT,
+          depth_sand FLOAT,
+          time_sand FLOAT,
+          Ctot_sand FLOAT,
+          Ctot_sand_per_cent FLOAT,
+          D50_sand FLOAT,
+          frac_vol_sand BLOB,
+          frac_vol_sand_cumul BLOB
+        )
+        """
 
-        self.create_SedimentsData = """CREATE TABLE SedimentsData(
-                                                ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                                sample_fine_name STRING,
-                                                sample_fine_index INTEGER,
-                                                distance_from_bank_fine FLOAT,
-                                                depth_fine FLOAT,
-                                                time_fine FLOAT,
-                                                Ctot_fine FLOAT,
-                                                Ctot_fine_per_cent FLOAT,
-                                                D50_fine FLOAT,
-                                                frac_vol_fine BLOB,
-                                                frac_vol_fine_cumul BLOB,
-                                                sample_sand_name STRING,
-                                                sample_sand_index INTEGER,
-                                                distance_from_bank_sand FLOAT,
-                                                depth_sand FLOAT,
-                                                time_sand FLOAT,
-                                                Ctot_sand FLOAT,
-                                                Ctot_sand_per_cent FLOAT,
-                                                D50_sand FLOAT,
-                                                frac_vol_sand BLOB,
-                                                frac_vol_sand_cumul BLOB
-                                                )
-                                                """
+        self.create_Calibration = """
+        CREATE TABLE Calibration(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          path_calibration_file STRING,
+          filename_calibration_file STRING,
+          range_lin_interp BLOB,
+          M_profile_fine BLOB,
+          ks BLOB,
+          sv BLOB,
+          X_exponent BLOB,
+          alpha_s BLOB,
+          zeta BLOB,
+          FCB BLOB,
+          depth_real BLOB,
+          lin_reg BLOB
+        )
+        """
 
-        self.create_Calibration = """CREATE TABLE Calibration(
-                                                        ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                                        path_calibration_file STRING,
-                                                        filename_calibration_file STRING,
-                                                        range_lin_interp BLOB,
-                                                        M_profile_fine BLOB,
-                                                        ks BLOB,
-                                                        sv BLOB,
-                                                        X_exponent BLOB,
-                                                        alpha_s BLOB,
-                                                        zeta BLOB,
-                                                        FCB BLOB,
-                                                        depth_real BLOB,
-                                                        lin_reg BLOB
-                                                        )"""
-
-        self.create_Inversion = """CREATE TABLE Inversion(
-                                                          ID INTEGER PRIMARY KEY AUTOINCREMENT,
-                                                          J_cross_section_freq1 BLOB,
-                                                          J_cross_section_freq2 BLOB,
-                                                          VBI_cross_section BLOB,
-                                                          SSC_fine BLOB,
-                                                          SSC_sand BLOB
-                                                          )"""
+        self.create_Inversion = """
+        CREATE TABLE Inversion(
+          ID INTEGER PRIMARY KEY AUTOINCREMENT,
+          J_cross_section_freq1 BLOB,
+          J_cross_section_freq2 BLOB,
+          VBI_cross_section BLOB,
+          SSC_fine BLOB,
+          SSC_sand BLOB
+        )
+        """
 
         self.open_file_dialog()
 
@@ -203,18 +221,24 @@ class CreateTableForSaveAs:
             msgBox.exec()
 
     def create_table(self):
-
-        # Create a new database and open a database connection to allow sqlite3 to work with it.
         cnx = sqlite3.connect(stg.filename_save_as)
-
-        # Create database cursor to execute SQL statements and fetch results from SQL queries.
         cur = cnx.cursor()
 
-        # --------------------------------------------------------------------------------------------------------------
-                                                # +++++++++++++++++++++++++++
-                                                # --- Table Acoustic File ---
-                                                # +++++++++++++++++++++++++++
+        self.create_table_acoustic_file(cnx, cur)
+        self.create_table_measure(cnx, cur)
+        self.create_table_BSRawData(cnx, cur)
+        self.create_table_settings(cnx, cur)
+        self.create_table_sediments_file(cnx, cur)
+        self.create_table_sediments_data(cnx, cur)
+        self.create_table_calibration(cnx, cur)
+        self.create_table_inversion(cnx, cur)
 
+        cnx.commit()
+
+        cur.close()
+        cnx.close()
+
+    def create_table_acoustic_file(self, cnx, cur):
         start_table_File = time.time()
 
         cur.execute("DROP TABLE if exists AcousticFile")
@@ -222,28 +246,42 @@ class CreateTableForSaveAs:
         cur.execute(self.create_AcousticFile)
 
         for i in stg.acoustic_data:
-            print("stg.acoustic_data ", stg.acoustic_data[i])
-            print("stg.filename_BS_raw_data ", stg.filename_BS_raw_data[i])
-            print('stg.ABS_name', stg.ABS_name)
-            print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i])
+            logger.debug(f"stg.acoustic_data: {stg.acoustic_data[i]}")
+            logger.debug("stg.filename_BS_raw_data: "
+                         + f"{stg.filename_BS_raw_data[i]}")
+            logger.debug(f"stg.ABS_name: {stg.ABS_name}")
+            logger.debug(f"stg.path_BS_raw_data: {stg.path_BS_raw_data[i]}")
 
-            cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data,
-                                                 filename_BS_noise_data, noise_method, noise_value, data_preprocessed)
-                                    VALUES(?, ?, ?, ?, ?, ?, ?, ?)''',
-                        (stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i],
-                        stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i],
-                        stg.noise_value[i], stg.data_preprocessed[i])
-                        )
+            cur.execute(
+                """
+                INSERT into AcousticFile(
+                  acoustic_data,
+                  acoustic_file,
+                  ABS_name,
+                  path_BS_noise_data,
+                  filename_BS_noise_data,
+                  noise_method,
+                  noise_value,
+                  data_preprocessed)
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.acoustic_data[i],
+                    stg.filename_BS_raw_data[i].split('.')[0],
+                    stg.ABS_name[i],
+                    stg.path_BS_noise_data[i],
+                    stg.filename_BS_noise_data[i],
+                    stg.noise_method[i],
+                    stg.noise_value[i],
+                    stg.data_preprocessed[i]
+                )
+            )
 
         cnx.commit()
 
-        print(f"table File : {time.time() - start_table_File} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # +++++++++++++++++++++
-                                                # --- Table Measure ---
-                                                # +++++++++++++++++++++
+        logger.info(f"table File : {time.time() - start_table_File} sec")
 
+    def create_table_measure(self, cnx, cur):
         start_table_Measure = time.time()
 
         # Drop Table if exists
@@ -251,35 +289,52 @@ class CreateTableForSaveAs:
 
         # Execute the CREATE TABLE statement
         cur.execute(self.create_Measure)
-        print("stg.date ", stg.date, "stg.hour ", stg.hour)
-        # Fill the table Measure
+
+        logger.debug(f"stg.date: {stg.date}, stg.hour: {stg.hour}")
+
         for i in stg.acoustic_data:
-
             for j in range(stg.freq[i].shape[0]):
-
-                cur.execute(''' INSERT into Measure(acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected,
-                                                        NbProfiles, NbProfilesPerSeconds, NbCells, CellSize, PulseLength,
-                                                        NbPingsPerSeconds, NbPingsAveragedPerProfile, GainRx, GainTx
-                                                        )
-                                    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                            (stg.acoustic_data[i], #stg.date[i], stg.hour[i],
-                             str(stg.date[i].year) + str('-') + str(stg.date[i].month) + str('-') + str(stg.date[i].day),
-                             str(stg.hour[i].hour) + str(':') + str(stg.hour[i].minute),
-                             stg.freq[i][j], stg.water_attenuation[i][j], stg.kt_read[j], stg.kt_corrected[j],
-                             stg.nb_profiles[i][j], stg.nb_profiles_per_sec[i][j], stg.nb_cells[i][j],
-                             stg.cell_size[i][j], stg.pulse_length[i][j], stg.nb_pings_per_sec[i][j],
-                             stg.nb_pings_averaged_per_profile[i][j], stg.gain_rx[i][j], stg.gain_tx[i][j]))
+                cur.execute(
+                    """
+                    INSERT into Measure(
+                      acoustic_data,
+                      Date, Hour,
+                      frequency,
+                      sound_attenuation,
+                      kt_read, kt_corrected,
+                      NbProfiles, NbProfilesPerSeconds,
+                      NbCells, CellSize,
+                      PulseLength,
+                      NbPingsPerSeconds,
+                      NbPingsAveragedPerProfile,
+                      GainRx, GainTx
+                    )
+                    VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        stg.acoustic_data[i], #stg.date[i], stg.hour[i],
+                        str(stg.date[i].year) + str('-')
+                        + str(stg.date[i].month) + str('-')
+                        + str(stg.date[i].day),
+                        str(stg.hour[i].hour) + str(':') + str(stg.hour[i].minute),
+                        stg.freq[i][j],
+                        stg.water_attenuation[i][j],
+                        stg.kt_read[j], stg.kt_corrected[j],
+                        stg.nb_profiles[i][j], stg.nb_profiles_per_sec[i][j],
+                        stg.nb_cells[i][j], stg.cell_size[i][j],
+                        stg.pulse_length[i][j],
+                        stg.nb_pings_per_sec[i][j],
+                        stg.nb_pings_averaged_per_profile[i][j],
+                        stg.gain_rx[i][j], stg.gain_tx[i][j]
+                    )
+                )
 
         # Commit the transaction after executing INSERT.
         cnx.commit()
 
-        print(f"table Measure : {time.time() - start_table_Measure} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # +++++++++++++++++++++++++
-                                                # --- Table BSRawData_i ---
-                                                # +++++++++++++++++++++++++
+        logger.info(f"table Measure : {time.time() - start_table_Measure} sec")
 
+    def create_table_BSRawData(self, cnx, cur):
         start_table_BSRawData = time.time()
 
         cur.execute('DROP TABLE if exists BSRawData')
@@ -288,105 +343,140 @@ class CreateTableForSaveAs:
         cur.execute(self.create_BSRawData)
 
         for i in stg.acoustic_data:
+            cur.execute(
+                """
+                INSERT into BSRawData(
+                  acoustic_data,
+                  time, depth,
+                  BS_raw_data,
+                  time_reshape,
+                  depth_reshape,
+                  BS_raw_data_reshape,
+                  time_cross_section, depth_cross_section,
+                  BS_cross_section, BS_stream_bed,
+                  depth_bottom, val_bottom, ind_bottom,
+                  time_noise, depth_noise, BS_noise_raw_data,
+                  SNR_raw_data, SNR_cross_section, SNR_stream_bed,
+                  BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average,
+                  BS_cross_section_pre_process_SNR, BS_cross_section_pre_process_average,
+                  BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average,
+                  BS_mean
+                )
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+                       ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.acoustic_data[i], stg.time[i].tobytes(),
+                    stg.depth[i].tobytes(), stg.BS_raw_data[i].tobytes(),
+                    stg.time_reshape[i].tobytes(), stg.depth_reshape[i].tobytes(),
+                    stg.BS_raw_data_reshape[i].tobytes(),
+                    stg.time_cross_section[i].tobytes(),
+                    stg.depth_cross_section[i].tobytes(),
+                    stg.BS_cross_section[i].tobytes(), stg.BS_stream_bed[i].tobytes(),
+                    stg.depth_bottom[i].tobytes(), np.array(stg.val_bottom[i]).tobytes(),
+                    np.array(stg.ind_bottom[i]).tobytes(),
+                    stg.time_noise[i].tobytes(), stg.depth_noise[i].tobytes(),
+                    stg.BS_noise_raw_data[i].tobytes(),
+                    stg.SNR_raw_data[i].tobytes(), stg.SNR_cross_section[i].tobytes(),
+                    stg.SNR_stream_bed[i].tobytes(),
+                    stg.BS_raw_data_pre_process_SNR[i].tobytes(),
+                    stg.BS_raw_data_pre_process_average[i].tobytes(),
+                    stg.BS_cross_section_pre_process_SNR[i].tobytes(),
+                    stg.BS_cross_section_pre_process_average[i].tobytes(),
+                    stg.BS_stream_bed_pre_process_SNR[i].tobytes(),
+                    stg.BS_stream_bed_pre_process_average[i].tobytes(),
+                    stg.BS_mean[i].tobytes()
+                )
+            )
 
-            cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data,
-                                                      time_reshape, depth_reshape, BS_raw_data_reshape,
-                                                      time_cross_section, depth_cross_section,
-                                                      BS_cross_section, BS_stream_bed,
-                                                      depth_bottom, val_bottom, ind_bottom,
-                                                      time_noise, depth_noise, BS_noise_raw_data,
-                                                      SNR_raw_data, SNR_cross_section, SNR_stream_bed,
-                                                      BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average,
-                                                      BS_cross_section_pre_process_SNR, BS_cross_section_pre_process_average,
-                                                      BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average,
-                                                      BS_mean)
-                                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                        (stg.acoustic_data[i], stg.time[i].tobytes(),
-                         stg.depth[i].tobytes(), stg.BS_raw_data[i].tobytes(),
-                         stg.time_reshape[i].tobytes(), stg.depth_reshape[i].tobytes(), stg.BS_raw_data_reshape[i].tobytes(),
-                         stg.time_cross_section[i].tobytes(), stg.depth_cross_section[i].tobytes(),
-                         stg.BS_cross_section[i].tobytes(), stg.BS_stream_bed[i].tobytes(),
-                         stg.depth_bottom[i].tobytes(), np.array(stg.val_bottom[i]).tobytes(), np.array(stg.ind_bottom[i]).tobytes(),
-                         stg.time_noise[i].tobytes(), stg.depth_noise[i].tobytes(), stg.BS_noise_raw_data[i].tobytes(),
-                         stg.SNR_raw_data[i].tobytes(), stg.SNR_cross_section[i].tobytes(), stg.SNR_stream_bed[i].tobytes(),
-                         stg.BS_raw_data_pre_process_SNR[i].tobytes(), stg.BS_raw_data_pre_process_average[i].tobytes(),
-                         stg.BS_cross_section_pre_process_SNR[i].tobytes(), stg.BS_cross_section_pre_process_average[i].tobytes(),
-                         stg.BS_stream_bed_pre_process_SNR[i].tobytes(), stg.BS_stream_bed_pre_process_average[i].tobytes(),
-                         stg.BS_mean[i].tobytes()
-                         )
-                        )
+            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)
 
-        print("stg.ind_bottom ", stg.ind_bottom[i])
-        print(np.array([stg.ind_bottom[i]]), np.array(stg.ind_bottom[i]).shape)
-            # Commit the transaction after executing INSERT.
+        # Commit the transaction after executing INSERT.
         cnx.commit()
 
-        print(f"table BSRawData : {time.time() - start_table_BSRawData} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # ++++++++++++++++++++++
-                                                # --- Table Settings ---
-                                                # ++++++++++++++++++++++
+        logger.info(f"table BSRawData : {time.time() - start_table_BSRawData} sec")
 
+    def create_table_settings(self, cnx, cur):
         start_table_Settings = time.time()
 
         cur.execute("DROP TABLE if exists Settings")
 
         cur.execute(self.create_Settings)
 
-        print(stg.acoustic_data, stg.temperature, stg.rmin, stg.rmax, stg.tmin, stg.tmax)
+        logger.debug(f"acoustic_data: {stg.acoustic_data}")
+        logger.debug(f"temperature: {stg.temperature}")
+        logger.debug(f"rmin: {stg.rmin}, rmax: {stg.rmax}")
+        logger.debug(f"tmin: {stg.tmin}, tmax: {stg.tmax}")
 
         for i in stg.acoustic_data:
-            cur.execute('''INSERT into Settings(acoustic_data, temperature,
-                        tmin_index, tmin_value, tmax_index, tmax_value,
-                        rmin_index, rmin_value, rmax_index, rmax_value,
-                        freq_bottom_detection_index, freq_bottom_detection_value,
-                        SNR_filter_value, Nb_cells_to_average_BS_signal
-                        )
-                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                        (stg.acoustic_data[i], stg.temperature,
-                         stg.tmin[i][0], stg.tmin[i][1], stg.tmax[i][0], stg.tmax[i][1],
-                         stg.rmin[i][0], stg.rmin[i][1], stg.rmax[i][0], stg.rmax[i][1],
-                         stg.freq_bottom_detection[i][0], stg.freq_bottom_detection[i][1],
-                         stg.SNR_filter_value[i], stg.Nb_cells_to_average_BS_signal[i]
-                         )
-                        )
+            cur.execute(
+                """
+                INSERT into Settings(
+                  acoustic_data, temperature,
+                  tmin_index, tmin_value, tmax_index, tmax_value,
+                  rmin_index, rmin_value, rmax_index, rmax_value,
+                  freq_bottom_detection_index, freq_bottom_detection_value,
+                  SNR_filter_value, Nb_cells_to_average_BS_signal
+                )
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.acoustic_data[i], stg.temperature,
+                    stg.tmin[i][0], stg.tmin[i][1],
+                    stg.tmax[i][0], stg.tmax[i][1],
+                    stg.rmin[i][0], stg.rmin[i][1],
+                    stg.rmax[i][0], stg.rmax[i][1],
+                    stg.freq_bottom_detection[i][0],
+                    stg.freq_bottom_detection[i][1],
+                    stg.SNR_filter_value[i],
+                    stg.Nb_cells_to_average_BS_signal[i]
+                )
+            )
 
         cnx.commit()
 
-        print(f"table Settings : {time.time() - start_table_Settings} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # ++++++++++++++++++++++++++++
-                                                # --- Table Sediments File ---
-                                                # ++++++++++++++++++++++++++++
+        logger.info(f"table Settings : {time.time() - start_table_Settings} sec")
 
+    def create_table_sediments_file(self, cnx, cur):
         start_table_SedimentsFile = time.time()
 
         cur.execute("DROP TABLE if exists SedimentsFile")
 
         cur.execute(self.create_SedimentsFile)
 
-        cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine,
-                                                     path_sand, filename_sand, radius_grain_sand,
-                                                     time_column_label, distance_from_bank_column_label,
-                                                     depth_column_label, Ctot_fine_column_label, D50_fine_column_label,
-                                                     Ctot_sand_column_label, D50_sand_column_label)
-                                              VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                    (stg.path_fine, stg.filename_fine, stg.radius_grain_fine.tobytes(),
-                     stg.path_sand, stg.filename_sand, stg.radius_grain_sand.tobytes(),
-                     stg.columns_fine[0], stg.columns_fine[1], stg.columns_fine[2],
-                     stg.columns_fine[3], stg.columns_fine[4], stg.columns_sand[3], stg.columns_sand[4]))
+        if stg.path_fine != "" and path_sand != "":
+            cur.execute(
+                """
+                INSERT into SedimentsFile(
+                  path_fine, filename_fine, radius_grain_fine,
+                  path_sand, filename_sand, radius_grain_sand,
+                  time_column_label, distance_from_bank_column_label,
+                  depth_column_label, Ctot_fine_column_label,
+                  D50_fine_column_label,
+                  Ctot_sand_column_label, D50_sand_column_label
+                )
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.path_fine, stg.filename_fine,
+                    stg.radius_grain_fine.tobytes(),
+                    stg.path_sand, stg.filename_sand,
+                    stg.radius_grain_sand.tobytes(),
+                    stg.columns_fine[0], stg.columns_fine[1],
+                    stg.columns_fine[2], stg.columns_fine[3],
+                    stg.columns_fine[4],
+                    stg.columns_sand[3], stg.columns_sand[4]
+                )
+            )
 
         cnx.commit()
 
-        print(f"table SedimentsFile : {time.time() - start_table_SedimentsFile} sec")
+        logger.info(f"table SedimentsFile : {time.time() - start_table_SedimentsFile} sec")
 
-        # --------------------------------------------------------------------------------------------------------------
-                                                # ++++++++++++++++++++++++++++
-                                                # --- Table Sediments Data ---
-                                                # ++++++++++++++++++++++++++++
 
+    def create_table_sediments_data(self, cnx, cur):
         start_table_SedimentsData = time.time()
 
         cur.execute("DROP TABLE if exists SedimentsData")
@@ -394,59 +484,79 @@ class CreateTableForSaveAs:
         cur.execute(self.create_SedimentsData)
 
         for f in range(len(stg.sample_fine)):
-            cur.execute('''INSERT into SedimentsData(sample_fine_name, sample_fine_index, distance_from_bank_fine,
-                                    depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine,
-                                    frac_vol_fine, frac_vol_fine_cumul,
-                                    sample_sand_name, sample_sand_index, distance_from_bank_sand,
-                                    depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand,
-                                    frac_vol_sand, frac_vol_sand_cumul
-                                    )
-                        VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                    (stg.sample_fine[f][0] , stg.sample_fine[f][1],
-                     stg.distance_from_bank_fine[f], stg.depth_fine[f], stg.time_fine[f], stg.Ctot_fine[f],
-                     stg.Ctot_fine_per_cent[f], stg.D50_fine[f],
-                     stg.frac_vol_fine[f].tobytes(), stg.frac_vol_fine_cumul[f].tobytes(),
-                     stg.sample_sand[f][0], stg.sample_sand[f][1],
-                     stg.distance_from_bank_sand[f], stg.depth_sand[f], stg.time_sand[f], stg.Ctot_sand[f],
-                     stg.Ctot_sand_per_cent[f], stg.D50_sand[f],
-                     stg.frac_vol_sand[f].tobytes(), stg.frac_vol_sand_cumul[f].tobytes()))
+            cur.execute(
+                """
+                INSERT into SedimentsData(
+                  sample_fine_name, sample_fine_index,
+                  distance_from_bank_fine,
+                  depth_fine, time_fine, Ctot_fine,
+                  Ctot_fine_per_cent, D50_fine,
+                  frac_vol_fine, frac_vol_fine_cumul,
+                  sample_sand_name, sample_sand_index,
+                  distance_from_bank_sand,
+                  depth_sand, time_sand, Ctot_sand,
+                  Ctot_sand_per_cent, D50_sand,
+                  frac_vol_sand, frac_vol_sand_cumul
+                )
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+                       ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.sample_fine[f][0] , stg.sample_fine[f][1],
+                    stg.distance_from_bank_fine[f], stg.depth_fine[f],
+                    stg.time_fine[f], stg.Ctot_fine[f],
+                    stg.Ctot_fine_per_cent[f], stg.D50_fine[f],
+                    stg.frac_vol_fine[f].tobytes(),
+                    stg.frac_vol_fine_cumul[f].tobytes(),
+                    stg.sample_sand[f][0], stg.sample_sand[f][1],
+                    stg.distance_from_bank_sand[f], stg.depth_sand[f],
+                    stg.time_sand[f], stg.Ctot_sand[f],
+                    stg.Ctot_sand_per_cent[f], stg.D50_sand[f],
+                    stg.frac_vol_sand[f].tobytes(),
+                    stg.frac_vol_sand_cumul[f].tobytes()
+                )
+            )
 
         cnx.commit()
 
-        print(f"table SedimentsData : {time.time() - start_table_SedimentsData} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # ++++++++++++++++++++++++++++++
-                                                # --- Table Calibration ---
-                                                # ++++++++++++++++++++++++++++++
+        logger.info(f"table SedimentsData : {time.time() - start_table_SedimentsData} sec")
 
+    def create_table_calibration(self, cnx, cur):
         start_table_Calibration = time.time()
 
         cur.execute("DROP TABLE if exists Calibration")
 
         cur.execute(self.create_Calibration)
 
-        cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file,
-                                                    range_lin_interp, M_profile_fine,
-                                                    ks, sv, X_exponent, alpha_s, zeta,
-                                                    FCB, depth_real, lin_reg)
-                            VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
-                    (stg.path_calibration_file, stg.filename_calibration_file,
-                     stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(),
-                     np.array(stg.ks).tobytes(), np.array(stg.sv).tobytes(), np.array(stg.X_exponent).tobytes(),
-                     np.array(stg.alpha_s).tobytes(), np.array(stg.zeta).tobytes(),
-                     stg.FCB.tobytes(), stg.depth_real.tobytes(), np.array(stg.lin_reg).tobytes())
-                    )
+        if len(stg.range_lin_interp) != 0:
+            cur.execute(
+                """
+                INSERT into Calibration(
+                  path_calibration_file, filename_calibration_file,
+                  range_lin_interp, M_profile_fine,
+                  ks, sv, X_exponent, alpha_s, zeta,
+                  FCB, depth_real, lin_reg
+                )
+                VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.path_calibration_file, stg.filename_calibration_file,
+                    stg.range_lin_interp.tobytes(),
+                    stg.M_profile_fine.tobytes(),
+                    np.array(stg.ks).tobytes(), np.array(stg.sv).tobytes(),
+                    np.array(stg.X_exponent).tobytes(),
+                    np.array(stg.alpha_s).tobytes(),
+                    np.array(stg.zeta).tobytes(),
+                    stg.FCB.tobytes(), stg.depth_real.tobytes(),
+                    np.array(stg.lin_reg).tobytes()
+                )
+            )
 
         cnx.commit()
 
-        print(f"table Calibration : {time.time() - start_table_Calibration} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-                                                # ++++++++++++++++++++++++++++++
-                                                # --- Table Inversion ---
-                                                # ++++++++++++++++++++++++++++++
+        logger.info(f"table Calibration : {time.time() - start_table_Calibration} sec")
 
+    def create_table_inversion(self, cnx, cur):
         start_table_Inversion = time.time()
 
         cur.execute("DROP TABLE if exists Inversion")
@@ -454,21 +564,23 @@ class CreateTableForSaveAs:
         cur.execute(self.create_Inversion)
 
         for i in range(len(stg.SSC_fine)):
-            cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2,
-                                                    VBI_cross_section, SSC_fine, SSC_sand)
-                                VALUES(?, ?, ?, ?, ?)''',
-                        (stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(),
-                         stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes())
-                    )
+            cur.execute(
+                """
+                INSERT into Inversion(
+                  J_cross_section_freq1, J_cross_section_freq2,
+                  VBI_cross_section, SSC_fine, SSC_sand
+                )
+                VALUES(?, ?, ?, ?, ?)
+                """,
+                (
+                    stg.J_cross_section[i][0].tobytes(),
+                    stg.J_cross_section[i][1].tobytes(),
+                    stg.VBI_cross_section[i].tobytes(),
+                    stg.SSC_fine[i].tobytes(),
+                    stg.SSC_sand[i].tobytes()
+                )
+            )
 
         cnx.commit()
 
-        print(f"table Inversion : {time.time() - start_table_Inversion} sec")
-
-        # --------------------------------------------------------------------------------------------------------------
-
-        # Close database cursor
-        cur.close()
-
-        # Close database connection
-        cnx.close()
+        logger.info(f"table Inversion : {time.time() - start_table_Inversion} sec")

View/sample_data_tab.py

@@ -20,12 +20,8 @@
 
 # -*- coding: utf-8 -*-
 
-
-from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel, QSpacerItem, QSizePolicy,
-                            QTableWidget, QPushButton, QLineEdit,
-                            QTableWidgetItem, QComboBox, QFileDialog, QGridLayout, QMessageBox)
-from PyQt5.QtGui import QIcon
-from PyQt5.QtCore import Qt, QCoreApplication, pyqtSignal
+import os
+import logging
 
 import numpy as np
 import pandas as pd
@@ -36,7 +32,13 @@ from matplotlib.colors import LogNorm, BASE_COLORS
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar
 
-from os import path
+from PyQt5.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel,
+    QSpacerItem, QSizePolicy, QTableWidget, QPushButton, QLineEdit,
+    QTableWidgetItem, QComboBox, QFileDialog, QGridLayout, QMessageBox
+)
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import Qt, QCoreApplication, pyqtSignal
 
 from Model.granulo_loader import GranuloLoader
 
@@ -48,6 +50,7 @@ import settings as stg
 
 _translate = QCoreApplication.translate
 
+logger = logging.getLogger()
 
 class SampleDataTab(QWidget):
 
@@ -57,8 +60,7 @@ class SampleDataTab(QWidget):
     def __init__(self, widget_tab):
         super().__init__()
 
-        path_icon = "./icons/"
-        icon_folder = QIcon(path_icon + "folder.png")
+        icon_folder = QIcon(os.path.join("icons", "folder.png"))
 
         ### --- General layout of widgets ---
 
@@ -269,20 +271,36 @@ class SampleDataTab(QWidget):
 
         self.groupbox_plot_PSD.setTitle(_translate("CONSTANT_STRING", cs.DISTRIBUTION_PLOT))
 
-    # ------------------------------------------------------------------------------------------------------------------
-    # --- Function to select directory and file name of fine sediments sample data ---
-    def open_dialog_box_fine_sediment(self):
 
+    def last_opened_file_path(self, priority="sand"):
+        lst = []
+
+        if priority == "sand":
+            lst += [stg.path_sand]
+            lst += [stg.path_fine]
+        else:
+            lst += [stg.path_fine]
+            lst += [stg.path_sand]
+
+        lst += stg.path_BS_raw_data
+
+        for path in lst:
+            if path != "":
+                return path
+
+        return ""
+
+    def open_dialog_box_fine_sediment(self):
         filename_fine_sediment = QFileDialog.getOpenFileName(
             self, "Fine sediment file",
-            [stg.path_fine if stg.path_fine else stg.path_sand if stg.path_sand
-            else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0],
+            self.last_opened_file_path(priority="fine"),
             "Fine sediment file (*.xlsx, *xls, *.ods)",
-            options=QFileDialog.DontUseNativeDialog)
+            options=QFileDialog.DontUseNativeDialog
+        )
 
         try:
-            stg.path_fine = path.dirname(filename_fine_sediment[0])
-            stg.filename_fine = path.basename(filename_fine_sediment[0])
+            stg.path_fine = os.path.dirname(filename_fine_sediment[0])
+            stg.filename_fine = os.path.basename(filename_fine_sediment[0])
             self.load_fine_sediment_data()
         except IsADirectoryError:
             msgBox = QMessageBox()
@@ -291,25 +309,24 @@ class SampleDataTab(QWidget):
             msgBox.setText("Please select a file")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
+        except Exception as e:
+            logger.error(e)
         else:
             self.lineEdit_fine_sediment.clear()
             self.lineEdit_fine_sediment.setText(stg.filename_fine)
             self.lineEdit_fine_sediment.setToolTip(stg.path_fine)
             self.fill_table_fine()
 
-    # --- Function to select directory and file name of sand sediments sample data ---
     def open_dialog_box_sand_sediment(self):
-
         filename_sand_sediment = QFileDialog.getOpenFileName(
             self, "Sand sediment file",
-            [stg.path_sand if stg.path_sand else stg.path_fine if stg.path_fine
-            else stg.path_BS_raw_data[-1] if self.combobox_acoustic_data.count() > 0 else ""][0],
+            self.last_opened_file_path(priority="sand"),
             "Sand sediment file (*.xlsx, *xls, *.ods)",
             options=QFileDialog.DontUseNativeDialog)
 
         try:
-            stg.path_sand = path.dirname(filename_sand_sediment[0])
-            stg.filename_sand = path.basename(filename_sand_sediment[0])
+            stg.path_sand = os.path.dirname(filename_sand_sediment[0])
+            stg.filename_sand = os.path.basename(filename_sand_sediment[0])
             self.load_sand_sediment_data()
         except IsADirectoryError:
             msgBox = QMessageBox()
@@ -318,13 +335,17 @@ class SampleDataTab(QWidget):
             msgBox.setText("Please select a file")
             msgBox.setStandardButtons(QMessageBox.Ok)
             msgBox.exec()
+        except Exception as e:
+            logger.error(e)
         else:
             self.lineEdit_sand_sediment.setText(stg.filename_sand)
             self.lineEdit_sand_sediment.setToolTip(stg.path_sand)
             self.fill_table_sand()
 
     def load_fine_sediment_data(self):
-        fine_granulo_data = GranuloLoader(stg.path_fine + "/" + stg.filename_fine)
+        fine_granulo_data = GranuloLoader(
+            os.path.join(stg.path_fine, stg.filename_fine)
+        )
         stg.columns_fine = fine_granulo_data._data.columns
         stg.time_fine = fine_granulo_data._time
         stg.distance_from_bank_fine = fine_granulo_data._y
@@ -336,7 +357,9 @@ class SampleDataTab(QWidget):
         stg.frac_vol_fine_cumul = fine_granulo_data._frac_vol_cumul
 
     def load_sand_sediment_data(self):
-        sand_granulo_data = GranuloLoader(stg.path_sand + "/" + stg.filename_sand)
+        sand_granulo_data = GranuloLoader(
+            os.path.join(stg.path_sand, stg.filename_sand)
+        )
         stg.columns_sand = sand_granulo_data._data.columns
         stg.time_sand = sand_granulo_data._time
         stg.distance_from_bank_sand = sand_granulo_data._y
@@ -359,36 +382,57 @@ class SampleDataTab(QWidget):
     # ------------------------------------------------------------------------------------------------------------------
     # --- Function to fill table of values ---
     def fill_table_fine(self):
-        if self.lineEdit_fine_sediment.text():
+        self.tableWidget_fine.blockSignals(True)
 
-            self.row_fine = self.tableWidget_fine.setRowCount(len(stg.depth_fine))
-            self.column_fine = self.tableWidget_fine.setColumnCount(6 + stg.radius_grain_fine.shape[0])
+        if self.lineEdit_fine_sediment.text():
+            self.row_fine = self.tableWidget_fine.setRowCount(
+                len(stg.depth_fine)
+            )
+            self.column_fine = self.tableWidget_fine.setColumnCount(
+                6 + stg.radius_grain_fine.shape[0]
+            )
 
             # --- Set horizontal header ---
-
-            horizontal_header = list(itertools.chain(["Color", "Sample"],
-                                                     list(map(str, stg.columns_fine[[0, 2]])),
-                                                     list(map(str, stg.columns_fine[3:]))))
+            horizontal_header = list(
+                itertools.chain(
+                    ["Color", "Sample"],
+                    list(map(str, stg.columns_fine[[0, 2]])),
+                    list(map(str, stg.columns_fine[3:]))
+                )
+            )
 
             for horizontal_header_text in horizontal_header:
                 self.horizontal_header_item_fine = QTableWidgetItem()
-                self.tableWidget_fine.setHorizontalHeaderItem(horizontal_header.index(horizontal_header_text),
-                                                                self.horizontal_header_item_fine)
+                self.tableWidget_fine.setHorizontalHeaderItem(
+                    horizontal_header.index(horizontal_header_text),
+                    self.horizontal_header_item_fine
+                )
                 self.horizontal_header_item_fine.setText(horizontal_header_text)
 
             # --- Set vertical header (color) ---
             self.tableWidget_fine.verticalHeader().setVisible(False)
             color_list = BASE_COLORS
+
+            self.comboBox_sample_table_fine = []
             for i in range(self.tableWidget_fine.rowCount()):
-                exec("self.comboBox_sample_table_fine" + str(i) + "= QComboBox()")
-                exec("self.comboBox_sample_table_fine" + str(i) + ".addItems(color_list)")
-                eval(f"self.tableWidget_fine.setCellWidget(i, 0, self.comboBox_sample_table_fine{i})")
-                eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged."
-                     f"connect(self.plot_total_concentration)")
-                eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged."
-                     f"connect(self.plot_PSD_fine_and_sand_sediments)")
-                eval(f"self.comboBox_sample_table_fine{i}.currentTextChanged."
-                     f"connect(self.update_plot_sample_position_on_transect)")
+                self.comboBox_sample_table_fine.append(
+                    QComboBox()
+                )
+
+                self.comboBox_sample_table_fine[i].addItems(color_list)
+                self.tableWidget_fine.setCellWidget(
+                    i, 0, self.comboBox_sample_table_fine[i]
+                )
+
+                self.comboBox_sample_table_fine[i]\
+                    .currentTextChanged\
+                    .connect(self.plot_total_concentration)
+                self.comboBox_sample_table_fine[i]\
+                    .currentTextChanged\
+                    .connect(self.plot_PSD_fine_and_sand_sediments)
+                self.comboBox_sample_table_fine[i]\
+                    .currentTextChanged\
+                    .connect(self.update_plot_sample_position_on_transect)
 
             # --- Fill Sample column with checkbox ---
             for i in range(self.tableWidget_fine.rowCount()):
@@ -401,12 +445,21 @@ class SampleDataTab(QWidget):
             # --- Fill table with data ---
             for i in range(stg.frac_vol_fine.shape[0]):
                 for j in range(stg.frac_vol_fine.shape[1]):
-                    self.tableWidget_fine.setItem(i, 2, QTableWidgetItem(str(stg.time_fine[i])))
-                    self.tableWidget_fine.setItem(i, 3, QTableWidgetItem(str(stg.depth_fine[i])))
-
-                    self.tableWidget_fine.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_fine[i])))
-                    self.tableWidget_fine.setItem(i, 5, QTableWidgetItem(str(stg.D50_fine[i])))
-                    self.tableWidget_fine.setItem(i, j + 6, QTableWidgetItem(str(stg.frac_vol_fine[i, j])))
+                    self.tableWidget_fine.setItem(
+                        i, 2, QTableWidgetItem(str(stg.time_fine[i]))
+                    )
+                    self.tableWidget_fine.setItem(
+                        i, 3, QTableWidgetItem(str(stg.depth_fine[i]))
+                    )
+                    self.tableWidget_fine.setItem(
+                        i, 4, QTableWidgetItem(str(stg.Ctot_fine[i]))
+                    )
+                    self.tableWidget_fine.setItem(
+                        i, 5, QTableWidgetItem(str(stg.D50_fine[i]))
+                    )
+                    self.tableWidget_fine.setItem(
+                        i, j + 6, QTableWidgetItem(str(stg.frac_vol_fine[i, j]))
+                    )
 
             # --- Connect checkbox to all checkboxes of tableWidget ---
             # self.allChkBox.stateChanged.connect(self.check_allChkBox)
@@ -423,6 +476,7 @@ class SampleDataTab(QWidget):
             self.plot_total_concentration()
             self.plot_PSD_fine_and_sand_sediments()
 
+            self.tableWidget_fine.blockSignals(False)
         else:
             msgBox = QMessageBox()
             msgBox.setWindowTitle("Fill table Error")
@@ -432,36 +486,50 @@ class SampleDataTab(QWidget):
             msgBox.exec()
 
     def fill_table_sand(self):
-        if self.lineEdit_sand_sediment.text():
+        self.tableWidget_sand.blockSignals(True)
 
+        if self.lineEdit_sand_sediment.text():
             self.row_sand = self.tableWidget_sand.setRowCount(len(stg.depth_sand))
             self.column_sand = self.tableWidget_sand.setColumnCount(6 + stg.radius_grain_sand.shape[0])
-
             # --- Set horizontal header ---
-
-            horizontal_header = list(itertools.chain(["Color", "Sample"],
-                                                     list(map(str, stg.columns_sand[[0, 2]])),
-                                                     list(map(str, stg.columns_sand[3:]))))
+            horizontal_header = list(
+                itertools.chain(
+                    ["Color", "Sample"],
+                    list(map(str, stg.columns_sand[[0, 2]])),
+                    list(map(str, stg.columns_sand[3:]))
+                )
+            )
 
             for horizontal_header_text in horizontal_header:
                 self.horizontal_header_item_sand = QTableWidgetItem()
-                self.tableWidget_sand.setHorizontalHeaderItem(horizontal_header.index(horizontal_header_text),
-                                                                self.horizontal_header_item_sand)
+                self.tableWidget_sand.setHorizontalHeaderItem(
+                    horizontal_header.index(horizontal_header_text),
+                    self.horizontal_header_item_sand
+                )
                 self.horizontal_header_item_sand.setText(horizontal_header_text)
 
             # --- Set vertical header (color) ---
             self.tableWidget_sand.verticalHeader().setVisible(False)
             color_list = BASE_COLORS
+
+            self.comboBox_sample_table_sand = []
             for i in range(self.tableWidget_sand.rowCount()):
-                exec("self.comboBox_sample_table_sand" + str(i) + "= QComboBox()")
-                exec("self.comboBox_sample_table_sand" + str(i) + ".addItems(color_list)")
-                eval(f"self.tableWidget_sand.setCellWidget(i, 0, self.comboBox_sample_table_sand{i})")
-                eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged."
-                     f"connect(self.plot_total_concentration)")
-                eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged."
-                     f"connect(self.plot_PSD_fine_and_sand_sediments)")
-                eval(f"self.comboBox_sample_table_sand{i}.currentTextChanged."
-                     f"connect(self.update_plot_sample_position_on_transect)")
+                self.comboBox_sample_table_sand.append(QComboBox())
+
+                self.comboBox_sample_table_sand[i].addItems(color_list)
+                self.tableWidget_sand.setCellWidget(
+                    i, 0, self.comboBox_sample_table_sand[i]
+                )
+
+                self.comboBox_sample_table_sand[i]\
+                    .currentTextChanged\
+                    .connect(self.plot_total_concentration)
+                self.comboBox_sample_table_sand[i]\
+                    .currentTextChanged\
+                    .connect(self.plot_PSD_fine_and_sand_sediments)
+                self.comboBox_sample_table_sand[i]\
+                    .currentTextChanged\
+                    .connect(self.update_plot_sample_position_on_transect)
 
             # --- Fill Sample column with checkbox ---
             for i in range(self.tableWidget_sand.rowCount()):
@@ -474,25 +542,44 @@ class SampleDataTab(QWidget):
             # --- Fill table with data ---
             for i in range(stg.frac_vol_sand.shape[0]):
                 for j in range(stg.frac_vol_sand.shape[1]):
-                    self.tableWidget_sand.setItem(i, 2, QTableWidgetItem(str(stg.time_sand[i])))
-                    self.tableWidget_sand.setItem(i, 3, QTableWidgetItem(str(stg.depth_sand[i])))
-
-                    self.tableWidget_sand.setItem(i, 4, QTableWidgetItem(str(stg.Ctot_sand[i])))
-                    self.tableWidget_sand.setItem(i, 5, QTableWidgetItem(str(stg.D50_sand[i])))
-                    self.tableWidget_sand.setItem(i, j + 6, QTableWidgetItem(str(stg.frac_vol_sand[i, j])))
+                    self.tableWidget_sand.setItem(
+                        i, 2, QTableWidgetItem(str(stg.time_sand[i]))
+                    )
+                    self.tableWidget_sand.setItem(
+                        i, 3, QTableWidgetItem(str(stg.depth_sand[i]))
+                    )
+                    self.tableWidget_sand.setItem(
+                        i, 4, QTableWidgetItem(str(stg.Ctot_sand[i]))
+                    )
+                    self.tableWidget_sand.setItem(
+                        i, 5, QTableWidgetItem(str(stg.D50_sand[i]))
+                    )
+                    self.tableWidget_sand.setItem(
+                        i, j + 6, QTableWidgetItem(str(stg.frac_vol_sand[i, j]))
+                    )
 
             # --- Connect checkbox items of tableWidget to update plots ---
-            self.tableWidget_sand.itemChanged.connect(self.update_plot_sample_position_on_transect)
-            self.tableWidget_sand.itemChanged.connect(self.plot_total_concentration)
-            self.tableWidget_sand.itemChanged.connect(self.plot_PSD_fine_and_sand_sediments)
+            self.tableWidget_sand\
+                .itemChanged\
+                .connect(self.update_plot_sample_position_on_transect)
+            self.tableWidget_sand\
+                .itemChanged\
+                .connect(self.plot_total_concentration)
+            self.tableWidget_sand\
+                .itemChanged\
+                .connect(self.plot_PSD_fine_and_sand_sediments)
 
-            self.combobox_x_axis.currentIndexChanged.connect(self.plot_total_concentration)
-            self.combobox_y_axis.currentIndexChanged.connect(self.plot_total_concentration)
+            self.combobox_x_axis.currentIndexChanged\
+                                .connect(self.plot_total_concentration)
+            self.combobox_y_axis.currentIndexChanged\
+                                .connect(self.plot_total_concentration)
 
             self.plot_sample_position_on_transect()
             self.plot_total_concentration()
             self.plot_PSD_fine_and_sand_sediments()
 
+            self.tableWidget_sand.blockSignals(False)
+
     # --- Function to extract position of sample from table checkboxes to update plots ---
     def extract_position_list_and_color_list_from_table_checkboxes_fine(self):
         position = []
@@ -502,7 +589,7 @@ class SampleDataTab(QWidget):
             if self.tableWidget_fine.item(i, 1).checkState() == 2:
                 if self.tableWidget_fine.item(i, 1).checkState() == Qt.Checked:
                     position.append(i)
-                    eval(f"color_list.append(self.comboBox_sample_table_fine{i}.currentText())")
+                    color_list.append(self.comboBox_sample_table_fine[i].currentText())
                     sample_checkbox[0, i] = 2
 
         return position, color_list
@@ -570,7 +657,9 @@ class SampleDataTab(QWidget):
                 if self.tableWidget_sand.item(i, 1).checkState() == 2:
                     if self.tableWidget_sand.item(i, 1).checkState() == Qt.Checked:
                         position.append(i)
-                        eval(f"color_list.append(self.comboBox_sample_table_sand{i}.currentText())")
+                        color_list.append(
+                            self.comboBox_sample_table_sand[i].currentText()
+                        )
                         sample_checkbox[0, i] = 2
             return position, color_list
 
@@ -646,7 +735,6 @@ class SampleDataTab(QWidget):
         self.combobox_acoustic_data.showPopup()
 
     def fill_comboboxes_and_plot_transect(self):
-
         self.combobox_acoustic_data.clear()
         for n, m in enumerate(stg.noise_method):
             if stg.noise_method[n] == 0:
@@ -659,19 +747,23 @@ class SampleDataTab(QWidget):
         self.combobox_frequencies.currentIndexChanged.connect(self.update_plot_sample_position_on_transect)
 
     def plot_sample_position_on_transect(self):
+        self.verticalLayout_groupbox_plot_transect\
+            .removeWidget(self.canvas_plot_sample_position_on_transect)
 
-        self.verticalLayout_groupbox_plot_transect.removeWidget(self.canvas_plot_sample_position_on_transect)
+        fig, axis = plt.subplots(nrows=1, ncols=1, layout="constrained")
 
-        self.figure_plot_sample_position_on_transect, self.axis_plot_sample_position_on_transect = \
-            plt.subplots(nrows=1, ncols=1, layout="constrained")
-        self.canvas_plot_sample_position_on_transect = FigureCanvas(self.figure_plot_sample_position_on_transect)
+        self.figure_plot_sample_position_on_transect = fig
+        self.axis_plot_sample_position_on_transect = axis
 
-        self.verticalLayout_groupbox_plot_transect.addWidget(self.canvas_plot_sample_position_on_transect)
+        self.canvas_plot_sample_position_on_transect = FigureCanvas(
+            self.figure_plot_sample_position_on_transect
+        )
+
+        self.verticalLayout_groupbox_plot_transect\
+            .addWidget(self.canvas_plot_sample_position_on_transect)
 
         if self.combobox_acoustic_data.count() == 0:
-
             if self.tableWidget_fine.columnCount() > 10:
-
                 position_list_fine, color_list_fine = self.extract_position_list_and_color_list_from_table_checkboxes_fine()
 
                 self.axis_plot_sample_position_on_transect.scatter(
@@ -1696,4 +1788,3 @@ class SampleDataTab(QWidget):
                         self.axis_plot_PSD[1].set_ylabel('Cumulative size volume fraction')
 
                 self.figure_plot_PSD.canvas.draw_idle()
-

View/signal_processing_tab.py

@@ -14,19 +14,25 @@
     #                                                                        #
     # You should have received a copy of the GNU General Public License      #
     # along with this program.  If not, see <https://www.gnu.org/licenses/>. #
-from cProfile import label
 
 #                                                      by Brahim MOUDJED #
 # ============================================================================== #
 
 # -*- coding: utf-8 -*-
 
+from cProfile import label
 
-from PyQt5.QtWidgets import (QWidget, QHBoxLayout, QVBoxLayout, QPushButton, QGroupBox, QLabel,
-                            QSpinBox,  QComboBox, QLineEdit, QSlider, QGridLayout, QMessageBox,
-                             QScrollArea, QFileDialog, QSpacerItem, QSizePolicy)
+from PyQt5.QtWidgets import (
+    QWidget, QHBoxLayout, QVBoxLayout, QPushButton, QGroupBox,
+    QLabel, QSpinBox,  QComboBox, QLineEdit, QSlider,
+    QGridLayout, QMessageBox, QScrollArea, QFileDialog,
+    QSpacerItem, QSizePolicy
+)
 from PyQt5.QtGui import QIcon
-from PyQt5.QtCore import Qt, QCoreApplication, QEvent, pyqtSignal, QPropertyAnimation, QSize
+from PyQt5.QtCore import (
+    Qt, QCoreApplication, QEvent, pyqtSignal, QPropertyAnimation,
+    QSize
+)
 
 import numpy as np
 from copy import deepcopy
@@ -641,6 +647,9 @@ class SignalProcessingTab(QWidget):
         stg.BS_mean[self.combobox_acoustic_data_choice.currentIndex()] = (
                 np.nanmean(stg.BS_raw_data[self.combobox_acoustic_data_choice.currentIndex()][:, :, val1:val2], axis=2))
 
+        if stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
+            self.compute_noise_from_profile_tail_value()
+
     def plot_averaged_profile_tail(self):
 
         # --- Plot averaged signal ---
@@ -926,7 +935,7 @@ class SignalProcessingTab(QWidget):
         # --- Compute noise from value and compute SNR ---
 
         if stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,):
-
+            stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = np.array([])
             stg.BS_noise_raw_data[self.combobox_acoustic_data_choice.currentIndex()] = (
                 np.full(stg.BS_stream_bed[self.combobox_acoustic_data_choice.currentIndex()].shape,
                         float(self.lineEdit_profile_tail_value.text().replace(",", "."))))
@@ -986,7 +995,7 @@ class SignalProcessingTab(QWidget):
         self.plot_pre_processed_BS_signal()
         self.plot_pre_processed_profile()
 
-        self.activate_list_of_pre_processed_data()
+        # self.activate_list_of_pre_processed_data()
 
     def plot_noise(self):
         self.horizontalLayout_groupbox_plot_noise_data.removeWidget(self.canvas_noise)

main.py

@@ -33,7 +33,8 @@ logging.basicConfig(
 )
 
 logger = logging.getLogger()
-logger.setLevel(logging.DEBUG)
+# logger.setLevel(logging.DEBUG)
+logger.setLevel(logging.INFO)
 
 class MainApplication(QMainWindow):
 
@@ -53,7 +54,6 @@ class MainApplication(QMainWindow):
             # -------------- Acoustic data tab ---------------
 
             self.acoustic_data_tab = AcousticDataTab(self.ui_mainwindow.tab1)
-            print("0 AcousticDataTab ", id(AcousticDataTab))
 
             self.acoustic_data_tab\
                 .combobox_ABS_system_choice\