parouby
/
acoused
mirror of https://forgemia.inra.fr/theophile.terraz/acoused
1
0
Fork 0
Code Issues Packages Projects Releases Activity

Model: Start simple refactoring read table.

dev-brahim
Pierre-Antoine 2025-03-20 17:43:14 +01:00
parent 5d3ae961b2
commit 680f18b741
1 changed files with 360 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

550
Model/read_table_for_open.py
View File

@ -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")