diff --git a/View/acoustic_inversion_tab.py b/View/acoustic_inversion_tab.py index 5a04c6c..38bc3e5 100644 --- a/View/acoustic_inversion_tab.py +++ b/View/acoustic_inversion_tab.py @@ -1,53 +1,54 @@ -import sys +# ============================================================================== # + # acoustic_inversion.py - AcouSed # + # Copyright (C) 2024 INRAE # + # # + # This program is free software: you can redistribute it and/or modify # + # it under the terms of the GNU General Public License as published by # + # the Free Software Foundation, either version 3 of the License, or # + # (at your option) any later version. # + # # + # This program is distributed in the hope that it will be useful, # + # but WITHOUT ANY WARRANTY; without even the implied warranty of # + # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # + # GNU General Public License for more details. # + # # + # You should have received a copy of the GNU General Public License # + # along with this program. If not, see . # + + # by Brahim MOUDJED # +# ============================================================================== # + +# -*- coding: utf-8 -*- + import pandas as pd -from PyQt5.QtWidgets import (QWidget, QMainWindow, QApplication, QVBoxLayout, QHBoxLayout, QGroupBox, QComboBox, - QGridLayout, QLabel, QPushButton, QSpinBox, QDoubleSpinBox, QAbstractSpinBox, QSpacerItem, - QSizePolicy, QSlider, QLineEdit, QMessageBox, QFileDialog) +from PyQt5.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QComboBox, + QLabel, QPushButton, QSpacerItem, + QSlider, QLineEdit, QMessageBox, QFileDialog) -from PyQt5.QtCore import QCoreApplication, Qt, pyqtSignal -from PyQt5.QtGui import QStandardItemModel, QIcon, QPixmap +from PyQt5.QtCore import QCoreApplication, Qt +from PyQt5.QtGui import QIcon, QPixmap import numpy as np -from itertools import combinations - import matplotlib.pyplot as plt -from matplotlib.colors import LogNorm, BoundaryNorm, CSS4_COLORS +from matplotlib.colors import LogNorm from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolBar -from os import path, chdir -import datetime - -from scipy import stats +from os import chdir from copy import deepcopy -import Translation.constant_string as cs - from View.checkable_combobox import CheckableComboBox import settings as stg -from View.show_popup_combobox import ComboBoxShowPopUpWindow - from Model.acoustic_inversion_method_high_concentration import AcousticInversionMethodHighConcentration -from settings import SSC_fine _translate = QCoreApplication.translate -def deleteItemsOfLayout(layout): - if layout is not None: - while layout.count(): - item = layout.takeAt(0) - widget = item.widget() - if widget is not None: - widget.setParent(None) - else: - deleteItemsOfLayout(item.layout()) - class AcousticInversionTab(QWidget): @@ -111,12 +112,10 @@ class AcousticInversionTab(QWidget): self.horizontalLayoutTop.addWidget(self.groupbox_plot_SSC_fine, 6) self.groupbox_plot_SSC_fine_vertical_profile = QGroupBox() - # self.horizontalLayoutTop.addWidget(self.groupbox_plot_SSC_fine_vertical_profile, 3) self.verticalLayout_groupbox_plot_SSC_fine_profile_and_slider = QVBoxLayout() self.horizontalLayoutTop.addLayout(self.verticalLayout_groupbox_plot_SSC_fine_profile_and_slider, 3) self.groupbox_plot_measured_vs_inverted_SSC_fine = QGroupBox() - # self.horizontalLayoutTop.addWidget(self.groupbox_plot_measured_vs_inverted_SSC_fine, 3) self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine_and_combobox = QVBoxLayout() self.horizontalLayoutTop.addLayout(self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine_and_combobox, 3) @@ -128,12 +127,10 @@ class AcousticInversionTab(QWidget): self.horizontalLayoutBottom.addWidget(self.groupbox_plot_SSC_sand, 6) self.groupbox_plot_SSC_sand_vertical_profile = QGroupBox() - # self.horizontalLayoutBottom.addWidget(self.groupbox_plot_SSC_sand_vertical_profile, 3) self.verticalLayout_groupbox_plot_SSC_sand_profile_and_slider = QVBoxLayout() self.horizontalLayoutBottom.addLayout(self.verticalLayout_groupbox_plot_SSC_sand_profile_and_slider, 3) self.groupbox_plot_measured_vs_inverted_SSC_sand = QGroupBox() - # self.horizontalLayoutBottom.addWidget(self.groupbox_plot_measured_vs_inverted_SSC_sand, 3) self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_sand_and_combobox = QVBoxLayout() self.horizontalLayoutBottom.addLayout(self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_sand_and_combobox, 3) @@ -171,7 +168,6 @@ class AcousticInversionTab(QWidget): self.verticalLayout_groupbox_plot_vertical_profile_fine.addWidget(self.canvas_profile_fine) self.horizontalLayout_slider_fine = QHBoxLayout() - # self.verticalLayout_groupbox_plot_vertical_profile_fine.addLayout(self.horizontalLayout_slider_fine) self.verticalLayout_groupbox_plot_SSC_fine_profile_and_slider.addLayout(self.horizontalLayout_slider_fine) self.pushbutton_left_to_begin_fine = QPushButton() @@ -222,8 +218,6 @@ class AcousticInversionTab(QWidget): self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine.addWidget(self.canvas_inverted_vs_measured_SSC_fine) self.horizontalLayout_combobox_fine_sample_choice = QHBoxLayout() - # self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine.addLayout( - # self.horizontalLayout_combobox_fine_sample_choice) self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine_and_combobox.addLayout( self.horizontalLayout_combobox_fine_sample_choice) @@ -274,7 +268,6 @@ class AcousticInversionTab(QWidget): self.verticalLayout_groupbox_plot_vertical_profile_sand.addWidget(self.canvas_profile_sand) self.horizontalLayout_slider_sand = QHBoxLayout() - # self.verticalLayout_groupbox_plot_vertical_profile_sand.addLayout(self.horizontalLayout_slider_sand) self.verticalLayout_groupbox_plot_SSC_sand_profile_and_slider.addLayout(self.horizontalLayout_slider_sand) self.pushbutton_left_to_begin_sand = QPushButton() @@ -327,8 +320,6 @@ class AcousticInversionTab(QWidget): self.canvas_inverted_vs_measured_SSC_sand) self.horizontalLayout_combobox_sand_sample_choice = QHBoxLayout() - # self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_sand.addLayout( - # self.horizontalLayout_combobox_sand_sample_choice) self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_sand_and_combobox.addLayout( self.horizontalLayout_combobox_sand_sample_choice) @@ -378,10 +369,8 @@ class AcousticInversionTab(QWidget): # ================================================================================================================== def update_acoustic_data_choice(self): - print("(stg.filename_BS_noise_data ", (stg.filename_BS_noise_data)) self.combobox_acoustic_data_choice.clear() - # self.combobox_fileListWidget.addItem("") for i in range(len(stg.filename_BS_raw_data)): self.combobox_acoustic_data_choice.addItem(stg.data_preprocessed[i]) @@ -428,16 +417,6 @@ class AcousticInversionTab(QWidget): def compute_VBI(self): stg.VBI_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - print("compute VBI") - print(stg.frequencies_for_calibration[0][0], - stg.frequencies_for_calibration[1][0]) - print(stg.frequency_for_inversion) - print(stg.zeta[0], stg.zeta[1]) - print(stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][0].shape, - stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][1].shape) - print(stg.depth_2D[self.combobox_acoustic_data_choice.currentIndex()].shape) - print(stg.alpha_s[0], stg.alpha_s[1]) - print(stg.X_exponent[0]) stg.VBI_cross_section[self.combobox_acoustic_data_choice.currentIndex()] = self.inv_hc.VBI_cross_section( freq1=stg.frequencies_for_calibration[0][0], @@ -451,24 +430,9 @@ class AcousticInversionTab(QWidget): X=stg.X_exponent[0] ) - print("compute VBI end") - def compute_SSC_fine(self): stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - print("Compute SSC fine - start") - print(stg.zeta[1]) - print(stg.depth_2D[self.combobox_acoustic_data_choice.currentIndex()][ - stg.frequency_for_inversion[1]].shape) - # print(stg.VBI_cross_section.shape) - print(stg.frequencies_for_calibration[1][0]) - print(stg.X_exponent[0]) - print(stg.J_cross_section[self.combobox_acoustic_data_choice.currentIndex()][1].shape) - print(stg.water_attenuation) - print(np.full(shape=stg.depth_2D[self.combobox_acoustic_data_choice.currentIndex()][ - stg.frequency_for_inversion[1]].shape, - fill_value=stg.water_attenuation[self.combobox_acoustic_data_choice.currentIndex()][ - stg.frequency_for_inversion[1]])) stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()] = self.inv_hc.SSC_fine( zeta=stg.zeta[1], @@ -484,27 +448,16 @@ class AcousticInversionTab(QWidget): stg.frequency_for_inversion[1]]) ) - print("stg.SSC_fine ", stg.SSC_fine) - print("stg.SSC_fine shape ", stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()].shape) - def compute_SSC_sand(self): stg.SSC_sand[self.combobox_acoustic_data_choice.currentIndex()] = np.array([]) - print("+++++++++++++++++++++") - print(stg.VBI_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape) - print(stg.frequencies_for_calibration[1][0]) - print(stg.X_exponent) - print(stg.ks[1]) - print("+++++++++++++++++++++") + stg.SSC_sand[self.combobox_acoustic_data_choice.currentIndex()] = self.inv_hc.SSC_sand( VBI=stg.VBI_cross_section[self.combobox_acoustic_data_choice.currentIndex()], freq=stg.frequencies_for_calibration[1][0], X=stg.X_exponent, ks=stg.ks[1]) - print("stg.SSC_sand ", stg.SSC_sand) - print("stg.SSC_sand shape ", stg.SSC_sand[self.combobox_acoustic_data_choice.currentIndex()].shape) - def plot_SSC_fine(self): if self.combobox_acoustic_data_choice.count() > 0: @@ -535,17 +488,8 @@ class AcousticInversionTab(QWidget): val_min = np.nanmin(stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()]) val_max = np.nanmax(stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()]) - # if stg.ABS_name[0] == "Aquascat 1000R": - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - - # print("time cross section ", stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1]]) - # print("depth cross section ", stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1]]) - # print(stg.frequency_for_inversion[1]) - pcm_SSC_fine = self.axis_SSC_fine.pcolormesh( stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ stg.frequency_for_inversion[1]], @@ -570,24 +514,6 @@ class AcousticInversionTab(QWidget): stg.frequency_for_inversion[1]], linestyle="solid", color='r', linewidth=2) - # print("o+o+o+o+o+o") - # print(stg.frequency_for_inversion[1]) - # print([i for i, _ in stg.fine_sample_position]) - # # print([stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # # stg.frequency_for_inversion[1], i] - # # for i, _ in stg.fine_sample_position]) - # print("o+o+o+o+o+o") - - # self.pcm_SSC_fine_meas_vs_inv, = self.axis_SSC_fine.plot( - # [stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], i] - # for i, _ in stg.fine_sample_position], - # [-stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], j] - # for _, j in stg.fine_sample_position], - # ls=" ", marker="o", ms=5, mec="k", mfc="k") - - else: pcm_SSC_fine = self.axis_SSC_fine.pcolormesh( @@ -618,26 +544,19 @@ class AcousticInversionTab(QWidget): # --- Plot samples of fine sediments --- time_fine_temp = deepcopy(stg.time_fine) depth_fine_temp = deepcopy(stg.depth_fine) - print("0 time_fine_temp, depth_fine_temp, ", time_fine_temp, depth_fine_temp) for s in stg.fine_sample_profile: - print("s = ", s) - print(stg.time_fine[s[1]]) - print(stg.depth_fine[s[1]]) time_fine_temp.remove(stg.time_fine[s[1]]) depth_fine_temp.remove(stg.depth_fine[s[1]]) - print("1 time_fine_temp, depth_fine_temp, ", time_fine_temp, depth_fine_temp) self.pcm_SSC_fine_meas_vs_inv, = self.axis_SSC_fine.plot( time_fine_temp, depth_fine_temp, ls=" ", marker="o", ms=5, mec="k", mfc="k") time_fine_temp = deepcopy(stg.time_fine) depth_fine_temp = deepcopy(stg.depth_fine) sample_fine_temp = deepcopy(stg.sample_fine) - print("0 sample_fine_temp ", sample_fine_temp) for s in stg.fine_sample_profile: sample_fine_temp.remove(s) time_fine_temp.remove(stg.time_fine[s[1]]) depth_fine_temp.remove(stg.depth_fine[s[1]]) - print("1 sample_fine_temp ", sample_fine_temp) for i in range(len(sample_fine_temp)): self.pcm_SSC_fine_meas_vs_inv_text = self.axis_SSC_fine.text( time_fine_temp[i], @@ -654,27 +573,10 @@ class AcousticInversionTab(QWidget): self.pcm_SSC_fine_meas_vs_inv_sample_calibration_text = self.axis_SSC_fine.text( time_fine_temp[j]+5, depth_fine_temp[j]+0.05, i, color='r', fontweight='bold') - # self.pcm_SSC_fine_meas_vs_inv, = self.axis_SSC_fine.plot( - # [stg.time[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], i] - # for i, _ in stg.fine_sample_position], - # [-stg.depth[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], j] - # for _, j in stg.fine_sample_position], - # ls=" ", marker="o", ms=5, mec="k", mfc="k") - cbar_SSC_fine = self.figure_SSC_fine.colorbar(pcm_SSC_fine, ax=self.axis_SSC_fine, shrink=1, location='right') cbar_SSC_fine.set_label(label='Fine SSC (g/L', rotation=270, labelpad=15) - # elif stg.ABS_name[0] == "UB-SediFlow": - # pcm_SSC_fine = self.axis_SSC_fine.pcolormesh(stg.t[0, :], - # -stg.r[0, :], - # stg.SSC_fine, - # cmap='rainbow', - # norm=LogNorm(vmin=1e-2, vmax=10), - # shading='gouraud') - self.figure_SSC_fine.supxlabel("Time (sec)", fontsize=10) self.figure_SSC_fine.supylabel("Depth (m)", fontsize=10) self.figure_SSC_fine.canvas.draw_idle() @@ -757,8 +659,6 @@ class AcousticInversionTab(QWidget): -np.nanmin(stg.depth[self.combobox_acoustic_data_choice.currentIndex()][ stg.frequency_for_inversion[1]])]) - # self.axis_SSC_fine.plot([], [], ) - self.axis_vertical_profile_SSC_fine.set_xlim(0, 10) self.axis_vertical_profile_SSC_fine.set_xlabel("Inverted Fine SSC (g/L)") self.axis_vertical_profile_SSC_fine.set_ylabel("Depth (m)") @@ -798,7 +698,7 @@ class AcousticInversionTab(QWidget): stg.frequency_for_inversion[1]])]) else: - + self.axis_vertical_profile_SSC_fine.plot( stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()][:, self.slider_fine.value() - 1], @@ -921,17 +821,12 @@ class AcousticInversionTab(QWidget): def fill_combobox_fine_sample(self): - print("stg.sample_fine ", stg.sample_fine) self.combobox_fine_sample_choice.addItems([f for f, _ in stg.sample_fine]) # --- Get position (index, value) of sample in acoustic measurement space --- if ((stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): - print(stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - stg.frequency_for_inversion[1]]) - print(stg.depth_fine) - for j in range(len(stg.time_fine)): (stg.fine_sample_position. @@ -957,8 +852,6 @@ class AcousticInversionTab(QWidget): ) ) - print("0 stg.fine_sample_position ", stg.fine_sample_position) - elif ((stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -987,8 +880,6 @@ class AcousticInversionTab(QWidget): ) ) - print("1 stg.fine_sample_position ", stg.fine_sample_position) - elif ((stg.time[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -1017,8 +908,6 @@ class AcousticInversionTab(QWidget): ) ) - print("2 stg.fine_sample_position ", stg.fine_sample_position) - elif ((stg.time[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -1047,8 +936,6 @@ class AcousticInversionTab(QWidget): ) ) - print("3 stg.fine_sample_position ", stg.fine_sample_position) - def plot_measured_vs_inverted_SSC_fine(self): if self.combobox_acoustic_data_choice.count() > 0: @@ -1078,20 +965,7 @@ class AcousticInversionTab(QWidget): self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine.addWidget(self.toolbar_inverted_vs_measured_SSC_fine) self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_fine.addWidget(self.canvas_inverted_vs_measured_SSC_fine) - print("self.combobox_fine_sample_choice.currentData() ", self.combobox_fine_sample_choice.currentData()) - print("self.combobox_fine_sample_choice.currentIndex() ", self.combobox_fine_sample_choice.currentIndex()) - - print("///////////////////////////////////////////////////") self.fine_sample_to_plot = [int(f[1:]) - 1 for f in self.combobox_fine_sample_choice.currentData()] - print("self.fine_sample_to_plot ", self.fine_sample_to_plot) - - # for k in self.fine_sample_to_plot: - # print("stg.Ctot_fine[k] ", stg.Ctot_fine[k]) - # print(stg.fine_sample_position[k][1]) - # print(stg.fine_sample_position[k][0]) - # print(stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.fine_sample_position[k][1], - # stg.fine_sample_position[k][0]]) if self.fine_sample_to_plot: @@ -1220,16 +1094,8 @@ class AcousticInversionTab(QWidget): val_min = np.nanmin(stg.SSC_sand[self.combobox_acoustic_data_choice.currentIndex()]) val_max = np.nanmax(stg.SSC_sand[self.combobox_acoustic_data_choice.currentIndex()]) - # if stg.ABS_name[0] == "Aquascat 1000R": - if stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,): - # print("time cross section ", stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1]]) - # print("depth cross section ", stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1]]) - # print(stg.frequency_for_inversion[1]) - pcm_SSC_sand = self.axis_SSC_sand.pcolormesh( stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ stg.frequency_for_inversion[1]], @@ -1255,35 +1121,9 @@ class AcousticInversionTab(QWidget): stg.frequency_for_inversion[1]], linestyle="solid", color='r', linewidth=2) - print("o+o+o+o+o+o") - print(stg.frequency_for_inversion[1]) - print([i for i, _ in stg.sand_sample_position]) - # print([stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], i] - # for i, _ in stg.fine_sample_position]) - print("o+o+o+o+o+o") - - # self.pcm_SSC_fine_meas_vs_inv, = self.axis_SSC_fine.plot( - # [stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], i] - # for i, _ in stg.fine_sample_position], - # [-stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], j] - # for _, j in stg.fine_sample_position], - # ls=" ", marker="o", ms=5, mec="k", mfc="k") - self.pcm_SSC_sand_meas_vs_inv, = self.axis_SSC_sand.plot(stg.time_sand, stg.depth_sand, ls=" ", marker="o", ms=5, mec="k", mfc="k") - # print(stg.time_sand) - # print(stg.depth_sand) - # print([f for _, f in stg.sample_sand]) - # for i, j in stg.sample_sand: - # self.pcm_SSC_sand_meas_vs_inv_text = self.axis_SSC_sand.text( - # stg.time_sand[j], - # stg.depth_sand[j], - # i) - else: pcm_SSC_sand = self.axis_SSC_sand.pcolormesh( @@ -1311,41 +1151,26 @@ class AcousticInversionTab(QWidget): stg.frequency_for_inversion[1]], linestyle="solid", color='r', linewidth=2) - # self.pcm_SSC_sand_meas_vs_inv, = self.axis_SSC_sand.plot( - # [stg.time[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], i] - # for i, _ in stg.sand_sample_position], - # [-stg.depth[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.frequency_for_inversion[1], j] - # for _, j in stg.sand_sample_position], - # ls=" ", marker="o", ms=5, mec="k", mfc="k") - self.pcm_SSC_sand_meas_vs_inv, = self.axis_SSC_sand.plot(stg.time_sand, stg.depth_sand, ls=" ", marker="o", ms=5, mec="k", mfc="k") # --- Plot samples of fine sediments --- time_sand_temp = deepcopy(stg.time_sand) depth_sand_temp = deepcopy(stg.depth_sand) - print("0 time_sand_temp, depth_sand_temp, ", time_sand_temp, depth_sand_temp) for s in stg.sand_sample_target: - print("s = ", s) - print(stg.time_sand[s[1]]) - print(stg.depth_sand[s[1]]) + time_sand_temp.remove(stg.time_sand[s[1]]) depth_sand_temp.remove(stg.depth_sand[s[1]]) - print("1 time_sand_temp, depth_sand_temp, ", time_sand_temp, depth_sand_temp) self.pcm_SSC_sand_meas_vs_inv, = self.axis_SSC_sand.plot( time_sand_temp, depth_sand_temp, ls=" ", marker="o", ms=5, mec="k", mfc="k") time_sand_temp = deepcopy(stg.time_sand) depth_sand_temp = deepcopy(stg.depth_sand) sample_sand_temp = deepcopy(stg.sample_sand) - print("0 sample_sand_temp ", sample_sand_temp) for s in stg.sand_sample_target: sample_sand_temp.remove(s) time_sand_temp.remove(stg.time_sand[s[1]]) depth_sand_temp.remove(stg.depth_sand[s[1]]) - print("1 sample_sand_temp ", sample_sand_temp) for i in range(len(sample_sand_temp)): self.pcm_SSC_sand_meas_vs_inv_text = self.axis_SSC_sand.text( time_sand_temp[i], @@ -1366,14 +1191,6 @@ class AcousticInversionTab(QWidget): location='right') cbar_SSC_sand.set_label(label='Sand SSC (g/L', rotation=270, labelpad=15) - # elif stg.ABS_name[0] == "UB-SediFlow": - # pcm_SSC_sand = self.axis_SSC_sand.pcolormesh(stg.t[0, :], - # -stg.r[0, :], - # stg.SSC_sand, - # cmap='rainbow', - # norm=LogNorm(vmin=1e-2, vmax=10), - # shading='gouraud') - self.figure_SSC_sand.supxlabel("Time (sec)", fontsize=10) self.figure_SSC_sand.supylabel("Depth (m)", fontsize=10) self.figure_SSC_sand.canvas.draw_idle() @@ -1624,17 +1441,12 @@ class AcousticInversionTab(QWidget): def fill_combobox_sand_sample(self): - print("stg.sample_sand ", stg.sample_sand) self.combobox_sand_sample_choice.addItems([f for f, _ in stg.sample_sand]) # --- Get position (index, value) of sample in acoustic measurement space --- if ((stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): - print(stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()][ - stg.frequency_for_inversion[1]]) - print(stg.depth_fine) - for j in range(len(stg.time_sand)): (stg.sand_sample_position. @@ -1660,8 +1472,6 @@ class AcousticInversionTab(QWidget): ) ) - print("0 stg.sand_sample_position ", stg.sand_sample_position) - elif ((stg.time_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -1690,8 +1500,6 @@ class AcousticInversionTab(QWidget): ) ) - print("1 stg.sand_sample_position ", stg.sand_sample_position) - elif ((stg.time[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth_cross_section[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -1720,8 +1528,6 @@ class AcousticInversionTab(QWidget): ) ) - print("2 stg.sand_sample_position ", stg.sand_sample_position) - elif ((stg.time[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,)) and (stg.depth[self.combobox_acoustic_data_choice.currentIndex()].shape != (0,))): @@ -1750,8 +1556,6 @@ class AcousticInversionTab(QWidget): ) ) - print("3 stg.sand_sample_position ", stg.sand_sample_position) - def plot_measured_vs_inverted_SSC_sand(self): if self.combobox_acoustic_data_choice.count() > 0: @@ -1790,20 +1594,7 @@ class AcousticInversionTab(QWidget): self.verticalLayout_groupbox_plot_measured_vs_inverted_SSC_sand.addWidget( self.canvas_inverted_vs_measured_SSC_sand) - print("self.combobox_sand_sample_choice.currentData() ", self.combobox_sand_sample_choice.currentData()) - print("self.combobox_sand_sample_choice.currentIndex() ", self.combobox_sand_sample_choice.currentIndex()) - - print("///////////////////////////////////////////////////") self.sand_sample_to_plot = [int(f[1:]) - 1 for f in self.combobox_sand_sample_choice.currentData()] - print("self.sand_sample_to_plot ", self.sand_sample_to_plot) - - # for k in self.fine_sample_to_plot: - # print("stg.Ctot_fine[k] ", stg.Ctot_fine[k]) - # print(stg.fine_sample_position[k][1]) - # print(stg.fine_sample_position[k][0]) - # print(stg.SSC_fine[self.combobox_acoustic_data_choice.currentIndex()][ - # stg.fine_sample_position[k][1], - # stg.fine_sample_position[k][0]]) if self.sand_sample_to_plot: @@ -1879,7 +1670,6 @@ class AcousticInversionTab(QWidget): self.figure_measured_vs_inverted_sand.canvas.draw_idle() - def save_result_in_excel_file(self): if self.combobox_acoustic_data_choice.count() > 0: @@ -1962,9 +1752,6 @@ class AcousticInversionTab(QWidget): if stg.SSC_sand[k].shape == (0,): stg.SSC_sand[k] = np.zeros(r.shape[0]) - - print("<<<<<<<<<<<<<<<<<<<<<<<<<") - print(t.shape, r.shape, stg.SSC_fine[k].shape, stg.SSC_sand[k].shape) exec("result_" + str(k) + "= pd.DataFrame({'Time (sec)': t," + "'Depth (m)': r," + "'SSC_fine (g/L)': stg.SSC_fine[" + str(k) + "].reshape(t.shape[0])," + @@ -1973,1774 +1760,7 @@ class AcousticInversionTab(QWidget): with pd.ExcelWriter(dirname + filename + '.xlsx') as writer: - print("writer ", writer) for k in range(self.combobox_acoustic_data_choice.count()): eval("result_" + str(k) + ".to_excel(writer, index=False, " + "engine='xlsxwriter', na_rep='NA', " + "sheet_name=stg.data_preprocessed[" + str(k) + "])") - # result.to_excel(excel_writer=filename + '.xlsx', index=False, engine='xlsxwriter', na_rep='NA', - # sheet_name=stg.data_preprocessed[k]) - - # except ValueError as e: - # print("error = ", e) - # msgBox = QMessageBox() - # msgBox.setWindowTitle("Save Inversion Result Error") - # msgBox.setIcon(QMessageBox.Warning) - # msgBox.setText("No saved file") - # msgBox.setStandardButtons(QMessageBox.Ok) - # msgBox.exec() - - # -------------------------------------------------------------------------------------------------------------- - - # ______ _______ - # | | | | \ - # | | | | \ - # | | | | | - # | | | | / - # |______| |________ |________/ - - # COMMENT OLD CODE LINE FROM HERE ... - -# ### --- Layout of groupbox in the Top horizontal layout box -# -# # Acoustic inversion Options | Acoustic inversion method Settings parameter -# -# self.groupbox_acoustic_inversion_options = QGroupBox() -# self.horizontalLayoutTop.addWidget(self.groupbox_acoustic_inversion_options, 3) -# -# self.groupbox_acoustic_inversion_settings_parameter = QGroupBox() -# self.horizontalLayoutTop.addWidget(self.groupbox_acoustic_inversion_settings_parameter, 7) -# -# ### --- Layout of groupbox in the Bottom horizontal layout box -# -# # Plot SSC 2D field | Plot SSC graph sample vs inversion -# -# self.groupbox_SSC_2D_field = QGroupBox() -# self.horizontalLayoutBottom.addWidget(self.groupbox_SSC_2D_field, 6) -# -# self.groupbox_SSC_profiles_or_measured_vs_inverted = QGroupBox() -# self.horizontalLayoutBottom.addWidget(self.groupbox_SSC_profiles_or_measured_vs_inverted, 4) -# -# # ===================================================== -# # TOP HORIZONTAL BOX LAYOUT -# # ===================================================== -# -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# # | Group box Acoustic inversion options | -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# -# self.gridLayout_groupbox_acoustic_inversion_options = QGridLayout(self.groupbox_acoustic_inversion_options) -# -# self.groupbox_acoustic_inversion_options.setTitle("Acoustic inversion option") -# -# self.label_acoustic_inversion_method_choice = QLabel() -# self.gridLayout_groupbox_acoustic_inversion_options.addWidget( -# self.label_acoustic_inversion_method_choice, 0, 0, 1, 1) -# self.label_acoustic_inversion_method_choice.setText("Acoustic inversion method : ") -# -# self.combobox_acoustic_inversion_method_choice = QComboBox() -# self.gridLayout_groupbox_acoustic_inversion_options.addWidget( -# self.combobox_acoustic_inversion_method_choice, 0, 1, 1, 1) -# self.combobox_acoustic_inversion_method_choice.addItems([" ", "Acoustic inversion method 1"]) -# self.combobox_acoustic_inversion_method_choice.currentIndexChanged.connect( -# self.acoustic_inversion_method_choice) -# # self.combobox_acoustic_inversion_method_choice.currentIndexChanged.connect(self.test) -# -# self.groupbox_calibration_samples = QGroupBox() -# self.groupbox_calibration_samples.setTitle("Sample choice for calibration") -# self.gridLayout_groupbox_acoustic_inversion_options.addWidget(self.groupbox_calibration_samples, 1, 0, 1, 2) -# -# self.gridLayout_groupbox_calibration_samples = QGridLayout(self.groupbox_calibration_samples) -# -# self.label_frequency = QLabel() -# self.label_frequency.setText("Frequency :") -# self.gridLayout_groupbox_calibration_samples.addWidget(self.label_frequency, 0, 0, 1, 1) -# -# self.combobox_frequency = QComboBox() -# self.gridLayout_groupbox_calibration_samples.addWidget(self.combobox_frequency, 0, 1, 1, 1) -# self.combobox_frequency.currentIndexChanged.connect(self.update_plot_transect_with_sample_position) -# -# self.label_sand_sample_choice = QLabel() -# self.label_sand_sample_choice.setText("Sand sediments :") -# self.gridLayout_groupbox_calibration_samples.addWidget(self.label_sand_sample_choice, 0, 2, 1, 1) -# -# self.combobox_calibration_sand_sample = CheckableComboBox() -# self.gridLayout_groupbox_calibration_samples.addWidget(self.combobox_calibration_sand_sample, 0, 3, 1, 1) -# # self.combobox_calibration_sand_sample.currentData.connect(self.update_plot_transect_with_sample_position) -# self.combobox_calibration_sand_sample.currentIndexChanged.connect( -# self.update_plot_transect_with_sample_position) -# # self.combobox_calibration_sand_sample.currentIndexChanged.connect(self.sample_choice) -# -# self.label_fine_sample_choice = QLabel() -# self.label_fine_sample_choice.setText("Fine sediments :") -# self.gridLayout_groupbox_calibration_samples.addWidget(self.label_fine_sample_choice, 0, 4, 1, 1) -# -# self.combobox_calibration_fine_sample = CheckableComboBox() -# self.gridLayout_groupbox_calibration_samples.addWidget(self.combobox_calibration_fine_sample, 0, 5, 1, 1) -# # self.combobox_calibration_fine_sample.currentData.connect(self.update_plot_transect_with_sample_position) -# self.combobox_calibration_fine_sample.currentIndexChanged.connect( -# self.update_plot_transect_with_sample_position) -# -# # self.combobox_calibration_fine_sample.currentIndexChanged.connect(self.sample_choice) -# -# self.groupbox_plot_sample_position_on_transect = QGroupBox() -# self.gridLayout_groupbox_calibration_samples.addWidget(self.groupbox_plot_sample_position_on_transect, 1, 0, 1, 6) -# self.verticalLayout_groupbox_plot_sample_position_on_transect = QVBoxLayout(self.groupbox_plot_sample_position_on_transect) -# -# self.canvas_plot_sample_position_on_transect = None -# # self.verticalLayout_groupbox_plot_sample_position_on_transect.addWidget(self.canvas_plot_sample_position_on_transect) -# -# -# # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -# # | Group box Acoustic inversion method settings parameter | -# # +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -# -# self.gridLayout_groupbox_acoustic_inversion_settings_parameter \ -# = QGridLayout(self.groupbox_acoustic_inversion_settings_parameter) -# -# self.groupbox_acoustic_inversion_settings_parameter.setTitle("Acoustic inversion method settings parameter") -# -# self.groupbox_parameter = QGroupBox() -# self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget(self.groupbox_parameter, 0, 0, 1, 2) -# -# self.gridLayout_groupbox_parameter = QGridLayout(self.groupbox_parameter) -# -# # self.label_temperature = QLabel() -# # self.label_temperature.setText("Temperature : ") -# # # self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget(self.label_temperature, 0, 0, 1, 1) -# # self.gridLayout_groupbox_parameter.addWidget(self.label_temperature, 0, 0, 1, 1) -# # self.spinbox_temperature = QDoubleSpinBox() -# # # self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget(self.spinbox_temperature, 0, 1, 1, 1) -# # self.gridLayout_groupbox_parameter.addWidget(self.spinbox_temperature, 0, 1, 1, 1) -# # self.spinbox_temperature.valueChanged.connect(self.temperature_value) -# -# self.label_frequencies_pairs_to_compute_VBI = QLabel() -# self.label_frequencies_pairs_to_compute_VBI.setText("Frequencies for VBI") -# self.gridLayout_groupbox_parameter.addWidget( -# self.label_frequencies_pairs_to_compute_VBI, 0, 1, 1, 1) -# -# # self.combobox_frequencies_VBI = QComboBox() -# # self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget( -# # self.combobox_frequencies_VBI, 1, 1, 1, 1) -# # self.combobox_frequencies_VBI.currentIndexChanged.connect(self.frequencies_pair_choice_to_compute_VBI) -# -# self.label_ks = QLabel() -# self.label_ks.setText("ks") -# self.gridLayout_groupbox_parameter.addWidget(self.label_ks, 0, 2, 1, 1) -# -# self.label_sv = QLabel() -# self.label_sv.setText("sv") -# self.gridLayout_groupbox_parameter.addWidget(self.label_sv, 0, 3, 1, 1) -# -# self.label_X = QLabel() -# self.label_X.setText("X") -# self.gridLayout_groupbox_parameter.addWidget(self.label_X, 0, 4, 1, 1) -# -# self.label_alphas = QLabel() -# self.label_alphas.setText("\u03B1s") -# self.gridLayout_groupbox_parameter.addWidget(self.label_alphas, 0, 5, 1, 1) -# -# self.label_zeta = QLabel() -# self.label_zeta.setText("\u03B6") -# self.gridLayout_groupbox_parameter.addWidget(self.label_zeta, 0, 6, 1, 1) -# -# self.label_freq1 = QLabel() -# self.label_freq1.setText("Frequency 1 : ") -# self.gridLayout_groupbox_parameter.addWidget(self.label_freq1, 1, 0, 1, 1) -# -# self.label_freq2 = QLabel() -# self.label_freq2.setText("Frequency 2 : ") -# self.gridLayout_groupbox_parameter.addWidget(self.label_freq2, 2, 0, 1, 1) -# -# self.combobox_freq1 = QComboBox() -# self.gridLayout_groupbox_parameter.addWidget(self.combobox_freq1, 1, 1, 1, 1) -# -# self.combobox_freq2 = QComboBox() -# self.gridLayout_groupbox_parameter.addWidget(self.combobox_freq2, 2, 1, 1, 1) -# -# self.spinbox_ks_freq1 = QDoubleSpinBox() -# self.spinbox_ks_freq1.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_ks_freq1, 1, 2, 1, 1) -# -# self.spinbox_ks_freq2 = QDoubleSpinBox() -# self.spinbox_ks_freq2.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_ks_freq2, 2, 2, 1, 1) -# -# self.spinbox_sv_freq1 = QDoubleSpinBox() -# self.spinbox_sv_freq1.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_sv_freq1, 1, 3, 1, 1) -# -# self.spinbox_sv_freq2 = QDoubleSpinBox() -# self.spinbox_sv_freq2.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_sv_freq2, 2, 3, 1, 1) -# -# self.spinbox_X = QDoubleSpinBox() -# self.spinbox_X.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_X, 1, 4, 1, 1) -# -# self.spinbox_alphas_freq1 = QDoubleSpinBox() -# self.spinbox_alphas_freq1.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_alphas_freq1, 1, 5, 1, 1) -# -# self.spinbox_alphas_freq2 = QDoubleSpinBox() -# self.spinbox_alphas_freq2.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_alphas_freq2, 2, 5, 1, 1) -# -# self.spinbox_zeta_freq1 = QDoubleSpinBox() -# self.spinbox_zeta_freq1.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_zeta_freq1, 1, 6, 1, 1) -# -# self.spinbox_zeta_freq2 = QDoubleSpinBox() -# self.spinbox_zeta_freq2.setDecimals(5) -# self.gridLayout_groupbox_parameter.addWidget(self.spinbox_zeta_freq2, 2, 6, 1, 1) -# -# # self.label_frequency_to_compute_SSC = QLabel() -# # self.label_frequency_to_compute_SSC.setText("frequencies for SSC : ") -# # # self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget( -# # # self.label_frequency_to_compute_SSC, 2, 0, 1, 1) -# # self.gridLayout_groupbox_parameter.addWidget(self.label_frequency_to_compute_SSC, 3, 0, 1, 1) -# -# # self.combobox_frequency_SSC = QComboBox() -# # # self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget( -# # # self.combobox_frequency_SSC, 2, 1, 1, 1) -# # self.gridLayout_groupbox_parameter.addWidget(self.combobox_frequency_SSC, 3, 1, 1, 1) -# # self.combobox_frequency_SSC.currentIndexChanged.connect(self.frequency_choice_to_compute_SSC) -# -# self.pushbutton_run = QPushButton() -# self.pushbutton_run.setText("RUN") -# self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget(self.pushbutton_run, 1, 0, 1, 1) -# self.pushbutton_run.clicked.connect(self.compute_acoustic_inversion_method_high_concentration) -# -# self.pushbutton_plot = QPushButton() -# self.pushbutton_plot.setText("PLOT") -# self.gridLayout_groupbox_acoustic_inversion_settings_parameter.addWidget(self.pushbutton_plot, 1, 1, 1, 1) -# self.pushbutton_plot.clicked.connect(self.plot_SSC_fine) -# self.pushbutton_plot.clicked.connect(self.plot_SSC_sand) -# # self.pushbutton_plot.clicked.connect(self.insert_slider_for_vertical_profile_figure_area) -# self.pushbutton_plot.clicked.connect(self.plot_inverted_SSC_sand_vertical_profile) -# # self.pushbutton_plot.clicked.connect(self.plot_inverted_SSC_vs_measured_SSC) -# # self.pushbutton_plot.clicked.connect(self.plot_inverted_SSC_vs_measured_SSC_OR_inverted_SSC_vertical_profile) -# -# # ===================================================== -# # BOTTOM HORIZONTAL BOX LAYOUT -# # ===================================================== -# -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# # | Group box SSC 2D field | -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# -# self.verticalLayout_groupbox_SSC_2D_field = QVBoxLayout(self.groupbox_SSC_2D_field) -# self.groupbox_SSC_2D_field.setTitle("Suspended Sediment Concentration 2D plot") -# -# self.groupbox_plot_SSC_sand = QGroupBox() -# self.verticalLayout_groupbox_plot_SSC_sand = QVBoxLayout(self.groupbox_plot_SSC_sand) -# self.verticalLayout_groupbox_SSC_2D_field.addWidget(self.groupbox_plot_SSC_sand) -# -# self.figure_SSC_sand, self.axis_SSC_sand = plt.subplots(nrows=1, ncols=1, layout="constrained") -# self.canvas_SSC_sand = FigureCanvas(self.figure_SSC_sand) -# self.verticalLayout_groupbox_plot_SSC_sand.addWidget(self.canvas_SSC_sand) -# -# self.groupbox_plot_SSC_fine = QGroupBox() -# self.verticalLayout_groupbox_plot_SSC_fine = QVBoxLayout(self.groupbox_plot_SSC_fine) -# self.verticalLayout_groupbox_SSC_2D_field.addWidget(self.groupbox_plot_SSC_fine) -# -# self.figure_SSC_fine, self.axis_SSC_fine = plt.subplots(nrows=1, ncols=1, layout="constrained") -# self.canvas_SSC_fine = FigureCanvas(self.figure_SSC_fine) -# self.verticalLayout_groupbox_plot_SSC_fine.addWidget(self.canvas_SSC_fine) -# -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# # | Group box plot samples vs inversion | -# # +++++++++++++++++++++++++++++++++++++++++++++++ -# -# self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted = QVBoxLayout(self.groupbox_SSC_profiles_or_measured_vs_inverted) -# # self.groupbox_SSC_profiles_or_measured_vs_inverted.setTitle("Suspended Sediment Concentration : sample vs inversion") -# -# self.horizontalLayout_fig_choice = QHBoxLayout() -# self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addLayout(self.horizontalLayout_fig_choice) -# self.spacerItem_fig_choice = QSpacerItem(50, 10, QSizePolicy.Expanding, QSizePolicy.Minimum) -# self.horizontalLayout_fig_choice.addSpacerItem(self.spacerItem_fig_choice) -# self.combobox_fig_choice = QComboBox() -# self.combobox_fig_choice.addItems([ -# "Inverted SSC sand vertical profile", -# "Inverted SSC fine vertical profile", -# "Inverted SSC vs Measured SSC"]) -# self.horizontalLayout_fig_choice.addWidget(self.combobox_fig_choice) -# -# # self.combobox_fig_choice.currentIndexChanged.connect(self.plot_inverted_SSC_fine_vertical_profile) -# # self.combobox_fig_choice.currentIndexChanged.connect(self.plot_inverted_SSC_sand_vertical_profile) -# # self.combobox_fig_choice.currentIndexChanged.connect(self.plot_inverted_SSC_vs_measured_SSC) -# -# # self.combobox_fig_choice.currentIndexChanged.connect(self.plot_inverted_SSC_vs_measured_SSC_OR_inverted_SSC_vertical_profile) -# -# # --- Figure, axis, canvas for Inverted SSC vs Measured SSC -# self.figure_SSC_measured_vs_inverted, self.axis_SSC_measured_vs_inverted = plt.subplots(nrows=1, ncols=1, -# layout="constrained") -# self.canvas_SSC_measured_vs_inverted = FigureCanvas(self.figure_SSC_measured_vs_inverted) -# # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget(self.canvas_SSC_measured_vs_inverted) -# -# # --- Figure, axis, canvas for SSC sand vertical profile -# self.figure_SSC_sand_vertical_profile, self.axis_SSC_sand_vertical_profile = ( -# plt.subplots(nrows=1, ncols=1, layout="constrained")) -# self.canvas_SSC_sand_vertical_profile = FigureCanvas(self.figure_SSC_sand_vertical_profile) -# self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget( -# self.canvas_SSC_sand_vertical_profile) -# -# # --- Figure, axis, canvas for SSC fine vertical profile -# # self.figure_SSC_fine_vertical_profile, self.axis_SSC_fine_vertical_profile = ( -# # plt.subplots(nrows=1, ncols=1, layout="constrained")) -# # self.canvas_SSC_fine_vertical_profile = FigureCanvas(self.figure_SSC_fine_vertical_profile) -# # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget( -# # self.canvas_SSC_fine_vertical_profile) -# -# # --- Slider for moving the profile --- -# self.horizontalLayout_slider = QHBoxLayout() -# self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addLayout(self.horizontalLayout_slider) -# -# self.pushbutton_slider_left = QPushButton() -# self.pushbutton_slider_left.setIcon(self.icon_triangle_left) -# self.horizontalLayout_slider.addWidget(self.pushbutton_slider_left) -# -# self.pushbutton_slider_left.clicked.connect(self.slide_profile_number_to_left) -# -# self.pushbutton_slider_right = QPushButton() -# self.pushbutton_slider_right.setIcon(self.icon_triangle_right) -# self.horizontalLayout_slider.addWidget(self.pushbutton_slider_right) -# -# self.pushbutton_slider_right.clicked.connect(self.slide_profile_number_to_right) -# -# self.lineEdit_slider = QLineEdit() -# self.lineEdit_slider.setText("1") -# self.lineEdit_slider.setFixedWidth(50) -# self.horizontalLayout_slider.addWidget(self.lineEdit_slider) -# -# self.lineEdit_slider.returnPressed.connect(self.profile_number_on_lineEdit) -# -# self.slider = QSlider() -# self.horizontalLayout_slider.addWidget(self.slider, 9) -# -# self.slider.setOrientation(Qt.Horizontal) -# self.slider.setCursor(Qt.OpenHandCursor) -# self.slider.setMinimum(1) -# self.slider.setMaximum(10) -# self.slider.setTickInterval(1) -# self.slider.setValue(1) -# -# self.slider.valueChanged.connect(self.update_lineEdit_by_moving_slider) -# self.slider.valueChanged.connect(self.plot_inverted_SSC_sand_vertical_profile) -# self.slider.valueChanged.connect(self.plot_SSC_sand) -# -# # self.verticalLayout_groupbox_sediment_concentration_2Dplot = QVBoxLayout(self.groupbox_sediment_concentration_2Dplot) -# # -# # self.figure_SSC_2Dplot, self.axis_SSC_2Dplot = plt.subplots(nrows=2, ncols=1) -# # self.canvas_sediments2DPlot = FigureCanvas(self.figure_SSC_2Dplot) -# # self.toolbar_concentration_2Dplot = NavigationToolBar(self.canvas_sediments2DPlot, self) -# # self.plot_SSC_fine() -# # self.plot_SSC_sand() -# # # self.verticalLayout_groupbox_sediment_concentration_2Dplot.addWidget(self.toolbar_concentration_2Dplot) -# # self.verticalLayout_groupbox_sediment_concentration_2Dplot.addWidget(self.canvas_sediments2DPlot) -# # -# # # self.horizontalLayout_Bottom_acousticInversionTab.addWidget(self.canvas_sediments2DPlot) -# # self.horizontalLayout_Bottom_acousticInversionTab.addWidget(self.groupbox_sediment_concentration_2Dplot, 7) -# # -# # -# # # self.groupbox_sediment_concentration_sample_vs_measurement.setTitle( -# # # "Suspended sediment concentration plot : acoustic inversion theory VS measurements") -# # -# # self.verticalLayout_groupbox_sediment_concentration_sample_vs_measurement = QVBoxLayout( -# # self.groupbox_sediment_concentration_sample_vs_measurement) -# # -# # self.figure_inverseSSC_vs_measuredSSC, self.axis_inverseSSC_vs_measuredSSC = plt.subplots(nrows=1, ncols=1) -# # self.canvas_InverseSSC_vs_MeasuredSSC = FigureCanvas(self.figure_inverseSSC_vs_measuredSSC) -# # self.toolbar_InverseSSC_vs_MeasuredSSC = NavigationToolBar(self.canvas_InverseSSC_vs_MeasuredSSC, self) -# # # self.verticalLayout_groupbox_sediment_concentration_sample_vs_measurement.addWidget( -# # # self.toolbar_InverseSSC_vs_MeasuredSSC) -# # self.verticalLayout_groupbox_sediment_concentration_sample_vs_measurement.addWidget( -# # self.canvas_InverseSSC_vs_MeasuredSSC, 3) -# # # self.horizontalLayout_Bottom_acousticInversionTab.addWidget(self.canvas_InverseSSC_vs_MeasuredSSC) -# # -# # self.horizontalLayout_Bottom_acousticInversionTab.addWidget( -# # self.groupbox_sediment_concentration_sample_vs_measurement) -# # -# # self.verticalLayout_acoustic_inversion_tab.addLayout(self.horizontalLayout_Bottom_acousticInversionTab, 6) -# # -# # self.retranslate_acoustic_inversion_tab() -# -# # ---------------------------------------------------------------------------------------------------------------- -# # -------------------- Functions -------------------- -# -# # def retranslate_acoustic_inversion_tab(self): -# # -# # self.groupbox_AcousticInversionOption.setTitle(_translate("CONSTANT_STRING", cs.ACOUSTIC_INVERSION_OPTIONS)) -# # self.groupbox_sediment_concentration_2Dplot.setTitle(_translate("CONSTANT_STRING", cs.FINE_AND_SAND_SEDIMENTS_CONCENTRATION_2D_FIELD)) -# # self.groupbox_sediment_concentration_sample_vs_measurement.setTitle(_translate("CONSTANT_STRING", cs.SUSPENDED_SEDIMENT_CONCENTRATION_PLOT)) - - # def acoustic_inversion_method_choice(self): - # print("acoustic_inversion_method_choice") - # if self.combobox_acoustic_inversion_method_choice.currentIndex() == 1: - # - # self.plot_transect_with_sample_position() - # - # # --- add items in combobox of samples (sand and vertical fine) to calibrate acoustic inversion method --- - # - # # samples_vertical_line = np.split(stg.samples, np.where(np.diff(stg.sample_time) != 0)[0]+1) - # - # # self.combobox_calibration_sand_sample.addItem(" ") - # # for s in samples_vertical_line: - # # self.combobox_calibration_sand_sample.addItem(" - ".join([i for i in s])) - # - # self.combobox_frequency.addItems(stg.freq_text) - # - # self.combobox_calibration_sand_sample.addItems(stg.samples) - # # self.combobox_calibration_sand_sample.currentData.connect(self.update_plot_transect_with_sample_position) - # - # self.combobox_calibration_fine_sample.addItems(stg.samples) - # # self.combobox_calibration_fine_sample.currentData.connect(self.update_plot_transect_with_sample_position) - # - # self.combobox_freq1.addItems(stg.freq_text) - # self.combobox_freq2.addItems(stg.freq_text) - # - # - # # for i in range(len(samples_vertical_line)): - # # self.combobox_calibration_samples.setItemChecked(i, False) - # - # # --- add items in combobox of frequencies for VBI computation --- - # # self.combobox_frequencies_VBI.addItem(" ") - # # for k in combinations(stg.freq_text, 2): - # # self.combobox_frequencies_VBI.addItem(k[0] + " - " + k[1]) - # # print(k) - # # for i in range(len(list(combinations(stg.freq_text, 2)))): - # # self.combobox_frequencies_VBI.setItemChecked(i, False) - # - # # print(f"stg.fine_sediment_columns length : {len(stg.fine_sediment_columns)}") - # # print(f"stg.fine_sediment_columns : {stg.fine_sediment_columns}") - # # print(f"stg.frac_vol_fine.shape : {stg.frac_vol_fine.shape}") - # # print(f"stg.frac_vol_fine : {stg.frac_vol_fine}") - # - # def plot_transect_with_sample_position(self): - # print("plot_transect_with_sample_position") - # if self.canvas_plot_sample_position_on_transect == None: - # - # self.verticalLayout_groupbox_plot_sample_position_on_transect.removeWidget(self.canvas_plot_sample_position_on_transect) - # 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.verticalLayout_groupbox_plot_sample_position_on_transect.addWidget(self.canvas_plot_sample_position_on_transect) - # - # if stg.BS_stream_bed.size == 0: - # - # val_min = np.nanmin(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) - # val_max = np.nanmax(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) - # if val_min == 0: - # val_min = 1e-5 - # - # self.axis_plot_sample_position_on_transect.pcolormesh( - # stg.t[stg.freq_bottom_detection, :], - # -stg.r[stg.freq_bottom_detection, :], - # stg.BS_cross_section[stg.freq_bottom_detection, :, :], - # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) - # - # if stg.r_bottom.size != 0: - # self.axis_plot_sample_position_on_transect.plot( - # stg.t[stg.freq_bottom_detection, :], - # -stg.r_bottom, color='black', linewidth=1, linestyle="solid") - # - # else: - # - # val_min = np.nanmin(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) - # val_max = np.nanmax(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) - # if val_min == 0: - # val_min = 1e-5 - # - # self.axis_plot_sample_position_on_transect.pcolormesh( - # stg.t[stg.freq_bottom_detection, :], - # -stg.r[stg.freq_bottom_detection, :], - # stg.BS_stream_bed[stg.freq_bottom_detection, :, :], - # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) - # - # if stg.r_bottom.size != 0: - # self.axis_plot_sample_position_on_transect.plot( - # stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, - # color='black', linewidth=1, linestyle="solid") - # - # self.axis_plot_sample_position_on_transect.set_xticks([]) - # self.axis_plot_sample_position_on_transect.set_yticks([]) - # self.figure_plot_sample_position_on_transect.canvas.draw_idle() - # - # def update_plot_transect_with_sample_position(self): - # - # # --- List selected sand and fine samples --- - # sand_position_list, fine_position_list = self.sample_choice() - # - # # --- Create canvas of Matplotlib figure --- - # if stg.BS_raw_data.size == 0: - # - # self.verticalLayout_groupbox_plot_sample_position_on_transect.removeWidget( - # self.canvas_plot_sample_position_on_transect) - # 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.verticalLayout_groupbox_plot_sample_position_on_transect.addWidget( - # self.canvas_plot_sample_position_on_transect) - # - # if sand_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[sand_position_list], - # stg.sample_depth[sand_position_list], - # marker="o", s=20) - # - # if fine_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[fine_position_list], - # stg.sample_depth[fine_position_list], - # marker="o", s=14) - # - # self.axis_plot_sample_position_on_transect.set_xticks([]) - # self.axis_plot_sample_position_on_transect.set_yticks([]) - # self.figure_plot_sample_position_on_transect.canvas.draw_idle() - # - # elif stg.BS_stream_bed.size == 0: - # - # val_min = np.nanmin(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) - # val_max = np.nanmax(stg.BS_cross_section[stg.freq_bottom_detection, :, :]) - # if val_min == 0: - # val_min = 1e-5 - # - # self.axis_plot_sample_position_on_transect.pcolormesh( - # stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :], - # stg.BS_cross_section[self.combobox_frequency.currentIndex(), :, :], - # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) - # - # if stg.r_bottom.size != 0: - # self.axis_plot_sample_position_on_transect.plot( - # stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, - # color='black', linewidth=1, linestyle="solid") - # - # if sand_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[sand_position_list], - # stg.sample_depth[sand_position_list], - # marker="o", s=20) - # # markeredgecolor='k', markerfacecolor='none') - # - # if fine_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[fine_position_list], - # stg.sample_depth[fine_position_list], - # marker="o", s=14) - # # markeredgecolor='k', markerfacecolor='k') - # - # self.axis_plot_sample_position_on_transect.set_xticks([]) - # self.axis_plot_sample_position_on_transect.set_yticks([]) - # self.figure_plot_sample_position_on_transect.canvas.draw_idle() - # - # else: - # - # val_min = np.nanmin(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) - # val_max = np.nanmax(stg.BS_stream_bed[stg.freq_bottom_detection, :, :]) - # if val_min == 0: - # val_min = 1e-5 - # - # self.axis_plot_sample_position_on_transect.pcolormesh( - # stg.t[stg.freq_bottom_detection, :], -stg.r[stg.freq_bottom_detection, :], - # stg.BS_stream_bed[self.combobox_frequency.currentIndex(), :, :], - # cmap='viridis', norm=LogNorm(vmin=val_min, vmax=val_max)) - # - # if stg.r_bottom.size != 0: - # self.axis_plot_sample_position_on_transect.plot( - # stg.t[stg.freq_bottom_detection, :], -stg.r_bottom, color='black', linewidth=1, linestyle="solid") - # - # if sand_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[sand_position_list], - # stg.sample_depth[sand_position_list], - # marker="o", s=20) - # - # if fine_position_list: - # self.axis_plot_sample_position_on_transect.scatter(stg.sample_time[fine_position_list], - # stg.sample_depth[fine_position_list], - # marker="o", s=14) - # - # self.axis_plot_sample_position_on_transect.set_xticks([]) - # self.axis_plot_sample_position_on_transect.set_yticks([]) - # self.figure_plot_sample_position_on_transect.canvas.draw_idle() - # - # def sample_choice(self): - # # --- List selected sand samples --- - # sand_position_list = [int(s[1:])-1 for s in self.combobox_calibration_sand_sample.currentData()] - # print(f"sand_position_list : {sand_position_list}") - # # print(f"sand samples checked : {sand_samples_checked}") - # - # # --- List selected fine samples --- - # fine_position_list = [int(s[1:])-1 for s in self.combobox_calibration_fine_sample.currentData()] - # print(f"fine_position_list : {fine_position_list}") - # # print(f"fine samples checked : {fine_samples_checked}") - # return sand_position_list, fine_position_list - # - # def frequencies_pair_choice_to_compute_VBI(self): - # freq_combination = list(combinations(stg.freq, 2)) - # frequencies_position = [] - # # for i in range(self.combobox_frequencies_VBI.count()): - # # if self.combobox_frequencies_VBI.itemChecked(i): - # # frequencies_position.append(i) - # # elif (i in frequencies_position) and (not self.combobox_frequencies_VBI.itemChecked(i)): - # # frequencies_position.remove(i) - # frequencies_position.append(self.combobox_frequencies_VBI.currentIndex()) - # print(f"frequencies_position : {frequencies_position}") - # - # if len(frequencies_position) != 0: - # # print(frequencies_position) - # # print(freq_combination[frequencies_position[0]][0], freq_combination[frequencies_position[0]][1]) - # stg.frequencies_to_compute_VBI = ( - # np.array([[int(np.where(stg.freq == freq_combination[frequencies_position[0]-1][0])[0][0]), - # freq_combination[frequencies_position[0]-1][0]], - # [int(np.where(stg.freq == freq_combination[frequencies_position[0]-1][1])[0][0]), - # freq_combination[frequencies_position[0]-1][1]]])) - # print(f"stg.frequencies_to_compute_VBI : {stg.frequencies_to_compute_VBI}") - # - # # --- add items in combobox of frequency for SSC computation --- - # # for k in range(stg.frequencies_to_compute_VBI.shape[0]+1): - # # self.combobox_frequency_SSC.removeItem(k) - # self.combobox_frequency_SSC.clear() - # for k in range(stg.frequencies_to_compute_VBI.shape[0]+1): - # if k == 0: - # self.combobox_frequency_SSC.addItem(" ") - # else: - # self.combobox_frequency_SSC.addItem(str(1e-6*stg.frequencies_to_compute_VBI[k-1, 1]) + " MHz") - # # for i in range(stg.frequencies_to_compute_VBI.shape[0]): - # # self.combobox_frequency_SSC.setItemChecked(i, False) - # - # print("frequencies to compute VBI", stg.frequencies_to_compute_VBI) - # - # def frequency_choice_to_compute_SSC(self): - # print(self.combobox_frequency_SSC.currentText()) - # print(self.combobox_frequency_SSC.currentIndex()) - # # print(self.combobox_frequency_SSC.itemChecked(index)) - # - # - # # if self.combobox_frequency_SSC.itemChecked(index): - # # # itemChecked(index)): # currentIndex() == 0) or (self.combobox_frequency_SSC.currentIndex() == 1): - # # print(self.combobox_frequency_SSC.currentText()) - # # print(stg.freq_text) - # # print(np.where(np.array(stg.freq_text) == self.combobox_frequency_SSC.currentText())) - # - # # stg.frequency_to_compute_SSC \ - # # = np.array([int(np.where(np.array(stg.freq_text) == self.combobox_frequency_SSC.currentText())[0][0]), - # # stg.freq[int(np.where(np.array(stg.freq_text) == self.combobox_frequency_SSC.currentText())[0][0])]]) - # # - # # print("stg.frequency_to_compute_SSC ", stg.frequency_to_compute_SSC) - # - # # def temperature_value(self): - # # stg.temperature = self.spinbox_temperature.value() - # # print(stg.temperature) - # - # def compute_sound_velocity(self): - # stg.water_velocity = self.inv_hc.water_velocity(stg.temperature) - # print("water velocity ", stg.water_velocity) - # - # # def compute_kt(self, freq_ind): - # # - # # # stg.kt_corrected = self.inv_hc.kt_corrected(stg.r[int(stg.frequency_to_compute_SSC[0]), :], stg.water_velocity, - # # # stg.gain_rx[[int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])]], - # # # stg.gain_tx[[int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])]], - # # # stg.kt[[int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])]]) - # # - # # if stg.ABS_name == "Aquascat 1000R": - # # kt_corrected = self.inv_hc.kt_corrected(stg.r[0, :], stg.water_velocity, - # # stg.gain_rx[freq_ind], stg.gain_tx[freq_ind], stg.kt[0, freq_ind]) - # # kt_corrected_2D = np.repeat(kt_corrected, stg.r.shape[1], axis=0) - # # print("kt 2D ", kt_corrected_2D) - # # print("kt 2D shape ", kt_corrected_2D.shape) - # # kt_corrected_3D = np.zeros((kt_corrected_2D.shape[1], kt_corrected_2D.shape[0], stg.t.shape[1])) - # # for k in range(kt_corrected_2D.shape[1]): - # # kt_corrected_3D[k, :, :] = np.repeat(kt_corrected_2D, stg.t.shape[1], axis=1)[:, - # # k * stg.t.shape[1]:(k + 1) * stg.t.shape[1]] - # # print("kt 3D ", kt_corrected_3D) - # # print("kt 3D shape ", kt_corrected_3D.shape) - # # elif stg.ABS_name == "UB-SediFlow": - # # stg.kt_corrected = np.array([[0.003, 0.006]]) - # # print("kt ", stg.kt_corrected) - # # print("kt shape ", stg.kt_corrected.shape) - # # stg.kt_corrected_2D = np.array(np.repeat(stg.kt_corrected, stg.r.shape[1], axis=0)) - # # print("kt 2D shape ", stg.kt_corrected_2D.shape) - # # stg.kt_corrected_3D = np.zeros((stg.kt_corrected_2D.shape[1], stg.kt_corrected_2D.shape[0], stg.t.shape[1])) - # # for k in range(stg.kt_corrected_2D.shape[1]): - # # stg.kt_corrected_3D[k, :, :] = np.repeat(stg.kt_corrected_2D, stg.t.shape[1], axis=1)[:, - # # k * stg.t.shape[1]:(k + 1) * stg.t.shape[1]] - # # print("kt corrected 3D zeros shape ", stg.kt_corrected_3D.shape) - # # - # # print("kt ", stg.kt_corrected) - # # # print("kt shape ", stg.kt_corrected.shape) - # # - # # # stg.kt_corrected_2D = np.repeat(stg.kt_corrected, stg.r.shape[1], axis=0) - # # - # # # stg.kt_corrected_3D = np.zeros((stg.kt_corrected_2D.shape[1], stg.kt_corrected_2D.shape[0], stg.t.shape[1])) - # # # print("stg.t.shape ", stg.t.shape) - # # # print("kt corrected 3D zeros shape ", stg.kt_corrected_3D.shape) - # # # for k in range(stg.kt_corrected_2D.shape[1]): - # # # stg.kt_corrected_3D[k, :, :] = np.repeat(stg.kt_corrected_2D, stg.t.shape[1], axis=1)[:, k*stg.t.shape[1]:(k+1)*stg.t.shape[1]] - # # - # # # print("kt 2D", np.repeat(stg.kt_corrected[:, :, np.newaxis], stg.t.shape[0], axis=2)) - # - # def compute_J(self, freq_ind, kt): - # if stg.ABS_name == "Aquascat 1000R": - # print(f"stg.BS_stream_bed.shape : {stg.BS_stream_bed.shape}") - # - # if stg.BS_stream_bed.size != 0: - # - # if stg.BS_stream_bed_pre_process_SNR.size != 0: - # print("1/ stg.BS_stream_bed_pre_process_SNR") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed_pre_process_SNR[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed_pre_process_SNR.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.BS_stream_bed_pre_process_average.size != 0: - # print("2/ stg.BS_stream_bed_pre_process_average") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed_pre_process_average[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed_pre_process_average.shape[2]], - # kt[freq_ind, :, :])) - # - # else: - # print("3/ stg.BS_stream_bed") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.BS_cross_section.size != 0: - # - # if stg.BS_cross_section_pre_process_SNR.size != 0: - # print("1/ stg.BS_cross_section_pre_process_SNR") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_cross_section_pre_process_SNR[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_cross_section_pre_process_SNR.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.BS_cross_section_pre_process_average.size != 0: - # print("2/ stg.BS_cross_section_pre_process_average") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section(stg.BS_cross_section_pre_process_average[freq_ind, :, :], - # stg.r_2D[0, :, :stg.BS_cross_section_pre_process_average.shape[2]], - # kt[freq_ind, :, :])) - # - # else: - # print("3/ stg.BS_cross_section") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_cross_section[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_cross_section.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.ABS_name == "UB-SediFlow": - # - # if stg.BS_stream_bed.size != 0: - # - # if stg.BS_stream_bed_pre_process_SNR.size != 0: - # print("1/ stg.BS_stream_bed_pre_process_SNR") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed_pre_process_SNR[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed_pre_process_SNR.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.BS_stream_bed_pre_process_average.size != 0: - # print("2/ stg.BS_stream_bed_pre_process_average") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed_pre_process_average[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed_pre_process_average.shape[2]], - # kt[freq_ind, :, :])) - # - # - # - # else: - # print("3/ stg.BS_stream_bed") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_stream_bed[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_stream_bed.shape[2]], - # kt[freq_ind, :, :])) - # - # elif stg.BS_cross_section.size != 0: - # - # if stg.BS_cross_section_pre_process_SNR.size != 0: - # print("2/ stg.BS_cross_section_pre_process_SNR") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_cross_section_pre_process_SNR[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_cross_section_pre_process_SNR.shape[2]], - # kt[freq_ind, :, :])) - # - # if stg.BS_cross_section_pre_process_average.size != 0: - # print("1/ stg.BS_cross_section_pre_process_average") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section(stg.BS_cross_section_pre_process_average[freq_ind, :, :], - # stg.r_2D[freq_ind, :, - # :stg.BS_cross_section_pre_process_average.shape[2]], - # kt[freq_ind, :, :])) - # - # - # - # else: - # print("3/ stg.BS_cross_section") - # stg.J_cross_section = ( - # self.inv_hc.j_cross_section( - # stg.BS_cross_section[freq_ind, :, :], - # stg.r_2D[freq_ind, :, :stg.BS_cross_section.shape[2]], - # kt[freq_ind, :, :])) - # - # - # - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_cross_section_pre_process_average[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_cross_section_pre_process_average.shape[2]], - # # stg.kt_corrected_3D)) - # - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_cross_section_pre_process_SNR[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, - # # :stg.BS_cross_section_pre_process_SNR.shape[2]], - # # stg.kt_corrected_3D)) - # - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_cross_section[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, - # # :stg.BS_cross_section.shape[2]], - # # stg.kt_corrected_3D)) - # - # # stg.J_stream_bed = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_stream_bed_pre_process_average[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_stream_bed_pre_process_average.shape[2]], - # # stg.kt_corrected_3D)) - # - # - # # stg.J_stream_bed = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_stream_bed_pre_process_SNR[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_stream_bed_pre_process_SNR.shape[2]], - # # stg.kt_corrected_3D)) - # - # # stg.J_stream_bed = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_stream_bed[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, - # # :stg.BS_stream_bed.shape[2]], - # # stg.kt_corrected_3D)) - # - # # elif (stg.BS_data_section_averaged.size == 0) and (stg.BS_data_section_SNR_filter.size == 0): - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data_section.shape[2]], stg.kt_corrected_3D)) - # # elif (stg.BS_data_section_averaged.size != 0) and (stg.BS_data_section_SNR_filter.size == 0): - # # print("Je suis dans ce J") - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section_averaged[[0, 2], :, :], - # # stg.r_2D[[0, 2], :, :stg.BS_data_section_averaged.shape[2]], - # # stg.kt_corrected_3D[[0, 1], :, :])) - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section_averaged[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data_section_averaged.shape[2]], stg.kt_corrected_3D)) - # # else: - # # print("stg.r_2D.shape ", stg.r_2D.shape) - # # print("stg.kt_corrected_3D.shape ", stg.kt_corrected_3D.shape) - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section_SNR_filter[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data_section_SNR_filter.shape[2]], stg.kt_corrected_3D)) - # # - # # print("J ", stg.J_cross_section) - # # print("J sahpe ", stg.J_cross_section.shape) - # - # # if stg.BS_data_section.size == 0: - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data[ - # # [int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])], - # # :, :], stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data.shape[2]], - # # stg.kt_corrected_3D)) - # # elif (stg.BS_data_section_averaged.size == 0) and (stg.BS_data_section_SNR_filter.size == 0): - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # np.array([stg.r_2D[0, :, :stg.BS_data_section.shape[2]]]), - # # stg.kt_corrected_3D)) - # # elif (stg.BS_data_section_averaged.size != 0) and (stg.BS_data_section_SNR_filter.size == 0): - # # print("Je suis dans ce J") - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section_averaged[[0, 2], :, :], - # # stg.r_2D[[0, 2], :, :stg.BS_data_section_averaged.shape[2]], - # # stg.kt_corrected_3D[[0, 1], :, :])) - # # # stg.J_cross_section = ( - # # # self.inv_hc.j_cross_section( - # # # stg.BS_data_section_averaged[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data_section_averaged.shape[2]], stg.kt_corrected_3D)) - # # else: - # # print("stg.r_2D.shape ", stg.r_2D.shape) - # # print("stg.kt_corrected_3D.shape ", stg.kt_corrected_3D.shape) - # # stg.J_cross_section = ( - # # self.inv_hc.j_cross_section( - # # stg.BS_data_section_SNR_filter[[int(stg.frequencies_to_compute_VBI[0, 0]), - # # int(stg.frequencies_to_compute_VBI[1, 0])], :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.BS_data_section_SNR_filter.shape[2]], - # # stg.kt_corrected_3D)) - # # - # # print("J ", stg.J_cross_section) - # # print("J sahpe ", stg.J_cross_section.shape) - # - # return stg.J_cross_section - # - # # def compute_alpha_s(self, freq, freq_ind): - # # stg.sv = self.compute_sv(freq) - # # j_cross_section = self.compute_J(freq_ind) - # # stg.alpha_s = np.log(stg.sv / j_cross_section) / (4 * stg.sample_depth[10]) - stg.water_attenuation - # # return - # - # # def compute_zeta(self): - # # stg.zeta_freq1 = self.inv_hc.zeta(0, 2) - # # stg.zeta_freq2 = self.inv_hc.zeta() - # # # stg.zeta = self.inv_hc.zeta(int(stg.frequencies_to_compute_VBI[0, 0]), int(stg.frequencies_to_compute_VBI[1, 0])) - # # print("zeta ", stg.zeta) - # - # # def compute_X(self): - # # stg.X_exponent = self.inv_hc.X_exponent(2) #self.inv_hc.X_exponent(self.combobox_frequencies_VBI.currentIndex()) - # # print("X ", stg.X_exponent) - # - # # def compute_VBI(self): - # # stg.VBI_cross_section = self.inv_hc.VBI_cross_section(3e5, - # # 1e6, - # # stg.zeta[0], - # # # zeta is already limited to the frequencies pairs so that we just need to select indices 0 and 1 - # # stg.zeta[1], - # # stg.J_cross_section[0, :, :], - # # stg.J_cross_section[1, :, :], - # # stg.r_2D[0, :, :stg.t.shape[1]], - # # stg.water_attenuation[0], - # # stg.water_attenuation[1], - # # stg.X_exponent) - # - # # stg.VBI_cross_section = self.inv_hc.VBI_cross_section(stg.frequencies_to_compute_VBI[0, 1], stg.frequencies_to_compute_VBI[1, 1], - # # stg.zeta[0], # zeta is already limited to the frequencies pairs so that we just need to select indices 0 and 1 - # # stg.zeta[1], - # # stg.J_cross_section[0, :, :], - # # stg.J_cross_section[1, :, :], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.t.shape[1]], - # # stg.water_attenuation[0], - # # stg.water_attenuation[1], - # # stg.X_exponent) - # # print("VBI shape ", stg.VBI_cross_section.shape) - # # print(int(self.combobox_frequency_SSC.currentIndex())) - # # print(stg.zeta[int(self.combobox_frequency_SSC.currentIndex())]) - # - # def range_cells_function(self): - # """ Computing the real cell size, that depends on the temperature """ - # # defaut Aquascat cell size - # aquascat_cell_size = stg.r[0, 1] - stg.r[0, 0] - # # Pulse duration - # tau = aquascat_cell_size * 2 / 1500 # figure 2.9 1500 vitesse du son entrée pour le paramètrage des mesures aquascat - # # Sound speed - # cel = self.inv_hc.water_velocity(self.spinbox_temperature.value()) - # # Real cell size - # real_cell_size = cel * tau / 2 # voir fig 2.9 - # - # # Converting to real cell profile - # real_r = np.zeros((stg.freq.shape[0], stg.r.shape[1])) - # for i in range(stg.freq.shape[0]): - # real_r[i, :] = stg.r[i, :] / aquascat_cell_size * real_cell_size # (/ aquascat_cell_size) pour ramener BS.r entre 0 et 1 - # # (* real_cell_size) pour remettre les échelles spatiales sur la taille réelle des cellules - # - # # R with right shape (numpy array) - # R_real = real_r # np.repeat(real_r, len(stg.freq), axis=1) - # print(f"R_real = {R_real.shape}") - # - # return R_real - # - # def compute_acoustic_inversion_method_high_concentration(self): - # - # # --- List selected sand and fine samples --- - # sand_position_list, fine_position_list = self.sample_choice() - # - # if stg.ABS_name == "Aquascat 1000R": - # - # freq1 = int(self.combobox_freq1.currentIndex()) # 0 = 300kHz et 1 = 500kHz - # freq2 = int(self.combobox_freq2.currentIndex()) # 2 = 1MHz - # print(f"freq1 = {freq1}, freq2 = {freq2}") - # - # stg.water_velocity = self.inv_hc.water_velocity(stg.temperature) - # - # alpha_w_freq1, alpha_w_freq2 = (self.inv_hc.water_attenuation(freq=stg.freq[freq1], T=stg.temperature), - # self.inv_hc.water_attenuation(freq=stg.freq[freq2], T=stg.temperature)) - # print(f"alpha_w_freq1 = {alpha_w_freq1}, alpha_w_freq2 = {alpha_w_freq2}") - # - # self.compute_sound_velocity() - # - # # print("ks value : ", self.inv_hc.ks(a_s=stg.sand_sediment_columns[5:], rho_s=2500, freq=stg.freq[0], pdf=stg.frac_vol_sand[2, :])) - # - # # ks_freq1, ks_freq2 = ( - # # self.inv_hc.ks(num_sample=2, freq=stg.freq[freq1], pdf=stg.frac_vol_sand_cumul[2, :]), - # # self.inv_hc.ks(num_sample=2, freq=stg.freq[freq2], pdf=stg.frac_vol_sand_cumul[2, :])) - # ks_freq1, ks_freq2 = ( - # self.inv_hc.ks(num_sample=sand_position_list[0], freq=stg.freq[freq1], pdf=stg.frac_vol_sand_cumul[sand_position_list[0], :]), - # self.inv_hc.ks(num_sample=sand_position_list[0], freq=stg.freq[freq2], pdf=stg.frac_vol_sand_cumul[sand_position_list[0], :])) - # # 6 = V11 , 10 = V12 sur le notebook d'Adrien - # # ks_freq1, ks_freq2 = self.inv_hc.ks()[0], self.inv_hc.ks()[2] - # print(f"ks_freq1 = {ks_freq1}, ks_freq2 = {ks_freq2}") - # - # # f = self.inv_hc.form_factor_function_MoateThorne2012(np.log(np.logspace(-10, -2, 3000)), stg.freq[2]) - # # fig, ax = plt.subplots(nrows=1, ncols=1) - # # ax.plot(list(range(len(np.log(np.logspace(-10, -2, 3000))))), f, color="k", ls="solid") - # # plt.show() - # - # # sv_freq1, sv_freq2 = ( - # # self.inv_hc.sv(ks=ks_freq1, M_sand=stg.Ctot_sand[2]), - # # self.inv_hc.sv(ks=ks_freq2, M_sand=stg.Ctot_sand[2])) - # sv_freq1, sv_freq2 = ( - # self.inv_hc.sv(ks=ks_freq1, M_sand=stg.Ctot_sand[sand_position_list[0]]), - # self.inv_hc.sv(ks=ks_freq2, M_sand=stg.Ctot_sand[sand_position_list[0]])) - # print(f"sv_freq1 = {sv_freq1}, sv_freq2 = {sv_freq2}") - # - # X_exponent = self.inv_hc.X_exponent(freq1=stg.freq[freq1], freq2=stg.freq[freq2], sv_freq1=sv_freq1, sv_freq2=sv_freq2) - # # X_exponent = self.inv_hc.X_exponent(ind=2) - # print(f"X_exponent = {X_exponent}") - # - # stg.kt = np.array([[0.04], [0.01838], [0.03267], [0.01376]]) - # kt = np.array([]) - # for i, v in enumerate(stg.kt): - # kt = np.append(kt, self.inv_hc.kt_corrected(r=stg.r[i, :], - # water_velocity=stg.water_velocity, - # RxGain=stg.gain_rx[i], - # TxGain=stg.gain_tx[i], - # kt_ref=stg.kt[i])) - # kt = np.reshape(kt, (len(kt), 1)) - # print(f"kt = {kt}") - # kt2D = np.repeat(np.array(kt), stg.r.shape[1], axis=1) - # print(f"kt2D.shape = {kt2D.shape}") - # # print(f"kt2D = {kt2D}") - # kt3D = np.repeat(kt2D[:, :, np.newaxis], stg.t.shape[1], axis=2) - # print(f"kt3D.shape = {kt3D.shape}") - # # print(f"kt3D = {kt3D}") - # - # # kt_freq1, kt_freq2 = ( - # # self.inv_hc.kt_corrected(r=stg.r[0, :], water_velocity=stg.water_velocity, RxGain=stg.gain_rx[0], - # # TxGain=stg.gain_tx[0], kt_ref=stg.kt[0]), - # # self.inv_hc.kt_corrected(r=stg.r[2, :], water_velocity=stg.water_velocity, RxGain=stg.gain_rx[2], - # # TxGain=stg.gain_tx[2], kt_ref=stg.kt[2])) - # # print(f"kt_freq1 = {kt_freq1}, kt_freq2 = {kt_freq2}") - # # kt2D_freq1 = np.full((stg.r.shape[1], stg.t.shape[1]), kt_freq1) - # # kt2D_freq2 = np.full((stg.r.shape[1], stg.t.shape[1]), kt_freq2) - # # print(f"kt2D_freq1 = {kt2D_freq1.shape}") - # # print(f"kt2D_freq2 = {kt2D_freq2.shape}") - # # kt3D = np.repeat(kt2D[:, :, np.newaxis], stg.t.shape[1], axis=2) - # # print(f"kt_3D = {kt3D.shape}") - # # print(f"kt_3D = {kt3D}") - # - # # kt_freq1, kt_freq2 = ( - # # np.full((stg.r.shape[1], stg.t.shape[1]), stg.kt[0]), - # # np.full((stg.r.shape[1], stg.t.shape[1]), stg.kt[2])) - # # print(f"kt_freq1 = {kt_freq1.shape}, kt_freq2 = {kt_freq2.shape}") - # - # J_freq1, J_freq2 = self.compute_J(freq_ind=freq1, kt=kt3D), self.compute_J(freq_ind=freq2, kt=kt3D) - # print(f"J_freq1 = {J_freq1.shape}, J_freq2 = {J_freq2.shape}") - # - # # fig, ax = plt.subplots(nrows=1, ncols=1) - # # pcm = ax.pcolormesh(stg.t[0, :], stg.r[0, :], J_freq2, cmap='rainbow', shading='gouraud') - # # fig.colorbar(pcm, ax=ax, shrink=1, location='right') - # # plt.show() - # - # # print("***************************") - # # print(sv_freq1.shape) - # # print(J_freq1.shape) - # # print(np.repeat(stg.r[0, :][:, np.newaxis], stg.t.shape[1], axis=1).shape) - # # print(np.full((stg.r.shape[1], stg.t.shape[1]), alpha_w_freq1).shape) - # # print("***************************") - # - # r_sample_ind = [] - # t_sample_ind = [] - # for i in range(len(stg.sample_depth[fine_position_list])): #:3 - # # for i in range(len(stg.sample_depth[:3])): #:3 - # # print(-stg.sample_depth[i]) - # # print(-stg.sample_time[i]) - # r_sample_ind.append(np.where(np.abs(stg.r[0, :] - (-stg.sample_depth[i])) == - # np.nanmin(np.abs(stg.r[0, :] - (-stg.sample_depth[i]))))) - # # print(np.abs(stg.t[0, :] - (-stg.sample_time[i]))) - # t_sample_ind.append(np.where(np.abs(stg.t[0, :] - (stg.sample_time[i])) == - # np.nanmin(np.abs(stg.t[0, :] - (stg.sample_time[i]))))) - # print(f"r_sample_ind = {r_sample_ind}") - # print(f"t_sample_ind = {t_sample_ind}") - # # print("J_freq1[r_sample_ind[1][0], t_sample_ind[1][0]] ", J_freq1[r_sample_ind[1][0], t_sample_ind[1][0]]) - # - # # ind_r_min = int(ind_X_min_around_sample[p, k]) - # # print(f"ind_r_min = {ind_r_min}") - # # ind_r_max = int(ind_X_max_around_sample[p, k]) - # # print(f"ind_r_max = {ind_r_max}") - # # ind_t_min = int(ind_r_min_around_sample[p, k]) - # # print(f"ind_t_min = {ind_t_min}") - # # ind_t_max = int(ind_r_max_around_sample[p, k]) - # # print(f"ind_t_max = {ind_t_max}") - # - # # print(f"stg.BS freq1 = {stg.BS_stream_bed_pre_process_average[freq1, r_sample_ind[-1], t_sample_ind[-1]]}") - # # print(f"stg.BS freq2 = {stg.BS_stream_bed_pre_process_average[freq2, r_sample_ind[-1], t_sample_ind[-1]]}") - # # - # # print(f"J_freq1[r_sample_ind[-1], t_sample_ind[-1]] {J_freq1[r_sample_ind[-1], t_sample_ind[-1]]}") - # # print(f"J_freq2[r_sample_ind[-1], t_sample_ind[-1]] {J_freq2[r_sample_ind[-1], t_sample_ind[-1]]}") - # # - # # print(f"stg.r[0, r_sample_ind[-1]] {stg.r[2, r_sample_ind[-1]]}") - # - # - # alpha_s_freq1, alpha_s_freq2 = ( - # self.inv_hc.alpha_s(sv=sv_freq1, j_cross_section=J_freq1[r_sample_ind[-1], t_sample_ind[-1]], depth=stg.r[freq1, r_sample_ind[-1]], alpha_w=alpha_w_freq1), - # self.inv_hc.alpha_s(sv=sv_freq2, j_cross_section=J_freq2[r_sample_ind[-1], t_sample_ind[-1]], depth=stg.r[freq2, r_sample_ind[-1]], alpha_w=alpha_w_freq2)) - # print(f"alpha_s_freq1 = {alpha_s_freq1}, alpha_s_freq2 = {alpha_s_freq2}") - # - # # range_lin_interp, M_profile_fine = self.inv_hc.M_profile_SCC_fine_interpolated( - # # sample_depth=-stg.sample_depth[:3], #:3 - # # M_profile=stg.Ctot_fine[:3], #:3 - # # range_cells=stg.r[0, :], - # # r_bottom=stg.r_bottom[t_sample_ind[0][0]]) - # range_lin_interp, M_profile_fine = self.inv_hc.M_profile_SCC_fine_interpolated(sample_depth=-stg.sample_depth[fine_position_list], #:3 - # M_profile=stg.Ctot_fine[fine_position_list], #:3 - # range_cells=stg.r[0, :], - # r_bottom=[stg.r_bottom[t_sample_ind[0][0]] if stg.r_bottom.size != 0 else stg.r_bottom]) - # print(f"range_lin_interp : {range_lin_interp}") - # print(f"M_profile_fine : {M_profile_fine}") - # - # M_profile_fine = M_profile_fine[:len(range_lin_interp)] - # print(f"M_profile_fine : {M_profile_fine}") - # - # - # # print("----------------------") - # # print(f"r_sample_ind[-1][0] = {r_sample_ind[-1][0][0]}") - # # print(f"M_profile_fine[:r_sample_ind[-1][0]] = ", M_profile_fine[:r_sample_ind[-1][0][0]]) - # # print(f"stg.r[0, r_sample_ind[-1][0]] = ", stg.r[0, r_sample_ind[-1][0][0]]) - # # print("----------------------") - # - # zeta_freq1, zeta_freq2 = (self.inv_hc.zeta(alpha_s=alpha_s_freq1, r=stg.r[freq1, :], M_profile_fine=M_profile_fine), - # self.inv_hc.zeta(alpha_s=alpha_s_freq2, r=stg.r[freq2, :], M_profile_fine=M_profile_fine)) - # # zeta_freq1, zeta_freq2 = ( - # # self.inv_hc.zeta(r=stg.r[0, :r_sample_ind[-1][0][0]], M_profile_fine=M_profile_fine[:r_sample_ind[-1][0][0]]), - # # self.inv_hc.zeta(r=stg.r[0, :r_sample_ind[-1][0][0]], M_profile_fine=M_profile_fine[:r_sample_ind[-1][0][0]])) - # print(f"zeta_freq1 = {zeta_freq1}, zeta_freq2 = {zeta_freq2}") - # # plt.figure() - # # plt.plot(stg.r[0, :], Mprofile, 'b.', -stg.sample_depth[:3], stg.Ctot_fine[:3], 'ko') - # # plt.show() - # - # # --- Fill spinboxes with values of parameters --- - # self.spinbox_ks_freq1.setValue(ks_freq1) - # self.spinbox_ks_freq2.setValue(ks_freq2) - # self.spinbox_sv_freq1.setValue(sv_freq1) - # self.spinbox_sv_freq2.setValue(sv_freq2) - # self.spinbox_X.setValue(X_exponent) - # self.spinbox_alphas_freq1.setValue(alpha_s_freq1) - # self.spinbox_alphas_freq2.setValue(alpha_s_freq2) - # self.spinbox_zeta_freq1.setValue(zeta_freq1) - # self.spinbox_zeta_freq2.setValue(zeta_freq2) - # - # # fig, ax = plt.subplots(nrows=2, ncols=1) - # # pcm1 = ax[0].pcolormesh(stg.t[0, :], -stg.r[0, :], J_freq1, - # # cmap='rainbow', vmin=0, vmax=1e-5, shading='gouraud') - # # cbar1 = fig.colorbar(pcm1, ax=ax[0], shrink=1, location='right') - # # cbar1.set_label(label='J (/m', rotation=270, labelpad=15) - # # pcm2 = ax[1].pcolormesh(stg.t[0, :], -stg.r[0, :], J_freq2, - # # cmap='rainbow', vmin=0, vmax=1e-4, shading='gouraud') - # # cbar2 = fig.colorbar(pcm2, ax=ax[1], shrink=1, location='right') - # # cbar2.set_label(label='J (/m', rotation=270, labelpad=15) - # # fig.supxlabel("Time (sec)", fontsize=10) - # # fig.supylabel("Depth (m)", fontsize=10) - # # plt.show() - # - # stg.VBI_cross_section = self.inv_hc.VBI_cross_section(stg.freq[freq1], stg.freq[freq2], - # zeta_freq1, zeta_freq2, - # J_freq1, J_freq2, - # stg.r_2D[freq1, :, :stg.t.shape[1]], - # alpha_w_freq1, alpha_w_freq2, - # X_exponent) - # - # stg.SSC_fine = self.inv_hc.SSC_fine(zeta_freq2, stg.r_2D[freq2, :, :stg.t.shape[1]], - # stg.VBI_cross_section, stg.freq[freq2], X_exponent, J_freq2, - # np.full(shape=(stg.r.shape[1], stg.t.shape[1]), fill_value=alpha_w_freq2)) - # - # stg.SSC_sand = self.inv_hc.SSC_sand(stg.VBI_cross_section, stg.freq[freq2], X_exponent, ks_freq2) - # - # elif stg.ABS_name == "UB-SediFlow": - # - # freq1 = int(self.combobox_freq1.currentIndex()) # 0 = 500kHz - # freq2 = int(self.combobox_freq2.currentIndex()) # 1 = 1MHz - # - # stg.water_velocity = self.inv_hc.water_velocity(stg.temperature) - # - # alpha_w_freq1, alpha_w_freq2 = (self.inv_hc.water_attenuation(freq=stg.freq[freq1], T=stg.temperature), - # self.inv_hc.water_attenuation(freq=stg.freq[freq2], T=stg.temperature)) - # print(f"alpha_w_freq1 = {alpha_w_freq1}, alpha_w_freq2 = {alpha_w_freq2}") - # - # self.compute_sound_velocity() - # - # # ks_freq1, ks_freq2 = 0.11373812635175432, 0.35705575378038723 - # # ks_freq1, ks_freq2 = (self.inv_hc.form_factor_function_MoateThorne2012(a=100e-6, freq=stg.freq[freq1])/np.sqrt(2500*100e-6), - # # self.inv_hc.form_factor_function_MoateThorne2012(a=100e-6, freq=stg.freq[freq2])/np.sqrt(2500*100e-6)) - # - # ks_freq1, ks_freq2 = ( - # self.inv_hc.ks(num_sample=sand_position_list[0], freq=stg.freq[freq1], pdf=stg.frac_vol_sand_cumul[sand_position_list[0], :]), - # self.inv_hc.ks(num_sample=sand_position_list[0], freq=stg.freq[freq2], pdf=stg.frac_vol_sand_cumul[sand_position_list[0], :])) - # # ks_freq1 = 0.05261498026985425 - # # ks_freq2 = 0.19303997854869764 - # print(f"ks_freq1 = {ks_freq1}, ks_freq2 = {ks_freq2}") - # - # # Fine sediments 19/05/2021 15h11 - 15h42 (locale) = 13h10 - 13h42 (UTC) --> 6 samples - # # 52 to 428 / fixed at 234 - # # 14h10 = position 766 - # # Sand sediments 20/05/2021 12h04 - 12h20 (locale) = 10h04 - 10h20 (UTC) --> 2 samples - # # 777 to 972 / fixed at 777 - # - # sv_freq1, sv_freq2 = ( - # self.inv_hc.sv(ks=ks_freq1, M_sand=stg.Ctot_sand[sand_position_list[0]]), - # self.inv_hc.sv(ks=ks_freq2, M_sand=stg.Ctot_sand[sand_position_list[0]])) - # # sv_freq1 = 0.0004956686799986783 - # # sv_freq2 = 0.006672171109602389 - # print(f"sv_freq1 = {sv_freq1}, sv_freq2 = {sv_freq2}") - # - # X_exponent = self.inv_hc.X_exponent(freq1=stg.freq[freq1], freq2=stg.freq[freq2], - # sv_freq1=sv_freq1, sv_freq2=sv_freq2) - # # X_exponent = 3.750708280862506 - # print(f"X_exponent = {X_exponent}") - # - # # stg.kt = np.array([[1.38e-3], [6.02e-4]]) # Values of kt for 500kHz and 1MHz - # stg.kt = np.array([[0.5], [0.5]]) - # - # kt = stg.kt - # # kt = np.array([]) - # # for i, v in enumerate(stg.kt): - # # kt = np.append(kt, self.inv_hc.kt_corrected(r=stg.r[i, :], - # # water_velocity=stg.water_velocity, - # # RxGain=0, - # # TxGain=0, - # # kt_ref=stg.kt[i])) - # # kt = np.reshape(kt, (len(kt), 1)) - # print(f"kt = {kt}, kt.shape = {kt.shape}") - # kt2D = np.repeat(np.array(kt), stg.r.shape[1], axis=1) - # print(f"kt2D.shape = {kt2D.shape}") - # # print(f"kt2D = {kt2D}") - # kt3D = np.repeat(kt2D[:, :, np.newaxis], stg.t.shape[1], axis=2) - # print(f"kt3D.shape = {kt3D.shape}") - # - # J_freq1, J_freq2 = self.compute_J(freq_ind=freq1, kt=kt3D), self.compute_J(freq_ind=freq2, kt=kt3D) - # print(f"J_freq1 = {J_freq1.shape}, J_freq2 = {J_freq2.shape}") - # - # r_sample_ind = [] - # t_sample_ind = [] - # for i in range(len(stg.sample_depth[fine_position_list])): - # # print(-stg.sample_depth[i]) - # # print(-stg.sample_time[i]) - # r_sample_ind.append(np.where(np.abs(stg.r[freq1, :] - (-stg.sample_depth[i])) == - # np.nanmin(np.abs(stg.r[freq1, :] - (-stg.sample_depth[i]))))) - # # print(np.abs(stg.t[0, :] - (-stg.sample_time[i]))) - # t_sample_ind.append(np.where(np.abs(stg.t[freq1, :] - (stg.sample_time[i])) == - # np.nanmin(np.abs(stg.t[freq1, :] - (stg.sample_time[i]))))) - # print(f"r_sample_ind = {r_sample_ind}") - # print(f"t_sample_ind = {t_sample_ind}") - # - # print(f"stg.BS freq1 = {stg.BS_cross_section[freq1, r_sample_ind[-1], t_sample_ind[-1]]}") - # print(f"stg.BS freq2 = {stg.BS_cross_section[freq2, r_sample_ind[-1], t_sample_ind[-1]]}") - # - # print(f"J_freq1[r_sample_ind[-1], t_sample_ind[-1]] : {J_freq1[r_sample_ind[-1][0][0], t_sample_ind[-1][0][0]]}") - # # print(f"J_freq1[r_sample_ind[-1]+-n, t_sample_ind[-1]+-n] : {J_freq1[r_sample_ind[-1][0][0], t_sample_ind[-1][0][0]:t_sample_ind[-1][0][0]].mean(axis=0)}") - # - # # delta_t = 0 - # alpha_s_freq1, alpha_s_freq2 = ( - # self.inv_hc.alpha_s(sv=sv_freq1, - # j_cross_section=np.mean(J_freq1[r_sample_ind[-1][0][0], t_sample_ind[-1][0][0]]), - # depth=stg.r[freq1, r_sample_ind[-1][0][0]], alpha_w=alpha_w_freq1), - # self.inv_hc.alpha_s(sv=sv_freq2, - # j_cross_section=np.mean(J_freq2[r_sample_ind[-1][0][0], t_sample_ind[-1][0][0]]), - # # j_cross_section=J_freq2[r_sample_ind[-1], t_sample_ind[-1]], - # depth=stg.r[freq2, r_sample_ind[-1][0][0]], alpha_w=alpha_w_freq2)) - # - # # avec J (alpha_w = 0.03578217234512747) - # # alpha_s_freq1 = -0.12087339 - # # alpha_s_freq2 = -0.01437704 - # - # # avec log(J) - # # alpha_s_freq1 = -1.91967628 - # # alpha_s_freq2 = -1.87942544 - # - # # --- Calculation of alpha_s with FCB slope --- - # - # # R_real = np.repeat(self.range_cells_function()[:, :, np.newaxis], stg.t.shape[1], axis=2) - # # water_attenuation = np.full((2, stg.r.shape[1], stg.t.shape[1]), 1) - # # water_attenuation[0, :, :] = alpha_w_freq1*water_attenuation[0, :, :] - # # water_attenuation[1, :, :] = alpha_w_freq2*water_attenuation[1, :, :] - # # if stg.BS_stream_bed.size == 0: - # # stg.FCB = (np.log(stg.BS_cross_section[[freq1, freq2], :, :]) + np.log(R_real[[freq1, freq2], :, :]) + - # # 2 * water_attenuation * R_real[[freq1, freq2], :, :]) - # # elif (stg.BS_stream_bed_pre_process_average.size == 0) and (stg.BS_stream_bed_pre_process_SNR.size == 0): - # # stg.FCB = (np.log(stg.BS_stream_bed[[freq1, freq2], :, :]) + np.log(R_real[[freq1, freq2], :, :]) + - # # 2 * water_attenuation * R_real[[freq1, freq2], :, :]) - # # elif stg.BS_stream_bed_pre_process_SNR.size == 0: - # # stg.FCB = (np.log(stg.BS_stream_bed_pre_process_average[[freq1, freq2], :, :]) + np.log(R_real[[freq1, freq2], :, :]) + - # # 2 * water_attenuation * R_real[[freq1, freq2], :, :]) - # # else: - # # stg.FCB = (np.log(stg.BS_stream_bed_pre_process_SNR[[freq1, freq2], :, :]) + np.log(R_real[[freq1, freq2], :, :]) + - # # 2 * water_attenuation * R_real[[freq1, freq2], :, :]) - # # - # # print(f"FCB shape : {stg.FCB.shape}") - # # - # # y1 = stg.FCB[freq1, 5:138, t_sample_ind[-1][0][0]] - # # x1 = stg.r[freq1, 5:138] - # # lin_reg_compute1 = stats.linregress(x1, y1) - # # - # # y2 = stg.FCB[freq2, 5:138, t_sample_ind[-1][0][0]] - # # x2 = stg.r[freq2, 5:138] - # # lin_reg_compute2 = stats.linregress(x2, y2) - # # - # # print(f"lin_reg_compute1 : {lin_reg_compute1}") - # # print(f"lin_reg_compute2 : {lin_reg_compute2}") - # # - # # fig, ax = plt.subplots(nrows=1, ncols=2) - # # ax[0].plot(x1, y1, ls='solid', c='k') - # # ax[0].plot(x1, x1*lin_reg_compute1.slope + lin_reg_compute1.intercept, ls='dashed', c='b') - # # ax[0].set_xlabel("Distance from transducer (m)") - # # ax[0].set_ylabel("FCB") - # # ax[0].set_title("Frequency 500kHz") - # # ax[1].plot(x2, y2, ls='solid', c='k') - # # ax[1].plot(x2, x2*lin_reg_compute2.slope + lin_reg_compute2.intercept, ls='solid', c='r') - # # ax[1].set_xlabel("Distance from transducer (m)") - # # ax[1].set_ylabel("FCB") - # # ax[1].set_title("Frequency 1MHz") - # # plt.show() - # # - # # alpha_s_freq1 , alpha_s_freq2 = -0.5*lin_reg_compute1.slope, -0.5*lin_reg_compute2.slope - # # alpha_s_freq1 = 0.35107724188865586 - # # alpha_s_freq2 = 0.37059368399238274 - # print(f"alpha_s_freq1 = {alpha_s_freq1}, alpha_s_freq2 = {alpha_s_freq2}") - # - # range_lin_interp, M_profile_fine = self.inv_hc.M_profile_SCC_fine_interpolated( - # sample_depth=-stg.sample_depth[:], - # M_profile=stg.Ctot_fine[:], - # range_cells=stg.r[0, :], - # r_bottom=np.array([])) # stg.r_bottom[t_sample_ind[0][0]] is empty - # # M_profile_fine = M_profile_fine[:len(range_lin_interp)] - # # range_lin_interp, M_profile_fine = 3.2, 6.5 - # - # print(f"range_lin_interp : {range_lin_interp}") - # print(f"M_profile_fine : {M_profile_fine}") - # - # # zeta_freq1, zeta_freq2 = (alpha_s_freq1 / (M_profile_fine[0]*(3.19127224 - 0.52102404)), - # # alpha_s_freq2 / (M_profile_fine[0]*(3.19127224 - 0.52102404))) - # zeta_freq1, zeta_freq2 = ( - # self.inv_hc.zeta(alpha_s=alpha_s_freq1, r=stg.r[freq1, :], M_profile_fine=M_profile_fine), - # self.inv_hc.zeta(alpha_s=alpha_s_freq2, r=stg.r[freq2, :], M_profile_fine=M_profile_fine)) - # # zeta_freq1, zeta_freq2 = zeta_freq1*1e-8, zeta_freq2*1e-8 - # # zeta_freq1 = 0.06417348381928434 - # # zeta_freq2 = 0.06774089842814904 - # # zeta_freq1, zeta_freq2 = 0.03018602, 0.05496619 - # print(f"zeta_freq1 = {zeta_freq1}, zeta_freq2 = {zeta_freq2}") - # - # # zeta_freq1, zeta_freq2 = 1e-10*self.inv_hc.zeta(ind=1), 1e1*self.inv_hc.zeta(ind=2) - # # print(f"zeta_freq1 = {zeta_freq1}, zeta_freq2 = {zeta_freq2}") - # - # # --- Fill spinboxes with values of parameters --- - # self.spinbox_ks_freq1.setValue(ks_freq1) - # self.spinbox_ks_freq2.setValue(ks_freq2) - # self.spinbox_sv_freq1.setValue(sv_freq1) - # self.spinbox_sv_freq2.setValue(sv_freq2) - # self.spinbox_X.setValue(X_exponent) - # self.spinbox_alphas_freq1.setValue(alpha_s_freq1) - # self.spinbox_alphas_freq2.setValue(alpha_s_freq2) - # self.spinbox_zeta_freq1.setValue(zeta_freq1) - # self.spinbox_zeta_freq2.setValue(zeta_freq2) - # - # # fig, ax = plt.subplots(nrows=2, ncols=1) - # # pcm1 = ax[0].pcolormesh(stg.t[0, :], -stg.r[0, :], J_freq1, - # # cmap='rainbow', shading='gouraud') - # # cbar1 = fig.colorbar(pcm1, ax=ax[0], shrink=1, location='right') - # # cbar1.set_label(label='J (/m', rotation=270, labelpad=15) - # # pcm2 = ax[1].pcolormesh(stg.t[0, :], -stg.r[0, :], J_freq2, - # # cmap='rainbow', shading='gouraud') - # # cbar2 = fig.colorbar(pcm2, ax=ax[1], shrink=1, location='right') - # # cbar2.set_label(label='J (/m', rotation=270, labelpad=15) - # # fig.supxlabel("Time (sec)", fontsize=10) - # # fig.supylabel("Depth (m)", fontsize=10) - # # plt.show() - # - # stg.VBI_cross_section = self.inv_hc.VBI_cross_section(stg.freq[freq1], stg.freq[freq2], - # zeta_freq1, zeta_freq2, - # J_freq1, J_freq2, - # stg.r_2D[freq2, :, :stg.t.shape[1]], - # alpha_w_freq1, alpha_w_freq2, - # X_exponent) - # - # - # - # stg.SSC_fine = self.inv_hc.SSC_fine(zeta_freq2, stg.r_2D[freq2, :, :stg.t.shape[1]], - # stg.VBI_cross_section, stg.freq[freq2], X_exponent, J_freq2, - # np.full(shape=(stg.r.shape[1], stg.t.shape[1]), fill_value=alpha_w_freq2)) - # # stg.SSC_fine = self.inv_hc.SSC_fine(stg.zeta[int(self.combobox_frequency_SSC.currentIndex())], - # # stg.r_2D[int(stg.frequency_to_compute_SSC[0]), :, :stg.t.shape[1]], - # # stg.VBI_cross_section, - # # stg.frequency_to_compute_SSC[1], - # # stg.X_exponent, - # # stg.J_cross_section[self.combobox_frequency_SSC.currentIndex(), :, :]) - # # print("SSC fine shape ", stg.SSC_fine.shape) - # - # stg.SSC_sand = self.inv_hc.SSC_sand(stg.VBI_cross_section, stg.freq[freq2], X_exponent, ks_freq2) - # # stg.SSC_sand = self.inv_hc.SSC_sand(stg.VBI_cross_section, - # # stg.frequency_to_compute_SSC[1], - # # stg.X_exponent, - # # stg.ks) - # - # # print("SSC sand shape ", stg.SSC_sand.shape) - # - # # def plot_SSC_2D_fields(self): - # # - # # if self.canvas_SSC_2D_field == None: - # # - # # self.figure_SSC_2D_field, self.axis_SSC_2D_field = plt.subplots(nrows=2, ncols=1, layout="constrained") - # # self.canvas_SSC_2D_field = FigureCanvas(self.figure_SSC_2D_field) - # # self.verticalLayout_groupbox_SSC_2D_field.addWidget(self.canvas_SSC_2D_field) - # # - # # self.plot_SSC_fine() - # # self.plot_SSC_sand() - # # - # # else: - # # - # # self.verticalLayout_groupbox_SSC_2D_field.removeWidget(self.canvas_SSC_2D_field) - # # self.verticalLayout_groupbox_SSC_2D_field.addWidget(self.canvas_SSC_2D_field) - # # - # # self.plot_SSC_fine() - # # self.plot_SSC_sand() - # - # # def update_plot_SSC_fine_and_sand(self): - # # self.verticalLayout_groupbox_SSC_2D_field.removeWidget(self.canvas_SSC_2D_field) - # # - # # self.figure_SSC_2D_field, self.axis_SSC_2D_field = plt.subplots(nrows=2, ncols=1, layout="constrained") - # # self.canvas_SSC_2D_field = FigureCanvas(self.figure_SSC_2D_field) - # # self.verticalLayout_groupbox_SSC_2D_field.addWidget(self.canvas_SSC_2D_field) - # # - # # self.plot_SSC_fine() - # # self.plot_SSC_sand() - # - # # def plot_SSC_fine(self): - # # - # # self.slider.setMaximum(stg.t.shape[1]) - # # - # # self.figure_SSC_fine.clf() - # # self.verticalLayout_groupbox_plot_SSC_fine.removeWidget(self.canvas_SSC_fine) - # # - # # self.figure_SSC_fine, self.axis_SSC_fine = plt.subplots(nrows=1, ncols=1, layout="constrained") - # # self.canvas_SSC_fine = FigureCanvas(self.figure_SSC_fine) - # # self.verticalLayout_groupbox_plot_SSC_fine.addWidget(self.canvas_SSC_fine) - # # - # # # val_min = 1e-2 - # # # val_max = 15 - # # val_min = np.nanmin(stg.SSC_fine) - # # val_max = np.nanmax(stg.SSC_fine) - # # # print('val_min fine = ', val_min) - # # # print('val_max fine =', val_max) - # # # print('val_min fine = ', np.nanmin(stg.VBI_cross_section)) - # # # print('val_max fine =', np.nanmax(stg.VBI_cross_section)) - # # # if val_min == 0: - # # # val_min = 0.5 - # # # print('val_min update =', val_min) - # # - # # # pcm_SSC_fine = self.axis_SSC_2D_field[0].pcolormesh(stg.t[0, :], - # # # -stg.r[0, :], - # # # stg.SSC_fine, - # # # # np.log(stg.VBI_cross_section/1.1932980954310682e-27), - # # # # cmap='jet', - # # # # vmin=val_min, vmax=val_max) - # # # cmap = 'rainbow', - # # # norm=LogNorm(vmin=1e-1, vmax=15)) - # # # # shading='gouraud') - # # if stg.ABS_name == "Aquascat 1000R": - # # - # # pcm_SSC_fine = self.axis_SSC_fine.pcolormesh(stg.t[0, :], - # # -stg.r[0, :], - # # stg.SSC_fine, - # # cmap='rainbow', - # # norm=LogNorm(vmin=1e0, vmax=15), - # # shading='gouraud') - # # - # # cbar_SSC_fine = self.figure_SSC_fine.colorbar(pcm_SSC_fine, ax=self.axis_SSC_fine, shrink=1, - # # location='right') - # # cbar_SSC_fine.set_label(label='Fine SSC (g/L', rotation=270, labelpad=15) - # # - # # elif stg.ABS_name == "UB-SediFlow": - # # pcm_SSC_fine = self.axis_SSC_fine.pcolormesh(stg.t[0, :], - # # -stg.r[0, :], - # # stg.SSC_fine, - # # cmap='rainbow', - # # norm=LogNorm(vmin=1e-2, vmax=10), - # # shading='gouraud') - # # - # # - # # if stg.r_bottom.size != 0: - # # self.axis_SSC_fine.plot(stg.t[0, :], - # # -stg.r_bottom, - # # color='black', linewidth=1, linestyle="solid") - # # # self.axis_SSC_2D_field[0].plot(stg.t[int(stg.frequency_to_compute_SSC[0]), :], - # # # -stg.r_bottom, - # # # color='black', linewidth=1, linestyle="solid") - # # - # # if self.combobox_fig_choice.currentText() == "Inverted SSC fine vertical profile": - # # self.axis_SSC_fine.plot(stg.t[0, self.slider.value() - 1] * np.ones(stg.r.shape[1]), - # # -stg.r[0, :], - # # color='black', linestyle="solid", linewidth=2) - # # - # # self.figure_SSC_fine.supxlabel("Time (sec)", fontsize=10) - # # self.figure_SSC_fine.supylabel("Depth (m)", fontsize=10) - # # self.figure_SSC_fine.canvas.draw_idle() - # # - # # def plot_SSC_sand(self): - # # - # # self.slider.setMaximum(stg.t.shape[1]) - # # - # # self.figure_SSC_sand.clf() - # # self.verticalLayout_groupbox_plot_SSC_sand.removeWidget(self.canvas_SSC_sand) - # # - # # self.figure_SSC_sand, self.axis_SSC_sand = plt.subplots(nrows=1, ncols=1, layout="constrained") - # # self.canvas_SSC_sand = FigureCanvas(self.figure_SSC_sand) - # # self.verticalLayout_groupbox_plot_SSC_sand.addWidget(self.canvas_SSC_sand) - # # - # # val_min = 1e-2 - # # val_max = 2 - # # val_min = np.nanmin(stg.SSC_sand) - # # val_max = np.nanmax(stg.SSC_sand) - # # # val_min = np.nanmin(np.log(stg.VBI_cross_section)) - # # # val_max = np.nanmax(np.log(stg.VBI_cross_section)) - # # # print('val_min sand = ', val_min) - # # # print('val_max sand =', val_max) - # # # print('val_min sand = ', np.nanmin(stg.VBI_cross_section)) - # # # print('val_max sand = ', np.nanmax(stg.VBI_cross_section)) - # # if val_min == 0: - # # val_min = 0.5 - # # # print('val_min update =', val_min) - # # - # # # print(stg.SSC_sand) - # # - # # if stg.ABS_name == "Aquascat 1000R": - # # - # # pcm_SSC_sand = self.axis_SSC_sand.pcolormesh(stg.t[0, :], - # # -stg.r[0, :], - # # (stg.SSC_sand), - # # cmap='rainbow', - # # # vmin=-60, vmax=-45) - # # # vmin=1e-2, vmax=10) - # # # vmin=val_min, vmax=val_max, - # # norm=LogNorm(vmin=1e-2, vmax=2), - # # shading='gouraud') - # # - # # cbar_SSC_sand = self.figure_SSC_sand.colorbar(pcm_SSC_sand, ax=self.axis_SSC_sand, shrink=1, - # # location='right') - # # cbar_SSC_sand.set_label(label='Sand SSC (g/L', rotation=270, labelpad=15) - # # - # # elif stg.ABS_name == "UB-SediFlow": - # # pcm_SSC_sand = self.axis_SSC_sand.pcolormesh(stg.t[0, :], - # # -stg.r[0, 5:155], - # # (stg.SSC_sand[5:155, :]), - # # cmap="plasma", - # # # cmap='rainbow', - # # vmin=0, vmax=10, - # # # vmin=1e-2, vmax=10) - # # # vmin=val_min, vmax=val_max, - # # # norm=LogNorm(vmin=1e-2, vmax=1), - # # shading='gouraud') - # # # self.axis_SSC_2D_field[1].plot(stg.t[1, 52] * np.ones(len(stg.r[1, 5:152])), -stg.r[1, 5:152], - # # # c='b', ls='solid', lw=2) - # # # self.axis_SSC_2D_field[1].plot(stg.t[1, ] * np.ones(len(stg.r[1, 5:152])), -stg.r[1, 5:152], - # # # c='red', ls='solid', lw=2) - # # # self.axis_SSC_2D_field[1].plot(stg.t[1, 777] * np.ones(len(stg.r[1, 5:152])), -stg.r[1, 5:152], - # # # c='red', ls='solid', lw=2) - # # - # # # pcm_SSC_sand = self.axis_SSC_2D_field[1].pcolormesh(stg.t[int(stg.frequency_to_compute_SSC[0]), :], - # # # -stg.r[int(stg.frequency_to_compute_SSC[0]), :], - # # # stg.SSC_sand, - # # # cmap='rainbow', - # # # # vmin=val_min, vmax=val_max, - # # # norm=LogNorm(vmin=1e-2, vmax=2), - # # # shading='gouraud') - # # - # # if stg.r_bottom.size: - # # self.axis_SSC_sand.plot(stg.t[0, :], - # # -stg.r_bottom, - # # color='black', linewidth=1, linestyle="solid") - # # # self.axis_SSC_2D_field[1].plot(stg.t[int(stg.frequency_to_compute_SSC[0]), :], - # # # -stg.r_bottom, - # # # color='black', linewidth=1, linestyle="solid") - # # - # # if self.combobox_fig_choice.currentText() == "Inverted SSC sand vertical profile": - # # self.axis_SSC_sand.plot(stg.t[0, self.slider.value() - 1] * np.ones(stg.r.shape[1]), - # # -stg.r[0, :], - # # color='black', linestyle="solid", linewidth=2) - # # - # # self.figure_SSC_sand.supxlabel("Time (sec)", fontsize=10) - # # self.figure_SSC_sand.supylabel("Depth (m)", fontsize=10) - # # self.figure_SSC_sand.canvas.draw_idle() - # - # def plot_inverted_SSC_sand_vertical_profile(self): - # - # # self.combobox_fig_choice.setCurrentIndex(1) - # - # if self.combobox_fig_choice.currentText() == "Inverted SSC sand vertical profile": - # - # self.axis_SSC_sand_vertical_profile.cla() - # - # # --- Plot inverted SSC vertical profile --- - # self.axis_SSC_sand_vertical_profile.plot(stg.SSC_sand[:, self.slider.value()-1], - # -stg.r[self.combobox_freq2.currentIndex(), :], - # color='black', ls='solid') - # - # self.axis_SSC_sand_vertical_profile.set_xlabel('Sand concentration (g/l)', weight='bold') - # self.axis_SSC_sand_vertical_profile.set_ylabel('Depth (m)', weight='bold') - # - # self.axis_SSC_sand_vertical_profile.set_xlim(0, 10) - # - # self.figure_SSC_sand_vertical_profile.canvas.draw_idle() - # - # def plot_inverted_SSC_fine_vertical_profile(self): - # - # if self.combobox_fig_choice.currentText() == "Inverted SSC vs Measured SSC": - # - # self.axis_SSC_fine_vertical_profile.cla() - # - # # --- Plot inverted SSC vertical profile --- - # self.axis_SSC_fine_vertical_profile.plot(stg.r[self.combobox_freq2.currentIndex(), :], - # stg.SSC_sand[:, self.slider.value()-1], - # color='black', ls='solid') - # - # self.axis_SSC_fine_vertical_profile.set_xlabel('Sand concentration (g/l)', weight='bold') - # self.axis_SSC_fine_vertical_profile.set_ylabel('Depth (m)', weight='bold') - # - # self.figure_SSC_fine_vertical_profile.canvas.draw_idle() - # - # def plot_inverted_SSC_vs_measured_SSC(self): - # - # if self.combobox_fig_choice.currentText() == "Inverted SSC vs Measured SSC": - # - # self.figure_SSC_measured_vs_inverted.clf() - # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.canvas_SSC_measured_vs_inverted) - # - # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget(self.canvas_SSC_measured_vs_inverted) - # - # sample_depth_position = [] - # for i in range(stg.sample_depth.shape[0]): - # sample_depth_position.append( - # np.where(np.abs(stg.r[0, :] + stg.sample_depth[i]) == - # np.min(np.abs(stg.r[0, :] + stg.sample_depth[i])))[0][0]) - # - # sample_time_position = [] - # for j in range(stg.sample_time.shape[0]): - # sample_time_position.append( - # np.where(np.abs(stg.t[0, :] - stg.sample_time[j]) == - # np.min(np.abs(stg.t[0, :] - stg.sample_time[j])))[0][0]) - # - # # print("Ctot fine : ", stg.Ctot_fine) - # # print("SCC fine : ", stg.SSC_fine[sample_depth_position, sample_time_position]) - # # print("Ctot sand : ", stg.Ctot_sand) - # # print("SCC sand : ", stg.SSC_sand[sample_depth_position, sample_time_position]) - # - # self.axis_SSC_measured_vs_inverted.cla() - # - # self.axis_SSC_measured_vs_inverted.plot(stg.Ctot_fine, stg.SSC_fine[sample_depth_position, sample_time_position], ls=" ", marker='v', color='black', label='Fine SSC') - # self.axis_SSC_measured_vs_inverted.plot(stg.Ctot_sand, - # stg.SSC_sand[sample_depth_position, sample_time_position], - # ls=" ", marker='x', color='black', label='Sand SSC') - # - # self.axis_SSC_measured_vs_inverted.set_xscale('log') - # self.axis_SSC_measured_vs_inverted.set_yscale('log') - # self.axis_SSC_measured_vs_inverted.plot([0, 10], [0, 10], color='black', lw=1) - # self.axis_SSC_measured_vs_inverted.set_xlabel('Measured SSC (g/l)', weight='bold') - # self.axis_SSC_measured_vs_inverted.set_ylabel('Inverse SSC (g/l)', weight='bold') - # self.axis_SSC_measured_vs_inverted.legend() - # - # # def insert_slider_for_vertical_profile_figure_area(self): - # # - # # if ((self.combobox_fig_choice.currentText() == "Inverted SSC fine vertical profile") or - # # (self.combobox_fig_choice.currentText() == "Inverted SSC sand vertical profile")): - # # - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.canvas_SSC_measured_vs_inverted) - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget(self.canvas_SSC_measured_vs_inverted) - # # - # # # --- Slider for moving the profile --- - # # self.horizontalLayout_slider = QHBoxLayout() - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addLayout(self.horizontalLayout_slider) - # # - # # self.pushbutton_slider_left = QPushButton() - # # self.pushbutton_slider_left.setIcon(self.icon_triangle_left) - # # self.horizontalLayout_slider.addWidget(self.pushbutton_slider_left) - # # - # # self.pushbutton_slider_left.clicked.connect(self.slide_profile_number_to_left) - # # - # # self.pushbutton_slider_right = QPushButton() - # # self.pushbutton_slider_right.setIcon(self.icon_triangle_right) - # # self.horizontalLayout_slider.addWidget(self.pushbutton_slider_right) - # # - # # self.pushbutton_slider_right.clicked.connect(self.slide_profile_number_to_right) - # # - # # self.lineEdit_slider = QLineEdit() - # # self.lineEdit_slider.setText("1") - # # self.lineEdit_slider.setFixedWidth(50) - # # self.horizontalLayout_slider.addWidget(self.lineEdit_slider) - # # - # # self.lineEdit_slider.returnPressed.connect(self.profile_number_on_lineEdit) - # # - # # self.slider = QSlider() - # # self.horizontalLayout_slider.addWidget(self.slider, 9) - # # - # # self.slider.setOrientation(Qt.Horizontal) - # # self.slider.setCursor(Qt.OpenHandCursor) - # # self.slider.setMinimum(1) - # # self.slider.setMaximum(stg.t.shape[1]) - # # self.slider.setTickInterval(1) - # # self.slider.setValue(1) - # # - # # self.slider.valueChanged.connect(self.update_lineEdit_by_moving_slider) - # # - # # self.slider.valueChanged.connect(self.plot_inverted_SSC_fine_vertical_profile) - # # - # # self.slider.valueChanged.connect(self.plot_SSC_sand) - # # - # # self.plot_inverted_SSC_fine_vertical_profile() - # # self.update_plot_SSC_fine_and_sand() - # # - # # elif self.combobox_fig_choice.currentText() == "Inverted SSC vs Measured SSC": - # # - # # self.figure_SSC_sand.clf() - # # self.figure_SSC_fine.clf() - # # - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.canvas_SSC_sand) - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.canvas_SSC_fine) - # # - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.pushbutton_slider_right) - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.pushbutton_slider_left) - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.lineEdit_slider) - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.removeWidget(self.slider) - # # - # # self.verticalLayout_groupbox_SSC_profiles_or_measured_vs_inverted.addWidget(self.canvas_SSC_measured_vs_inverted) - # # - # # self.figure_SSC_measured_vs_inverted.canvas.draw_idle() - # - # - #