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

Compare commits

base: parouby:b7ae9dfe692256eb59b4770c52f871604abdb846
Branches Tags
parouby:dev-bjvincent-fix-UBSediFlow
parouby:dev-bjvincent
parouby:dev
parouby:fix-save-load
parouby:main
parouby:dev-parouby
parouby:dev-brahim
parouby:v2.2
parouby:v2.1
...
compare: parouby:f872b625c2dcb5a4dae83cafe9f77387389d64ed
Branches Tags
parouby:dev-bjvincent-fix-UBSediFlow
parouby:dev-bjvincent
parouby:dev
parouby:fix-save-load
parouby:main
parouby:dev-parouby
parouby:dev-brahim
parouby:v2.2
parouby:v2.1

3 Commits
b7ae9dfe69 ... f872b625c2

Author SHA1 Message Date
Pierre-Antoine f872b625c2 SQL: Minor change. 2025-03-10 17:14:11 +01:00
Pierre-Antoine 87098ff152 SQL: Some refactoring. 2025-03-10 17:12:45 +01:00
Pierre-Antoine f5eb9a18c6 SQL: Fix empty/partiel study save #12. 2025-03-10 17:04:31 +01:00
1 changed files with 404 additions and 292 deletions
Show Stats Expand all files Collapse all files

696
Model/create_table_for_save_as.py
View File

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