diff --git a/Model/read_table_for_open.py b/Model/read_table_for_open.py index a6ca72d..7eff069 100644 --- a/Model/read_table_for_open.py +++ b/Model/read_table_for_open.py @@ -60,41 +60,59 @@ class ReadTableForOpen: except OSError as e: logger.warning(f"chdir: {str(e)}") - self.sql_file_to_open = open(stg.filename_open) self.read_table() self.opened = True - def read_table(self): + def execute(self, query): + return self._cur.execute(query).fetchall() + def read_table(self): stg.read_table_trigger = 1 - # connexion to File db + logger.debug(f"Open '{stg.filename_open}'") + cnx = sqlite3.connect(stg.filename_open) + self._cur = cnx.cursor() - # Create database cursor to execute SQL statements and fetch results from SQL queries. - cur = cnx.cursor() + self.read_table_acoustic_file() + self.read_table_measure() + self.read_table_BS_raw_data() + self.read_table_settings() + self.read_table_sediment_file() + self.read_table_table_sediment_data() - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Acoustic File --- - # +++++++++++++++++++++++++++ + logger.debug(f"Reading '{stg.filename_open}' done") + self._cur.close() + cnx.close() + + logger.debug(f"'{stg.filename_open}' closed") + + def read_table_acoustic_file(self): query0 = f'''SELECT acoustic_data FROM AcousticFile''' - data0 = cur.execute(query0).fetchall() - print("data0 ", data0) + data0 = self.execute(query0) + + logger.debug(f"data0: {data0}") stg.acoustic_data = [x[0] for x in data0] - print("stg.acoustic_data ", stg.acoustic_data) + logger.debug(f"stg.acoustic_data: {stg.acoustic_data}") for k in range(len(stg.acoustic_data)): - print("hello") - query = f'''SELECT acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, filename_BS_noise_data, - noise_method, noise_value, data_preprocessed FROM AcousticFile WHERE (acoustic_data = {k})''' - data = cur.execute(query).fetchall() + query = f''' + SELECT + acoustic_data, acoustic_file, ABS_name, path_BS_noise_data, + filename_BS_noise_data, + noise_method, noise_value, data_preprocessed + FROM AcousticFile + WHERE (acoustic_data = {k}) + ''' + data = self.execute(query) print("data acoustic file", data) - stg.filename_BS_raw_data.append([str(y[1]) + '.aqa' for y in data][0]) + stg.filename_BS_raw_data.append( + [str(y[1]) + '.aqa' for y in data][0] + ) stg.ABS_name.append([z[2] for z in data][0]) stg.path_BS_noise_data.append([z[3] for z in data][0]) stg.filename_BS_noise_data.append([z[4] for z in data][0]) @@ -102,31 +120,45 @@ class ReadTableForOpen: stg.noise_value.append([z[6] for z in data][0]) stg.data_preprocessed.append([z[7] for z in data][0]) - print("data acoustic file ", stg.filename_BS_raw_data, stg.ABS_name, stg.path_BS_noise_data, stg.filename_BS_noise_data, - stg.noise_method, stg.noise_value, stg.data_preprocessed) - - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++ - # --- Table Measure --- - # +++++++++++++++++++++ + logger.debug("data acoustic file:") + logger.debug(f"- {stg.filename_BS_raw_data}") + logger.debug(f"- {stg.ABS_name}") + logger.debug(f"- {stg.path_BS_noise_data}") + logger.debug(f"- {stg.filename_BS_noise_data}") + logger.debug(f"- {stg.noise_method}") + logger.debug(f"- {stg.noise_value}") + logger.debug(f"- {stg.data_preprocessed}") + def read_table_measure(self): stg.date = [0]*len(stg.acoustic_data) stg.hour = [0]*len(stg.acoustic_data) - for i in range(len(stg.acoustic_data)): - print("i = ", i) - query1 = f'''SELECT acoustic_data, Date, Hour, frequency, sound_attenuation, kt_read, kt_corrected, NbProfiles, - NbProfilesPerSeconds, NbCells, CellSize, PulseLength, NbPingsPerSeconds, NbPingsAveragedPerProfile, - GainRx, GainTx FROM Measure WHERE (acoustic_data = {i})''' - data1 = cur.execute(query1).fetchall() - print("--------------------------------------") - print("data1 ", data1) + for i in range(len(stg.acoustic_data)): + query1 = f''' + SELECT + acoustic_data, Date, Hour, frequency, + sound_attenuation, kt_read, kt_corrected, NbProfiles, + NbProfilesPerSeconds, NbCells, CellSize, PulseLength, + NbPingsPerSeconds, NbPingsAveragedPerProfile, + GainRx, GainTx + FROM Measure + WHERE (acoustic_data = {i}) + ''' + data1 = self.execute(query1) + + logger.debug(f"data1 for {i}: {data1}") stg.date[i] = data1[0][1] stg.hour[i] = data1[0][2] - stg.freq.append(np.array([x[3] for x in data1])) - stg.freq_text.append([str(x[3]*1e-6) + 'MHz' for x in data1]) - stg.water_attenuation.append([x[4] for x in data1]) + stg.freq.append( + np.array([x[3] for x in data1]) + ) + stg.freq_text.append( + [str(x[3]*1e-6) + 'MHz' for x in data1] + ) + stg.water_attenuation.append( + [x[4] for x in data1] + ) stg.kt_read.append([x[5] for x in data1]) stg.kt_corrected = [x[6] for x in data1] stg.nb_profiles.append([x[7] for x in data1]) @@ -134,154 +166,309 @@ class ReadTableForOpen: stg.nb_cells.append([x[9] for x in data1]) stg.cell_size.append([x[10] for x in data1]) stg.pulse_length.append([x[11] for x in data1]) - stg.nb_pings_per_sec.append([x[12] for x in data1]) - stg.nb_pings_averaged_per_profile.append([x[13] for x in data1]) + stg.nb_pings_per_sec.append( + [x[12] for x in data1] + ) + stg.nb_pings_averaged_per_profile.append( + [x[13] for x in data1] + ) stg.gain_rx.append([x[14] for x in data1]) stg.gain_tx.append([x[15] for x in data1]) - print(stg.acoustic_data, stg.freq, stg.water_attenuation, stg.kt_read, stg.kt_corrected, stg.nb_profiles, stg.nb_profiles_per_sec, - stg.nb_cells, stg.cell_size, stg.pulse_length, stg.nb_pings_per_sec, stg.nb_pings_averaged_per_profile, - stg.gain_rx, stg.gain_tx) + logger.debug("measure:") + logger.debug(f"- {stg.acoustic_data}") + logger.debug(f"- {stg.freq}") + logger.debug(f"- {stg.water_attenuation}") + logger.debug(f"- {stg.kt_read}") + logger.debug(f"- {stg.kt_corrected}") + logger.debug(f"- {stg.nb_profiles}") + logger.debug(f"- {stg.nb_profiles_per_sec}") + logger.debug(f"- {stg.nb_cells}") + logger.debug(f"- {stg.cell_size}") + logger.debug(f"- {stg.pulse_length}") + logger.debug(f"- {stg.nb_pings_per_sec}") + logger.debug(f"- {stg.nb_pings_averaged_per_profile}") + logger.debug(f"- {stg.gain_rx}") + logger.debug(f"- {stg.gain_tx}") - print(stg.date) - print(stg.hour) + logger.debug(f"- {stg.date}") + logger.debug(f"- {stg.hour}") - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++ - # --- Table BSRawData --- - # ++++++++++++++++++++++ - print("len stg.acoustic_data ", len(stg.acoustic_data)) - for j in range(len(stg.acoustic_data)): - print(f"j = {j}") - query2 = f'''SELECT 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 - FROM BSRawData WHERE (acoustic_data = {j})''' + def read_table_BS_raw_data(self): + logger.debug(f"len stg.acoustic_data: {len(stg.acoustic_data)}") - data2 = cur.execute(query2).fetchall() - print("len data2 ", len(data2)) + for i in range(len(stg.acoustic_data)): + query = lambda values: f''' + SELECT + {", ".join(values)} + FROM BSRawData + WHERE (acoustic_data = {i}) + ''' - stg.time.append(np.frombuffer(data2[0][1], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("stg.time[0].shape ", stg.time[j].shape, np.frombuffer(data2[0][1], dtype=np.float64).shape) - print(stg.time) - stg.depth.append(np.frombuffer(data2[0][2], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("stg.depth[0].shape ", stg.depth[j].shape) - print(stg.depth) - stg.BS_raw_data.append(np.frombuffer(data2[0][3], dtype=np.float64).reshape((stg.freq[j].shape[0], stg.depth[j].shape[1], stg.time[j].shape[1]))) - print("BS_raw_data ", stg.BS_raw_data[j].shape) - stg.time_reshape.append(np.frombuffer(data2[0][4], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - print("stg.time_reshape[0].shape ", stg.time_reshape[j].shape) - stg.depth_reshape.append(np.frombuffer(data2[0][5], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - stg.BS_raw_data_reshape.append(np.frombuffer(data2[0][6], dtype=np.float64).reshape((-1, stg.freq[j].shape[0]))) - print("time cross section ", stg.time_cross_section, stg.time_cross_section == []) + self.read_table_BS_raw_data_raw(query, i) + self.read_table_BS_raw_data_cross_section(query, i) + self.read_table_BS_raw_data_bed(query, i) + self.read_table_BS_raw_data_noise(query, i) + self.read_table_BS_raw_data_SNR(query, i) + self.read_table_BS_raw_data_rest(query, i) + self.read_table_BS_raw_data_mean(query, i) - print("np.frombuffer(data2[0][9], dtype=np.float64) ", np.frombuffer(data2[0][9], dtype=np.float64)) - if len(np.frombuffer(data2[0][9], dtype=np.float64)) == 0: - print("Je suis là") - stg.time_cross_section.append(np.array([])) - stg.depth_cross_section.append(np.array([])) - stg.BS_cross_section.append(np.array([])) + def read_table_BS_raw_data_raw(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time", "depth", + "BS_raw_data", + "time_reshape", "depth_reshape", + "BS_raw_data_reshape", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS_raw_data = next(it) + time_reshape = next(it) + depth_reshape = next(it) + BS_raw_data_reshape = next(it) + + stg.time.append( + np_f64_parse(time).reshape((stg.freq[i].shape[0], -1)) + ) + stg.depth.append(np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + )) + stg.BS_raw_data.append( + np_f64_parse(BS_raw_data).reshape( + ( + stg.freq[i].shape[0], + stg.depth[i].shape[1], + stg.time[i].shape[1] + ) + ) + ) + stg.time_reshape.append( + np_f64_parse(time_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + stg.depth_reshape.append( + np_f64_parse(depth_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + stg.BS_raw_data_reshape.append( + np_f64_parse(BS_raw_data_reshape).reshape( + (-1, stg.freq[i].shape[0]) + ) + ) + + def read_table_BS_raw_data_cross_section(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time_cross_section", + "depth_cross_section", + "BS_cross_section", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.time_cross_section.append(np.array([])) + stg.depth_cross_section.append(np.array([])) + stg.BS_cross_section.append(np.array([])) + else: + stg.time_cross_section.append( + np_f64_parse(time).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.depth_cross_section.append( + np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + + stg.BS_cross_section.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_cross_section[i].shape[1], + stg.time_cross_section[i].shape[1] + ) + ) + ) + + def read_table_BS_raw_data_bed(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "BS_stream_bed", + "depth_bottom", "val_bottom", "ind_bottom", + ] + ) + )[0] + + it = iter(data) + + BS = np_f64_parse(next(it)) + depth = np_f64_parse(next(it)) + val = np_f64_parse(next(it)) + ind = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.BS_stream_bed.append(np.array([])) + else: + stg.BS_stream_bed.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_cross_section[i].shape[1], + stg.time_cross_section[i].shape[1] + ) + ) + ) + + if len(depth) == 0: + stg.depth_bottom.append(np.array([])) + stg.val_bottom.append([]) + stg.ind_bottom.append([]) + else: + stg.depth_bottom.append(depth) + stg.val_bottom.append(val.tolist()) + stg.ind_bottom.append(ind.tolist()) + + def read_table_BS_raw_data_noise(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "time_noise", "depth_noise", "BS_noise_raw_data", + ] + ) + )[0] + + it = iter(data) + + time = next(it) + depth = next(it) + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + stg.time_noise.append(np.array([])) + stg.depth_noise.append(np.array([])) + stg.BS_noise_raw_data.append(np.array([])) + else: + stg.time_noise.append( + np_f64_parse(time).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.depth_noise.append( + np_f64_parse(depth).reshape( + (stg.freq[i].shape[0], -1) + ) + ) + stg.BS_noise_raw_data.append( + BS.reshape( + ( + stg.freq[i].shape[0], + stg.depth_noise[i].shape[1], + stg.time_noise[i].shape[1] + ) + ) + ) + + def read_table_BS_raw_data_SNR(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "SNR_raw_data", "SNR_cross_section", "SNR_stream_bed", + ] + ) + )[0] + + it = iter(data) + + SNR_vars = [ + (stg.SNR_raw_data, stg.BS_raw_data), + (stg.SNR_cross_section, stg.BS_cross_section), + (stg.SNR_cross_section, stg.BS_stream_bed), + ] + + for dest, resh in SNR_vars: + SNR = np_f64_parse(next(it)) + + if len(SNR) == 0: + dest.append(np.array([])) else: - print("Je suis ici") - print(stg.freq[j].shape) - print(np.frombuffer(data2[0][7], dtype=np.float64).shape) - stg.time_cross_section.append(np.frombuffer(data2[0][7], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("time cross section ", stg.time_cross_section, stg.time_cross_section[j].shape) - stg.depth_cross_section.append(np.frombuffer(data2[0][8], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print("depth cross section ", stg.depth_cross_section, stg.depth_cross_section[j].shape) - stg.BS_cross_section.append(np.frombuffer(data2[0][9], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_cross_section[j].shape[1], stg.time_cross_section[j].shape[1]))) + dest.append(SNR.reshape(resh[i].shape)) - if len(np.frombuffer(data2[0][10], dtype=np.float64)) == 0: - stg.BS_stream_bed.append(np.array([])) + + def read_table_BS_raw_data_rest(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query( + [ + "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", + ] + ) + )[0] + + BS_vars = [ + (stg.BS_raw_data_pre_process_SNR, stg.BS_raw_data), + (stg.BS_raw_data_pre_process_average, stg.BS_raw_data), + (stg.BS_cross_section_pre_process_SNR, stg.BS_cross_section), + (stg.BS_cross_section_pre_process_average, stg.BS_cross_section), + (stg.BS_stream_bed_pre_process_SNR, stg.BS_stream_bed), + (stg.BS_stream_bed_pre_process_average, stg.BS_stream_bed), + ] + + it = iter(data) + for dest, resh in BS_vars: + BS = np_f64_parse(next(it)) + + if len(BS) == 0: + dest.append(np.array([])) else: - stg.BS_stream_bed.append(np.frombuffer(data2[0][10], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_cross_section[j].shape[1], stg.time_cross_section[j].shape[1]))) + dest.append(BS.reshape(resh[i].shape)) - if len(np.frombuffer(data2[0][11], dtype=np.float64)) == 0: - stg.depth_bottom.append(np.array([])) - stg.val_bottom.append([]) - stg.ind_bottom.append([]) - else: - stg.depth_bottom.append(np.frombuffer(data2[0][11], dtype=np.float64)) - stg.val_bottom.append(np.frombuffer(data2[0][12], dtype=np.float64).tolist()) - stg.ind_bottom.append(np.frombuffer(data2[0][13], dtype=np.float64).tolist()) - print("stg.depth_bottom ", stg.depth_bottom) - print("stg.val_bottom ", stg.val_bottom) - print("stg.ind_bottom ", stg.ind_bottom) + def read_table_BS_raw_data_mean(self, query, i): + np_f64_parse = lambda d: np.frombuffer(d, dtype=np.float64) + data = self.execute( + query(["BS_mean"]) + )[0] - if len(np.frombuffer(data2[0][14], dtype=np.float64)) == 0: - stg.time_noise.append(np.array([])) - stg.depth_noise.append(np.array([])) - stg.BS_noise_raw_data.append(np.array([])) - else: - stg.time_noise.append(np.frombuffer(data2[0][14], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - stg.depth_noise.append(np.frombuffer(data2[0][15], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - stg.BS_noise_raw_data.append(np.frombuffer(data2[0][16], dtype=np.float64).reshape( - (stg.freq[j].shape[0], stg.depth_noise[j].shape[1], stg.time_noise[j].shape[1]))) + BS = np_f64_parse(data[0]) - if len(np.frombuffer(data2[0][17], dtype=np.float64)) == 0: - stg.SNR_raw_data.append(np.array([])) - else: - stg.SNR_raw_data.append(np.frombuffer(data2[0][17], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][18], dtype=np.float64)) == 0: - stg.SNR_cross_section.append(np.array([])) - else: - stg.SNR_cross_section.append(np.frombuffer(data2[0][18], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][19], dtype=np.float64)) == 0: - stg.SNR_stream_bed.append(np.array([])) - else: - stg.SNR_stream_bed.append(np.frombuffer(data2[0][19], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][20], dtype=np.float64)) == 0: - stg.BS_raw_data_pre_process_SNR.append(np.array([])) - else: - stg.BS_raw_data_pre_process_SNR.append(np.frombuffer(data2[0][20], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][21], dtype=np.float64)) == 0: - stg.BS_raw_data_pre_process_average.append(np.array([])) - else: - stg.BS_raw_data_pre_process_average.append(np.frombuffer(data2[0][21], dtype=np.float64).reshape(stg.BS_raw_data[j].shape)) - - if len(np.frombuffer(data2[0][22], dtype=np.float64)) == 0: - stg.BS_cross_section_pre_process_SNR.append(np.array([])) - else: - stg.BS_cross_section_pre_process_SNR.append(np.frombuffer(data2[0][22], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][23], dtype=np.float64)) == 0: - stg.BS_cross_section_pre_process_average.append(np.array([])) - else: - stg.BS_cross_section_pre_process_average.append(np.frombuffer(data2[0][23], dtype=np.float64).reshape(stg.BS_cross_section[j].shape)) - - if len(np.frombuffer(data2[0][24], dtype=np.float64)) == 0: - stg.BS_stream_bed_pre_process_SNR.append(np.array([])) - else: - stg.BS_stream_bed_pre_process_SNR.append(np.frombuffer(data2[0][24], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][25], dtype=np.float64)) == 0: - stg.BS_stream_bed_pre_process_average.append(np.array([])) - else: - stg.BS_stream_bed_pre_process_average.append(np.frombuffer(data2[0][25], dtype=np.float64).reshape(stg.BS_stream_bed[j].shape)) - - if len(np.frombuffer(data2[0][26], dtype=np.float64)) == 0: - stg.BS_mean.append(np.array([])) - else: - stg.BS_mean.append(np.frombuffer(data2[0][26], dtype=np.float64).reshape((stg.freq[j].shape[0], -1))) - print(stg.BS_mean[j].shape) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++ - # --- Table Settings --- - # +++++++++++++++++++++++ + if len(BS) == 0: + stg.BS_mean.append(np.array([])) + else: + stg.BS_mean.append( + BS.reshape( + (stg.freq[i].shape[0], -1) + ) + ) + def read_table_settings(self): for s in range(len(stg.acoustic_data)): query3 = f'''SELECT acoustic_data, temperature, tmin_index, tmin_value, tmax_index, tmax_value, @@ -290,7 +477,7 @@ class ReadTableForOpen: SNR_filter_value, Nb_cells_to_average_BS_signal FROM Settings WHERE (acoustic_data = {s})''' - data3 = cur.execute(query3).fetchall() + data3 = self.execute(query3) stg.temperature = [x[1] for x in data3][0] stg.tmin.append([(x[2], x[3]) for x in data3]) @@ -301,18 +488,14 @@ class ReadTableForOpen: stg.SNR_filter_value.append([x[12] for x in data3]) stg.Nb_cells_to_average_BS_signal.append([x[13] for x in data3]) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Sediment File --- - # +++++++++++++++++++++++++++ - + def read_table_sediment_file(self): query4 = f'''SELECT 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 from SedimentsFile''' - data4 = cur.execute(query4).fetchall() + data4 = self.execute(query4) print("data4 ", data4) @@ -329,18 +512,14 @@ class ReadTableForOpen: print(stg.radius_grain_fine, stg.radius_grain_sand) print('stg.columns_fine ', stg.columns_fine) - # -------------------------------------------------------------------------------------------------------------- - # +++++++++++++++++++++++++++ - # --- Table Sediment Data --- - # +++++++++++++++++++++++++++ - + def read_table_table_sediment_data(self): query5 = f'''SELECT 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 from SedimentsData''' - data5 = cur.execute(query5).fetchall() + data5 = self.execute(query5) stg.frac_vol_fine = [] stg.frac_vol_fine_cumul = [] @@ -378,15 +557,6 @@ class ReadTableForOpen: print(stg.Ctot_fine, stg.sample_sand) print(type(stg.frac_vol_fine_cumul), stg.frac_vol_fine_cumul) - - # Close database cursor - cur.close() - - # Close database connection - cnx.close() - - print("read table finished") - def fill_acoustic_data_tab(self): print("start fill acoustic data tab")