SIM/qucs_s
1
0
Fork 0
mirror of https://github.com/ra3xdh/qucs_s synced 2025-03-28 21:13:26 +00:00
Code Issues Packages Projects Releases Wiki Activity
qucs_s/qucs-s-spar-viewer/qucs-s-spar-viewer.cpp
Vadim Kuznetsov b0523fa392
Merge pull request #1133 from andresmmera/SPAR_Viewer_Improvements 
S-parameter Viewer: Some improvements
2024-12-16 15:49:29 +01:00

3405 lines
127 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* qucs-s-spar-viewer.cpp - S-parameter viewer for Qucs-S
*
* copyright (C) 2024 Andres Martinez-Mera <andresmartinezmera@gmail.com>
*
* This 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 2, or (at your option)
* any later version.
*
* This software 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 package; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "qucs-s-spar-viewer.h"
#include <QPixmap>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGroupBox>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QLabel>
#include <QPushButton>
#include <QLineEdit>
#include <QComboBox>
#include <QValidator>
#include <QClipboard>
#include <QApplication>
#include <QDebug>
#include <QLineSeries>
Qucs_S_SPAR_Viewer::Qucs_S_SPAR_Viewer()
{
QWidget *centralWidget = new QWidget(this);
setCentralWidget(centralWidget);
setWindowIcon(QPixmap(":/bitmaps/big.qucs.xpm"));
setWindowTitle("Qucs S-parameter Viewer " PACKAGE_VERSION);
QMenu *fileMenu = new QMenu(tr("&File"));
QAction *fileQuit = new QAction(tr("&Quit"), this);
fileQuit->setShortcut(QKeySequence::Quit);
connect(fileQuit, SIGNAL(triggered(bool)), SLOT(slotQuit()));
QAction *fileOpenSession = new QAction(tr("&Open session file"), this);
fileOpenSession->setShortcut(QKeySequence::Open);
connect(fileOpenSession, SIGNAL(triggered(bool)), SLOT(slotLoadSession()));
QAction *fileSaveAsSession = new QAction(tr("&Save session as ..."), this);
fileSaveAsSession->setShortcut(QKeySequence::SaveAs);
connect(fileSaveAsSession, SIGNAL(triggered(bool)), SLOT(slotSaveAs()));
QAction *fileSaveSession = new QAction(tr("&Save session"), this);
fileSaveSession->setShortcut(QKeySequence::Save);
connect(fileSaveSession, SIGNAL(triggered(bool)), SLOT(slotSave()));
fileMenu->addAction(fileOpenSession);
fileMenu->addAction(fileSaveSession);
fileMenu->addAction(fileSaveAsSession);
recentFilesMenu = fileMenu->addMenu("Recent Files");
connect(recentFilesMenu, &QMenu::aboutToShow, this, &Qucs_S_SPAR_Viewer::updateRecentFilesMenu);
fileMenu->addAction(fileQuit);
QMenu *helpMenu = new QMenu(tr("&Help"));
QAction *helpHelp = new QAction(tr("&Help"), this);
helpHelp->setShortcut(Qt::Key_F1);
helpMenu->addAction(helpHelp);
connect(helpHelp, SIGNAL(triggered(bool)), SLOT(slotHelpIntro()));
QAction *helpAbout = new QAction(tr("&About"), this);
helpMenu->addAction(helpAbout);
connect(helpAbout, SIGNAL(triggered(bool)), SLOT(slotHelpAbout()));
helpMenu->addSeparator();
QAction * helpAboutQt = new QAction(tr("About Qt..."), this);
helpMenu->addAction(helpAboutQt);
connect(helpAboutQt, SIGNAL(triggered(bool)), SLOT(slotHelpAboutQt()));
menuBar()->addMenu(fileMenu);
menuBar()->addSeparator();
menuBar()->addMenu(helpMenu);
// Set frequency units
frequency_units << "Hz" << "kHz" << "MHz" << "GHz";
// Left panel
QScrollArea *scrollArea_Files = new QScrollArea();
FileList_Widget = new QWidget();
QWidget *FilesGroup = new QWidget();
FilesGrid = new QGridLayout(FileList_Widget);
vLayout_Files = new QVBoxLayout(FilesGroup);
QWidget *Buttons = new QWidget();
QHBoxLayout *hLayout_Files_Buttons = new QHBoxLayout(Buttons);
Button_Add_File = new QPushButton("Add file", this);
Button_Add_File->setStyleSheet("QPushButton {background-color: green;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_Add_File, SIGNAL(clicked()), SLOT(addFile()));
Delete_All_Files = new QPushButton("Delete all", this);
Delete_All_Files->setStyleSheet("QPushButton {background-color: red;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Delete_All_Files, SIGNAL(clicked()), SLOT(removeAllFiles()));
hLayout_Files_Buttons->addWidget(Button_Add_File);
hLayout_Files_Buttons->addWidget(Delete_All_Files);
scrollArea_Files->setWidget(FileList_Widget);
scrollArea_Files->setWidgetResizable(true);
vLayout_Files->addWidget(scrollArea_Files, Qt::AlignTop);
vLayout_Files->addWidget(Buttons, Qt::AlignBottom);
vLayout_Files->setStretch(0, 3);
vLayout_Files->setStretch(1, 1);
// Chart settings
chart = new QChart;
chart->createDefaultAxes();
QChartView *chartView = new QChartView(chart);
chartView->setRenderHint(QPainter::Antialiasing);
setCentralWidget(nullptr);
dockChart = new QDockWidget("Chart", this);
dockChart->setWidget(chartView);
dockChart->setAllowedAreas(Qt::AllDockWidgetAreas);
addDockWidget(Qt::LeftDockWidgetArea, dockChart);
// These are two maximum markers to find the lowest and the highest frequency in the data samples.
// They are used to prevent the user from zooming out too much
f_min = 1e20;
f_max = -1;
y_min = 1e4;
y_max = -1e4;
// Load default colors
default_colors.append(QColor(Qt::red));
default_colors.append(QColor(Qt::blue));
default_colors.append(QColor(Qt::darkGreen));
// Right panel
QWidget * SettingsGroup = new QWidget();
QGridLayout * SettingsGrid = new QGridLayout(SettingsGroup);
SettingsGrid->setSpacing(5);
SettingsGrid->setColumnMinimumWidth(3, 20);
// First row (min, max, div)
QLabel *axis_min = new QLabel("<b>min</b>");
SettingsGrid->addWidget(axis_min, 0, 1, Qt::AlignCenter);
QLabel *axis_max = new QLabel("<b>max</b>");
SettingsGrid->addWidget(axis_max, 0, 2, Qt::AlignCenter);
QLabel *axis_div = new QLabel("<b>div</b>");
SettingsGrid->addWidget(axis_div, 0, 3, Qt::AlignCenter);
// x-axis
QLabel *x_axis = new QLabel("<b>x-axis</b>");
SettingsGrid->addWidget(x_axis, 1, 0);
QSpinBox_x_axis_min = new QDoubleSpinBox();
QSpinBox_x_axis_min->setMinimum(0.1);
QSpinBox_x_axis_min->setMaximum(1000000);
QSpinBox_x_axis_min->setValue(0);
QSpinBox_x_axis_min->setDecimals(1);
QSpinBox_x_axis_min->setSingleStep(0.1);
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
SettingsGrid->addWidget(QSpinBox_x_axis_min, 1, 1);
QSpinBox_x_axis_max = new QDoubleSpinBox();
QSpinBox_x_axis_max->setMinimum(0.1);
QSpinBox_x_axis_max->setMaximum(1000000);
QSpinBox_x_axis_max->setValue(1000);
QSpinBox_x_axis_max->setDecimals(1);
QSpinBox_x_axis_max->setSingleStep(0.1);
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
SettingsGrid->addWidget(QSpinBox_x_axis_max, 1, 2);
// Available x-axis div
QComboBox_x_axis_div = new QComboBox();
available_x_axis_div.clear();
available_x_axis_div << 2000 << 1000 << 500 << 400 << 200 << 100 << 50 << 25 << 20 << 10 << 5 << 1 << 0.5 << 0.2 << 0.1;
for (const double &value : qAsConst(available_x_axis_div)) {
QComboBox_x_axis_div->addItem(QString::number(value));
}
connect(QComboBox_x_axis_div, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
SettingsGrid->addWidget(QComboBox_x_axis_div, 1, 3);
QCombobox_x_axis_units = new QComboBox();
QCombobox_x_axis_units->addItems(frequency_units);
QCombobox_x_axis_units->setCurrentIndex(2);
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(changeFreqUnits()));
SettingsGrid->addWidget(QCombobox_x_axis_units, 1, 4);
// y-axis
QLabel *y_axis = new QLabel("<b>y-axis</b>");
SettingsGrid->addWidget(y_axis, 2, 0);
QSpinBox_y_axis_min = new QDoubleSpinBox();
QSpinBox_y_axis_min->setMinimum(-150);
QSpinBox_y_axis_min->setValue(-50);
QSpinBox_y_axis_min->setDecimals(1);
connect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
SettingsGrid->addWidget(QSpinBox_y_axis_min, 2, 1);
QSpinBox_y_axis_max = new QDoubleSpinBox();
QSpinBox_y_axis_max->setMinimum(-150);
QSpinBox_y_axis_max->setValue(0);
QSpinBox_y_axis_max->setDecimals(1);
connect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
SettingsGrid->addWidget(QSpinBox_y_axis_max, 2, 2);
// Available x-axis div
QComboBox_y_axis_div = new QComboBox();
available_y_axis_div.clear();
available_y_axis_div << 50 << 25 << 20 << 10 << 5 << 2 << 1 << 0.5 << 0.2 << 0.1;
for (const double &value : qAsConst(available_y_axis_div)) {
QComboBox_y_axis_div->addItem(QString::number(value));
}
connect(QComboBox_y_axis_div, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
SettingsGrid->addWidget(QComboBox_y_axis_div, 2, 3);
/*QCombobox_y_axis_units = new QComboBox();
QCombobox_y_axis_units->addItem("dB");
SettingsGrid->addWidget(QCombobox_y_axis_units, 2, 4);*/
QLabel *y2_axis = new QLabel("<b>y2-axis</b>");
SettingsGrid->addWidget(y2_axis, 3, 0);
QSpinBox_y2_axis_min = new QDoubleSpinBox();
QSpinBox_y2_axis_min->setMinimum(0);
SettingsGrid->addWidget(QSpinBox_y2_axis_min, 3, 1);
QSpinBox_y2_axis_max = new QDoubleSpinBox();
QSpinBox_y2_axis_max->setMinimum(0);
SettingsGrid->addWidget(QSpinBox_y2_axis_max, 3, 2);
QSpinBox_y2_axis_div = new QDoubleSpinBox();
QSpinBox_y2_axis_div->setMinimum(0);
SettingsGrid->addWidget(QSpinBox_y2_axis_div, 3, 3);
/*QCombobox_y2_axis_units = new QComboBox();
QCombobox_y2_axis_units->addItem("dB");
SettingsGrid->addWidget(QCombobox_y2_axis_units, 3, 4);*/
// Hide y2 axis (temporary)
y2_axis->hide();
QSpinBox_y2_axis_min->hide();
QSpinBox_y2_axis_max->hide();
QSpinBox_y2_axis_div->hide();
// QCombobox_y2_axis_units->hide();
// Lock axis settings button
Lock_axis_settings_Button = new QPushButton("Lock Axes");
connect(Lock_axis_settings_Button, SIGNAL(clicked(bool)), SLOT(lock_unlock_axis_settings()));
lock_axis = false;
SettingsGrid->addWidget(Lock_axis_settings_Button, 0, 4);
QWidget * TracesGroup = new QWidget();
QVBoxLayout *Traces_VBox = new QVBoxLayout(TracesGroup);
// Trace addition box
QWidget * TraceSelection_Widget = new QWidget(); // Add trace
QGridLayout * DatasetsGrid = new QGridLayout(TraceSelection_Widget);
QLabel *dataset_label = new QLabel("<b>Dataset</b>");
DatasetsGrid->addWidget(dataset_label, 0, 0, Qt::AlignCenter);
QLabel *Traces_label = new QLabel("<b>Traces</b>");
DatasetsGrid->addWidget(Traces_label, 0, 1, Qt::AlignCenter);
QLabel *empty_label = new QLabel("<b>Empty</b>");
DatasetsGrid->addWidget(empty_label, 0, 2, Qt::AlignCenter);
empty_label->hide();
QCombobox_datasets = new QComboBox();
DatasetsGrid->addWidget(QCombobox_datasets, 1, 0);
connect(QCombobox_datasets, SIGNAL(currentIndexChanged(int)), SLOT(updateTracesCombo())); // Each time the dataset is changed it is needed to update the traces combo.
// This is needed when the user has data with different number of ports.
QCombobox_traces = new QComboBox();
DatasetsGrid->addWidget(QCombobox_traces, 1, 1);
Button_add_trace = new QPushButton("Add trace");
Button_add_trace->setStyleSheet("QPushButton {background-color: green;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_add_trace, SIGNAL(clicked()), SLOT(addTrace())); // Connect button with the handler
DatasetsGrid->addWidget(Button_add_trace, 1, 2);
// Trace management
// Titles
TracesList_Widget = new QWidget(); // Panel with the trace settings
QLabel * Label_Name = new QLabel("<b>Name</b>");
QLabel * Label_Color = new QLabel("<b>Color</b>");
QLabel * Label_LineStyle = new QLabel("<b>Line Style</b>");
QLabel * Label_LineWidth = new QLabel("<b>Width</b>");
QLabel * Label_Remove = new QLabel("<b>Remove</b>");
TracesGrid = new QGridLayout(TracesList_Widget);
TracesGrid->addWidget(Label_Name, 0, 0, Qt::AlignCenter);
TracesGrid->addWidget(Label_Color, 0, 1, Qt::AlignCenter);
TracesGrid->addWidget(Label_LineStyle, 0, 2, Qt::AlignCenter);
TracesGrid->addWidget(Label_LineWidth, 0, 3, Qt::AlignCenter);
TracesGrid->addWidget(Label_Remove, 0, 4, Qt::AlignCenter);
QScrollArea *scrollArea_Traces = new QScrollArea();
scrollArea_Traces->setWidget(TracesList_Widget);
scrollArea_Traces->setWidgetResizable(true);
Traces_VBox->addWidget(TraceSelection_Widget);
Traces_VBox->addWidget(scrollArea_Traces);
// Markers dock
QWidget * MarkersGroup = new QWidget();
QVBoxLayout *Markers_VBox = new QVBoxLayout(MarkersGroup);
// Trace addition box
QWidget * MarkerSelection_Widget = new QWidget();
MarkersGrid = new QGridLayout(MarkerSelection_Widget);
QLabel *Frequency_Marker_Label = new QLabel("<b>Frequency</b>");
MarkersGrid->addWidget(Frequency_Marker_Label, 0, 0, Qt::AlignCenter);
Button_add_marker = new QPushButton("Add marker");
Button_add_marker->setStyleSheet("QPushButton {background-color: green;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_add_marker, SIGNAL(clicked()), SLOT(addMarker())); // Connect button with the handler
MarkersGrid->addWidget(Button_add_marker, 0, 0);
Button_Remove_All_Markers = new QPushButton("Remove all");
Button_Remove_All_Markers->setStyleSheet("QPushButton {background-color: red;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_Remove_All_Markers, SIGNAL(clicked()), SLOT(removeAllMarkers())); // Connect button with the handler
MarkersGrid->addWidget(Button_Remove_All_Markers, 0, 1);
// Marker management
QWidget * MarkerList_Widget = new QWidget(); // Panel with the trace settings
QLabel * Label_Marker = new QLabel("<b>Marker</b>");
QLabel * Label_Freq_Marker = new QLabel("<b>Frequency</b>");
QLabel * Label_Freq_Scale_Marker = new QLabel("<b>Units</b>");
QLabel * Label_Remove_Marker = new QLabel("<b>Remove</b>");
MarkersGrid = new QGridLayout(MarkerList_Widget);
MarkersGrid->addWidget(Label_Marker, 0, 0, Qt::AlignCenter);
MarkersGrid->addWidget(Label_Freq_Marker, 0, 1, Qt::AlignCenter);
MarkersGrid->addWidget(Label_Freq_Scale_Marker, 0, 2, Qt::AlignCenter);
MarkersGrid->addWidget(Label_Remove_Marker, 0, 3, Qt::AlignCenter);
QScrollArea *scrollArea_Marker = new QScrollArea();
scrollArea_Marker->setWidget(MarkerList_Widget);
scrollArea_Marker->setWidgetResizable(true);
tableMarkers = new QTableWidget(1, 1, this);
Markers_VBox->addWidget(MarkerSelection_Widget);
Markers_VBox->addWidget(scrollArea_Marker);
Markers_VBox->addWidget(tableMarkers);
// Limits dock
QWidget * LimitsGroup = new QWidget();
QVBoxLayout *Limits_VBox = new QVBoxLayout(LimitsGroup);
// Limit addition box
QWidget * AddLimit_Widget = new QWidget(); // Add trace
LimitsGrid = new QGridLayout(AddLimit_Widget);
Button_add_Limit = new QPushButton("Add Limit");
Button_add_Limit->setStyleSheet("QPushButton {background-color: green;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_add_Limit, SIGNAL(clicked()), SLOT(addLimit())); // Connect button with the handler
LimitsGrid->addWidget(Button_add_Limit, 0, 0);
Button_Remove_All_Limits = new QPushButton("Remove all");
Button_Remove_All_Limits->setStyleSheet("QPushButton {background-color: red;\
border-style: outset;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
color: white;\
min-width: 10em;\
padding: 6px;\
}");
connect(Button_Remove_All_Limits, SIGNAL(clicked()), SLOT(removeAllLimits())); // Connect button with the handler
LimitsGrid->addWidget(Button_Remove_All_Limits, 0, 1);
QGroupBox * LimitSettings = new QGroupBox("Settings");
QGridLayout * LimitsSettingLayout = new QGridLayout(LimitSettings);
QLabel * LimitsOffsetLabel = new QLabel("<b>Limits Offset</>");
Limits_Offset = new QDoubleSpinBox();
Limits_Offset->setValue(0);
Limits_Offset->setSingleStep(0.1);
Limits_Offset->setMaximum(1e4);
Limits_Offset->setMinimum(-1e4);
connect(Limits_Offset, SIGNAL(valueChanged(double)), SLOT(updateTraces()));
LimitsSettingLayout->addWidget(LimitsOffsetLabel, 0, 0);
LimitsSettingLayout->addWidget(Limits_Offset, 0, 1);
// Limit management
QWidget * LimitList_Widget = new QWidget(); // Panel with the trace settings
QLabel * Label_Limit = new QLabel("<b>Limit</b>");
QLabel * Label_Limit_Start = new QLabel("<b>Start</b>");
QLabel * Label_Limit_Stop = new QLabel("<b>Stop</b>");
QLabel * Label_Remove_Limit = new QLabel("<b>Remove</b>");
LimitsGrid = new QGridLayout(LimitList_Widget);
LimitsGrid->addWidget(Label_Limit, 0, 0, Qt::AlignCenter);
LimitsGrid->addWidget(Label_Limit_Start, 0, 1, 1, 2, Qt::AlignCenter);
LimitsGrid->addWidget(Label_Limit_Stop, 0, 3, 1, 2, Qt::AlignCenter);
LimitsGrid->addWidget(Label_Remove_Limit, 0, 5, Qt::AlignCenter);
QScrollArea *scrollArea_Limits = new QScrollArea();
scrollArea_Limits->setWidget(LimitList_Widget);
scrollArea_Limits->setWidgetResizable(true);
Limits_VBox->addWidget(AddLimit_Widget);
Limits_VBox->addWidget(LimitSettings);
Limits_VBox->addWidget(scrollArea_Limits);
// Notes
Notes_Widget = new CodeEditor();
dockFiles = new QDockWidget("S-parameter files", this);
dockAxisSettings = new QDockWidget("Axis Settings", this);
dockTracesList = new QDockWidget("Traces List", this);
dockMarkers = new QDockWidget("Markers", this);
dockLimits = new QDockWidget("Limits", this);
dockNotes = new QDockWidget("Notes", this);
// Disable dock closing
dockChart->setFeatures(dockChart->features() & ~QDockWidget::DockWidgetClosable);
dockFiles->setFeatures(dockFiles->features() & ~QDockWidget::DockWidgetClosable);
dockAxisSettings->setFeatures(dockAxisSettings->features() & ~QDockWidget::DockWidgetClosable);
dockTracesList->setFeatures(dockTracesList->features() & ~QDockWidget::DockWidgetClosable);
dockMarkers->setFeatures(dockMarkers->features() & ~QDockWidget::DockWidgetClosable);
dockLimits->setFeatures(dockLimits->features() & ~QDockWidget::DockWidgetClosable);
dockNotes->setFeatures(dockLimits->features() & ~QDockWidget::DockWidgetClosable);
dockAxisSettings->setWidget(SettingsGroup);
dockTracesList->setWidget(TracesGroup);
dockFiles->setWidget(FilesGroup);
dockMarkers->setWidget(MarkersGroup);
dockLimits->setWidget(LimitsGroup);
dockNotes->setWidget(Notes_Widget);
addDockWidget(Qt::RightDockWidgetArea, dockAxisSettings);
addDockWidget(Qt::RightDockWidgetArea, dockTracesList);
addDockWidget(Qt::RightDockWidgetArea, dockFiles);
addDockWidget(Qt::RightDockWidgetArea, dockMarkers);
addDockWidget(Qt::RightDockWidgetArea, dockLimits);
addDockWidget(Qt::RightDockWidgetArea, dockNotes);
splitDockWidget(dockTracesList, dockAxisSettings, Qt::Vertical);
tabifyDockWidget(dockFiles, dockTracesList);
tabifyDockWidget(dockTracesList, dockMarkers);
tabifyDockWidget(dockMarkers, dockLimits);
tabifyDockWidget(dockMarkers, dockNotes);
dockFiles->raise();
setDockNestingEnabled(true);
// Set the height of the axis settings widget to its minimum. This makes the layout much clearer
int minHeight = dockAxisSettings->minimumSizeHint().height();
dockAxisSettings->setFixedHeight(minHeight);
setAcceptDrops(true);//Enable drag and drop feature to open files
loadRecentFiles();// Load "Recent Files" list
}
Qucs_S_SPAR_Viewer::~Qucs_S_SPAR_Viewer()
{
QSettings settings;
settings.setValue("recentFiles", QVariant::fromValue(recentFiles));
}
void Qucs_S_SPAR_Viewer::slotHelpIntro()
{
QMessageBox::about(this, tr("Qucs-S S-parameter Help"),
tr("This is a simple viewer for S-parameter data.\n"
"It can show several .snp files at a time in the "
"same diagram. Trace markers can also be added "
"so that the user can read the trace value at "
"at an specific frequency."));
}
void Qucs_S_SPAR_Viewer::slotHelpAboutQt()
{
QMessageBox::aboutQt(this, tr("About Qt"));
}
void Qucs_S_SPAR_Viewer::slotHelpAbout()
{
QMessageBox::about(this, tr("About..."),
"Qucs-S S-parameter Viewer Version " PACKAGE_VERSION+
tr("\nCopyright (C) 2024 by")+" Andrés Martínez Mera"
"\n"
"\nThis is free software; see the source for copying conditions."
"\nThere is NO warranty; not even for MERCHANTABILITY or "
"\nFITNESS FOR A PARTICULAR PURPOSE.\n\n");
}
void Qucs_S_SPAR_Viewer::slotQuit()
{
qApp->quit();
}
void Qucs_S_SPAR_Viewer::addFile()
{
QFileDialog dialog(this, QStringLiteral("Select S-parameter data files (.snp)"), QDir::homePath(),
tr("S-Parameter Files (*.s1p *.s2p *.s3p *.s4p);;All Files (*.*)"));
dialog.setFileMode(QFileDialog::ExistingFiles);
QStringList fileNames;
if (dialog.exec())
fileNames = dialog.selectedFiles();
addFiles(fileNames);
}
void Qucs_S_SPAR_Viewer::addFiles(QStringList fileNames)
{
int existing_files = this->datasets.size(); // Get the number of entries in the map
// Variables for reading the Touchstone data
QStringList values;
QString filename;
if (existing_files == 0){
// Reset limits
this->f_max = -1;
this->f_min = 1e30;
this->y_min = 1e30;
this->y_max = -1e30;
}
// Remove from the list of files those that already exist in the database
QStringList files_dataset = datasets.keys();
for (int i = 0; i < fileNames.length(); i++){
filename = QFileInfo(fileNames.at(i)).fileName();
// Check if this file already exists
QString new_filename = filename.left(filename.lastIndexOf('.'));
if (files_dataset.contains(new_filename)){
// Remove it from the list of new files to load
fileNames.removeAt(i);
// Pop up a warning
QMessageBox::information(
this,
tr("Warning"),
tr("This file is already in the dataset.") );
}
}
// Read files
for (int i = existing_files; i < existing_files+fileNames.length(); i++)
{
// Create the file name label
filename = QFileInfo(fileNames.at(i-existing_files)).fileName();
QLabel * Filename_Label = new QLabel(filename.left(filename.lastIndexOf('.')));
Filename_Label->setObjectName(QStringLiteral("File_") + QString::number(i));
List_FileNames.append(Filename_Label);
this->FilesGrid->addWidget(List_FileNames.last(), i,0,1,1);
// Create the "Remove" button
QToolButton * RemoveButton = new QToolButton();
RemoveButton->setObjectName(QStringLiteral("Remove_") + QString::number(i));
QIcon icon(":/bitmaps/trash.png"); // Use a resource path or a relative path
RemoveButton->setIcon(icon);
RemoveButton->setStyleSheet("QToolButton {background-color: red;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
margin: auto;\
}");
List_RemoveButton.append(RemoveButton);
this->FilesGrid->addWidget(List_RemoveButton.last(), i,1,1,1);
connect(RemoveButton, SIGNAL(clicked()), SLOT(removeFile())); // Connect button with the handler to remove the entry.
// Read the Touchstone file.
// Please see https://ibis.org/touchstone_ver2.0/touchstone_ver2_0.pdf
QMap<QString, QList<double>> file_data; // Data structure to store the file data
QString frequency_unit, parameter, format;
double freq_scale = 1; // Hz
double Z0=50; // System impedance. Typically 50 Ohm
// Get the number of ports
QString suffix = QFileInfo(filename).suffix();
QRegularExpression regex("(?i)[sp]");
QStringList numberParts = suffix.split(regex);
int number_of_ports = numberParts[1].toInt();
file_data["n_ports"].append(number_of_ports);
// 1) Open the file
QFile file(fileNames.at(i-existing_files));
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open the file";
break;
}
// 2) Read data
QTextStream in(&file);
while (!in.atEnd()) {
QString line = in.readLine();
line = line.simplified();
//qDebug() << line;
if (line.isEmpty()) continue;
if ((line.at(0).isNumber() == false) && (line.at(0) != '#')) {
if (file_data["frequency"].size() == 0){
// There's still no data
continue;
}else{
//There's already data, so it's very likely that the S-par data has ended and
//the following lines contain noise data. We must stop at this point.
break;
}
}
// Check for the option line
if (line.at(0) == '#'){
QStringList info = line.split(" ");
frequency_unit = info.at(1); // Specifies the unit of frequency.
// Legal values are Hz, kHz, MHz, and GHz. The default value is GHz.
frequency_unit = frequency_unit.toLower();
if (frequency_unit == "khz"){
freq_scale = 1e3;
} else {
if (frequency_unit == "mhz"){
freq_scale = 1e6;
} else {
if (frequency_unit == "ghz"){
freq_scale = 1e9;
}
}
}
parameter = info.at(2); // specifies what kind of network parameter data is contained in the file. Legal
// values are:
// S for Scattering parameters,
// Y for Admittance parameters,
// Z for Impedance parameters,
// H for Hybrid-h parameters,
// G for Hybrid-g parameters.
// The default value is S.
format = info.at(3); // Specifies the format of the network parameter data pairs. Legal values are:
// DB for decibel-angle (decibel = 20 × log 10|magnitude|)
// MA for magnitude-angle,
// RI for real-imaginary.
// Angles are given in degrees. Note that this format does not apply to noise
// parameters (refer to the “Noise Parameter Data” section later in this
// specification). The default value is MA.
Z0 = info.at(5).toDouble();
file_data["Rn"].append(Z0); // Specifies the reference resistance in ohms, where n is a real, positive number of
// ohms. The default reference resistance is 50 ohms. Note that this is overridden
// by the [Reference] keyword, described below, for files of [Version] 2.0 and above
continue;
}
// Split line by whitespace
values.clear();
values = line.split(' ');
file_data["frequency"].append(values[0].toDouble()*freq_scale); // in Hz
double S_1, S_2, S_3, S_4;
QString s1, s2, s3, s4;
int index = 1, data_counter = 0;
for (int i = 1; i<=number_of_ports; i++){
for (int j = 1; j<=number_of_ports; j++){
s1 = QStringLiteral("S") + QString::number(j) + QString::number(i) + QStringLiteral("_dB");
s2 = s1.mid(0, s1.length() - 2).append("ang");
s3 = s1.mid(0, s1.length() - 2).append("re");
s4 = s1.mid(0, s1.length() - 2).append("im");
S_1 = values[index].toDouble();
S_2 = values[index+1].toDouble();
convert_MA_RI_to_dB(&S_1, &S_2, &S_3, &S_4, format);
file_data[s1].append(S_1);//dB
file_data[s2].append(S_2);//ang
file_data[s3].append(S_3);//re
file_data[s4].append(S_4);//im
index += 2;
data_counter++;
// Check if the next values are in the new line
if ((index >= values.length()) && (data_counter < number_of_ports*number_of_ports)){
line = in.readLine();
line = line.simplified();
values = line.split(' ');
index = 0; // Reset index (it's a new line)
}
}
}
if (number_of_ports == 1){
double s11_re = file_data["S11_re"].last();
double s11_im = file_data["S11_im"].last();
std::complex<double> s11 (s11_re, s11_im);
// Optional traces. They are not computed now, but only if the user wants to display them
QStringList optional_traces;
optional_traces.append("Re{Zin}");
optional_traces.append("Im{Zin}");
for (int i = 0; i < optional_traces.size(); i++) {
if (!file_data.contains(optional_traces[i])) {
// If not, create an empty list
file_data[optional_traces[i]] = QList<double>();
}
}
}
if (number_of_ports == 2){
// Optional traces. They are not computed now, but only if the user wants to display them
QStringList optional_traces;
optional_traces.append("delta");
optional_traces.append("K");
optional_traces.append("mu");
optional_traces.append("mu_p");
optional_traces.append("MSG");
optional_traces.append("MAG");
optional_traces.append("Re{Zin}");
optional_traces.append("Im{Zin}");
optional_traces.append("Re{Zout}");
optional_traces.append("Im{Zout}");
for (int i = 0; i < optional_traces.size(); i++) {
if (!file_data.contains(optional_traces[i])) {
// If not, create an empty list
file_data[optional_traces[i]] = QList<double>();
}
}
}
}
// 3) Add data to the dataset
filename = filename.left(filename.lastIndexOf('.')); // Remove file extension
datasets[filename] = file_data;
file.close();
// 4) Add new dataset to the trace selection combobox
QCombobox_datasets->addItem(filename);
// Update traces
updateTracesCombo();
}
// Default behavior: If there's no more data loaded and a single S1P file is selected, then automatically plot S11
if ((fileNames.length() == 1) && (fileNames.first().toLower().endsWith(".s1p")) && (datasets.size() == 1)){
this->addTrace(filename, QStringLiteral("S11"), Qt::red);
adjust_x_axis_to_file(filename);
adjust_y_axis_to_trace(filename, "S11");
}
// Default behavior: If there's no more data loaded and a single S2P file is selected, then automatically plot S21, S11 and S22
if ((fileNames.length() == 1) && (fileNames.first().toLower().endsWith(".s2p")) && (datasets.size() == 1)){
this->addTrace(filename, QStringLiteral("S21"), Qt::red);
this->addTrace(filename, QStringLiteral("S11"), Qt::blue);
this->addTrace(filename, QStringLiteral("S22"), Qt::darkGreen);
adjust_x_axis_to_file(filename);
adjust_y_axis_to_trace(filename, "S11");
adjust_y_axis_to_trace(filename, "S21");
}
// Default behaviour: When adding multiple S2P file, then show the S21 of all traces
if (fileNames.length() > 1){
bool all_s2p = true;
for (int i = 0; i < fileNames.length(); i++){
if (!fileNames.at(i).toLower().endsWith(".s2p")){
all_s2p = false;
break;
}
}
if (all_s2p == true){
QString filename;
for (int i = 0; i < fileNames.length(); i++){
filename = QFileInfo(fileNames.at(i)).fileName();
filename = filename.left(filename.lastIndexOf('.'));
// Pick a random color
QColor trace_color = QColor(QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256));
this->addTrace(filename, QStringLiteral("S21"), trace_color);
adjust_y_axis_to_trace(filename, "S21");
}
// Update the frequency setting to fit the last s2p file
adjust_x_axis_to_file(filename);
}
}
// Show the trace settings widget
dockTracesList->raise();
}
// This function is called whenever a s-par file is intended to be removed from the map of datasets
void Qucs_S_SPAR_Viewer::removeFile()
{
QString ID = qobject_cast<QToolButton*>(sender())->objectName();
//qDebug() << "Clicked button:" << ID;
//Find the index of the button to remove
int index_to_delete = -1;
for (int i = 0; i < List_RemoveButton.size(); i++) {
if (List_RemoveButton.at(i)->objectName() == ID) {
index_to_delete = i;
break;
}
}
removeFile(index_to_delete);
}
void Qucs_S_SPAR_Viewer::removeFile(int index_to_delete)
{
// Delete the label
QLabel* labelToRemove = List_FileNames.at(index_to_delete);
QString dataset_to_remove = labelToRemove->text();
FilesGrid->removeWidget(labelToRemove);
List_FileNames.removeAt(index_to_delete);
delete labelToRemove;
// Delete the button
QToolButton* ButtonToRemove = List_RemoveButton.at(index_to_delete);
FilesGrid->removeWidget(ButtonToRemove);
List_RemoveButton.removeAt(index_to_delete);
delete ButtonToRemove;
// Look for the widgets associated to the trace and remove them
QList<int> indices_to_remove;
for (int i = 0; i < List_TraceNames.size(); i++){
QString trace_name = List_TraceNames.at(i)->text();
QStringList parts = {
trace_name.section('.', 0, -2),
trace_name.section('.', -1)
};
QString dataset_trace = parts[0];
if (dataset_trace == dataset_to_remove ){
QString Label_Object_Name = List_TraceNames.at(i)->objectName();
//Find the index of the button to remove
int index_to_delete = -1;
for (int j = 0; j < List_TraceNames.size(); j++) {
if (List_TraceNames.at(j)->objectName() == Label_Object_Name) {
index_to_delete = j;
break;
}
}
indices_to_remove.append(index_to_delete);
}
}
// Once the list of widgets to remove is known, then remove them on a row
std::sort(indices_to_remove.begin(), indices_to_remove.end(), std::greater<int>()); // Sort the items to avoid segfault when removing the widgets
removeTrace(indices_to_remove);
// Delete the map entry
datasets.remove(dataset_to_remove);
// Rebuild the dataset combobox based on the available datasets.
QStringList new_dataset_entries = datasets.keys();
disconnect(QCombobox_datasets, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTracesCombo())); // Needed to avoid segfault
QCombobox_datasets->clear();
QCombobox_datasets->addItems(new_dataset_entries);
connect(QCombobox_datasets, SIGNAL(currentIndexChanged(int)), SLOT(updateTracesCombo())); // Connect the signal again
// Update the combobox for trace selection
updateTracesCombo();
// Now it is needed to readjust the widgets in the grid layout
// Move up all widgets below the removed row
for (int r = index_to_delete+1; r < FilesGrid->rowCount(); r++) {
for (int c = 0; c < FilesGrid->columnCount(); c++) {
QLayoutItem* item = FilesGrid->itemAtPosition(r, c);
if (item) {
int oldRow, oldCol, rowSpan, colSpan;
FilesGrid->getItemPosition(FilesGrid->indexOf(item), &oldRow, &oldCol, &rowSpan, &colSpan);
FilesGrid->removeItem(item);
FilesGrid->addItem(item, oldRow - 1, oldCol, rowSpan, colSpan);
}
}
}
// Check if there are more files. If not, remove markers and limits
if (datasets.size() == 0)
{
removeAllMarkers();
removeAllLimits();
}
}
void Qucs_S_SPAR_Viewer::removeAllFiles()
{
int n_files = List_RemoveButton.size();
for (int i = 0; i < n_files; i++) {
removeFile(n_files-i-1);
}
}
// This function is called when the user wants to remove a trace from the plot
void Qucs_S_SPAR_Viewer::removeTrace()
{
QString ID = qobject_cast<QToolButton*>(sender())->objectName();
//qDebug() << "Clicked button:" << ID;
//Find the index of the button to remove
int index_to_delete = -1;
for (int i = 0; i < List_Button_DeleteTrace.size(); i++) {
if (List_Button_DeleteTrace.at(i)->objectName() == ID) {
index_to_delete = i;
break;
}
}
removeTrace(index_to_delete);
}
// This function is called when the user wants to remove a trace from the plot
void Qucs_S_SPAR_Viewer::removeTrace(QList<int> indices_to_delete)
{
if (indices_to_delete.isEmpty())
return;
for (int i = 0; i < indices_to_delete.size(); i++)
removeTrace(indices_to_delete.at(i));
}
void Qucs_S_SPAR_Viewer::removeTrace(int index_to_delete)
{
// Delete the label
QLabel* labelToRemove = List_TraceNames.at(index_to_delete);
QString trace_name = labelToRemove->text();
TracesGrid->removeWidget(labelToRemove);
List_TraceNames.removeAt(index_to_delete);
delete labelToRemove;
// Delete the color button
QPushButton* ColorButtonToRemove = List_Trace_Color.at(index_to_delete);
TracesGrid->removeWidget(ColorButtonToRemove);
List_Trace_Color.removeAt(index_to_delete);
delete ColorButtonToRemove;
// Delete the linestyle combo
QComboBox* ComboToRemove = List_Trace_LineStyle.at(index_to_delete);
TracesGrid->removeWidget(ComboToRemove);
List_Trace_LineStyle.removeAt(index_to_delete);
delete ComboToRemove;
// Delete the width spinbox
QSpinBox * SpinToRemove = List_TraceWidth.at(index_to_delete);
TracesGrid->removeWidget(SpinToRemove);
List_TraceWidth.removeAt(index_to_delete);
delete SpinToRemove;
// Delete the "delete" button
QToolButton* ButtonToRemove = List_Button_DeleteTrace.at(index_to_delete);
TracesGrid->removeWidget(ButtonToRemove);
List_Button_DeleteTrace.removeAt(index_to_delete);
delete ButtonToRemove;
// Remove the trace from the QMap
trace_list.removeAll(trace_name);
// Update graphs in QChart plot
removeSeriesByName(chart, trace_name);
// Update the chart limits.
this->f_max = -1;
this->f_min = 1e30;
QStringList files = datasets.keys();
for (int i = 0; i < files.size(); i++){
adjust_x_axis_to_file(files[i]);
}
updateGridLayout(TracesGrid);
}
bool Qucs_S_SPAR_Viewer::removeSeriesByName(QChart* chart, const QString& name)
{
QList<QAbstractSeries*> seriesList = chart->series();
for (QAbstractSeries* series : seriesList) {
if (series->name() == name) {
chart->removeSeries(series);
return true; // Series found and removed
}
}
return false; // Series not found
}
void Qucs_S_SPAR_Viewer::convert_MA_RI_to_dB(double * S_1, double * S_2, double *S_3, double *S_4, QString format)
{
double S_dB = *S_1, S_ang =*S_2;
double S_re = *S_3, S_im = *S_4;
if (format == "MA"){
S_dB = 20*log10(*S_1);
S_ang = *S_2;
S_re = *S_1 * std::cos(*S_2);
S_im = *S_1 * std::sin(*S_2);
}else{
if (format == "RI"){
S_dB = 20*log10(sqrt((*S_1)*(*S_1) + (*S_2)*(*S_2)));
S_ang = atan2(*S_2, *S_1) * 180 / M_PI;
S_re = *S_1;
S_im = *S_2;
} else {
// DB format
double r = std::pow(10, *S_1 / 10.0);
double theta = *S_2 * M_PI / 180.0;
S_re = r * std::cos(theta);
S_im = r * std::sin(theta);
}
}
*S_1 = S_dB;
*S_2 = S_ang;
*S_3 = S_re;
*S_4 = S_im;
}
// Gets the frequency scale unit from a String lke kHz, MHz, GHz
double Qucs_S_SPAR_Viewer::getFreqScale()
{
QString frequency_unit = QCombobox_x_axis_units->currentText();
double freq_scale=1;
if (frequency_unit == "kHz"){
freq_scale = 1e-3;
} else {
if (frequency_unit == "MHz"){
freq_scale = 1e-6;
} else {
if (frequency_unit == "GHz"){
freq_scale = 1e-9;
}
}
}
return freq_scale;
}
// Gets the frequency scale unit from a String lke kHz, MHz, GHz
double Qucs_S_SPAR_Viewer::getFreqScale(QString frequency_unit)
{
double freq_scale=1;
if (frequency_unit == "kHz"){
freq_scale = 1e-3;
} else {
if (frequency_unit == "MHz"){
freq_scale = 1e-6;
} else {
if (frequency_unit == "GHz"){
freq_scale = 1e-9;
}
}
}
return freq_scale;
}
void Qucs_S_SPAR_Viewer::addTrace()
{
QString selected_dataset, selected_trace;
selected_dataset = this->QCombobox_datasets->currentText();
selected_trace = this->QCombobox_traces->currentText();
// Color settings
QColor trace_color;
QPen pen;
int num_traces = trace_list.size();
if (num_traces >= 3){
trace_color = QColor(QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256), QRandomGenerator::global()->bounded(256));
pen.setColor(trace_color);
}
else {
trace_color = this->default_colors.at(num_traces);
}
addTrace(selected_dataset, selected_trace, trace_color);
}
// Read the dataset and trace Comboboxes and add a trace to the display list
void Qucs_S_SPAR_Viewer::addTrace(QString selected_dataset, QString selected_trace, QColor trace_color, int trace_width, QString trace_style)
{
int n_trace = this->trace_list.size()+1; // Number of displayed traces;
// Get the name of the selected dataset
// Get the name of the trace to plot
QString trace_name = selected_dataset;
trace_name.append("."); // Separate the dataset from the trace name with a point
trace_name.append(selected_trace);
if (trace_list.contains(trace_name)){
QMessageBox::information(
this,
tr("Warning"),
tr("This trace is already shown") );
return;
}
// Add the trace to the list of displayed list and create the widgets associated to the trace properties
// Label
QLabel * new_trace_label = new QLabel(trace_name);
new_trace_label->setObjectName(QStringLiteral("Trace_Name_") + trace_name);
List_TraceNames.append(new_trace_label);
this->TracesGrid->addWidget(new_trace_label, n_trace, 0);
// Color picker
QPushButton * new_trace_color = new QPushButton();
new_trace_color->setObjectName(QStringLiteral("Trace_Color_") + trace_name);
connect(new_trace_color, SIGNAL(clicked()), SLOT(changeTraceColor()));
QString styleSheet = QStringLiteral("QPushButton { background-color: %1; }").arg(trace_color.name());
new_trace_color->setStyleSheet(styleSheet);
new_trace_color->setAttribute(Qt::WA_TranslucentBackground); // Needed for Windows buttons to behave as they should
List_Trace_Color.append(new_trace_color);
this->TracesGrid->addWidget(new_trace_color, n_trace, 1);
// Line Style
QComboBox * new_trace_linestyle = new QComboBox();
new_trace_linestyle->setObjectName(QStringLiteral("Trace_LineStyle_") + trace_name);
new_trace_linestyle->addItem("Solid");
new_trace_linestyle->addItem("- - - -");
new_trace_linestyle->addItem("·······");
new_trace_linestyle->addItem("-·-·-·-");
new_trace_linestyle->addItem("-··-··-");
int index = new_trace_linestyle->findText(trace_style);
new_trace_linestyle->setCurrentIndex(index);
connect(new_trace_linestyle, SIGNAL(currentIndexChanged(int)), SLOT(changeTraceLineStyle()));
List_Trace_LineStyle.append(new_trace_linestyle);
this->TracesGrid->addWidget(new_trace_linestyle, n_trace, 2);
// Capture the pen style to correctly render the trace
Qt::PenStyle pen_style;
if (!trace_style.compare("Solid")) {
pen_style = Qt::SolidLine;
} else {
if (!trace_style.compare("- - - -")) {
pen_style = Qt::DashLine;
} else {
if (!trace_style.compare("·······")) {
pen_style = Qt::DotLine;
} else {
if (!trace_style.compare("-·-·-·-")) {
pen_style = Qt::DashDotLine;
} else {
if (!trace_style.compare("-··-··-")) {
pen_style = Qt::DashDotDotLine;
}
}
}
}
}
// Line width
QSpinBox * new_trace_width = new QSpinBox();
new_trace_width->setObjectName(QStringLiteral("Trace_Width_") + trace_name);
new_trace_width->setValue(trace_width);
connect(new_trace_width, SIGNAL(valueChanged(int)), SLOT(changeTraceWidth()));
List_TraceWidth.append(new_trace_width);
this->TracesGrid->addWidget(new_trace_width, n_trace, 3);
// Remove button
QToolButton * new_trace_removebutton = new QToolButton();
new_trace_removebutton->setObjectName(QStringLiteral("Trace_RemoveButton_") + trace_name);
QIcon icon(":/bitmaps/trash.png"); // Use a resource path or a relative path
new_trace_removebutton->setIcon(icon);
new_trace_removebutton->setStyleSheet(R"(
QToolButton {
background-color: #FF0000;
color: white;
border-radius: 20px;
margin: auto;
}
)");
connect(new_trace_removebutton, SIGNAL(clicked()), SLOT(removeTrace()));
List_Button_DeleteTrace.append(new_trace_removebutton);
this->TracesGrid->addWidget(new_trace_removebutton, n_trace, 4);
QLineSeries* series = new QLineSeries();
series->setName(trace_name);
trace_list.append(trace_name);
// Color settings
QPen pen;
pen.setColor(trace_color);
pen.setStyle(pen_style);
pen.setWidth(trace_width);
series->setPen(pen);// Apply the pen to the series
chart->addSeries(series);
updatePlot();
}
// This function is used for setting the available traces depending on the selected dataset
void Qucs_S_SPAR_Viewer::updateTracesCombo()
{
QCombobox_traces->clear();
QStringList traces;
QString current_dataset = QCombobox_datasets->currentText();
if (current_dataset.isEmpty())
return; // No datasets loaded. This happens if the user had one single file and deleted it
int n_ports = datasets[current_dataset]["n_ports"].at(0);
for (int i=1; i<=n_ports; i++){
for (int j=1; j<=n_ports; j++){
traces.append(QStringLiteral("S") + QString::number(i) + QString::number(j));
}
}
if(n_ports == 1){
// Additional traces
traces.append("Re{Zin}");
traces.append("Im{Zin}");
}
if(n_ports == 2){
// Additional traces
traces.append(QStringLiteral("|%1|").arg(QChar(0x0394)));
traces.append("K");
traces.append(QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209B)));
traces.append(QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209A)));
traces.append("MAG");
traces.append("MSG");
traces.append("Re{Zin}");
traces.append("Im{Zin}");
traces.append("Re{Zout}");
traces.append("Im{Zout}");
}
QCombobox_traces->addItems(traces);
}
// This is the handler that is triggered when the user hits the button to change the color of a given trace
void Qucs_S_SPAR_Viewer::changeTraceColor()
{
QColor color = QColorDialog::getColor(Qt::white, this, "Select Color");
if (color.isValid()) {
// Do something with the selected color
// For example, set the background color of the button
QPushButton *button = qobject_cast<QPushButton*>(sender());
if (button) {
QString styleSheet = QStringLiteral("QPushButton { background-color: %1; }").arg(color.name());
button->setStyleSheet(styleSheet);
QString ID = button->objectName();
int index_to_change_color = -1;
for (int i = 0; i < List_Trace_Color.size(); i++) {
if (List_Trace_Color.at(i)->objectName() == ID) {
index_to_change_color = i;
break;
}
}
QLabel* label = List_TraceNames.at(index_to_change_color);
QString trace_name = label->text();
// Change the color of the series named based on its name
const auto seriesList = chart->series();
for (QAbstractSeries *s : seriesList) {
QLineSeries *lineSeries = qobject_cast<QLineSeries*>(s);
if (lineSeries && lineSeries->name() == trace_name) {
QPen pen = lineSeries->pen();
pen.setColor(color);
lineSeries->setPen(pen);
break;
}
}
}
}
}
// This is the handler that is triggered when the user hits the button to change the line style of a given trace
void Qucs_S_SPAR_Viewer::changeTraceLineStyle()
{
QComboBox *combo = qobject_cast<QComboBox*>(sender());
const auto seriesList = chart->series();
QString ID = combo->objectName();
int index_to_change_linestyle = -1;
for (int i = 0; i < List_Trace_LineStyle.size(); i++) {
if (List_Trace_LineStyle.at(i)->objectName() == ID) {
index_to_change_linestyle = i;
break;
}
}
QLabel* label = List_TraceNames.at(index_to_change_linestyle);
QString trace_name = label->text();
for (QAbstractSeries *s : seriesList) {
QLineSeries *lineSeries = qobject_cast<QLineSeries*>(s);
if (lineSeries && lineSeries->name() == trace_name) {
QPen pen = lineSeries->pen();
switch (combo->currentIndex()) {
case 0: // Solid
pen.setStyle(Qt::SolidLine);
break;
case 1: // Dashed
pen.setStyle(Qt::DashLine);
break;
case 2: // Dotted
pen.setStyle(Qt::DotLine);
break;
case 3: // Dash Dot
pen.setStyle(Qt::DashDotLine);
break;
case 4: // Dash Dot Dot Line
pen.setStyle(Qt::DashDotDotLine);
break;
}
lineSeries->setPen(pen);
break;
}
}
}
// This is the handler that is triggered when the user hits the button to change the line width of a given trace
void Qucs_S_SPAR_Viewer::changeTraceWidth()
{
QSpinBox *spinbox = qobject_cast<QSpinBox*>(sender());
const auto seriesList = chart->series();
QString ID = spinbox->objectName();
int index_to_change_linestyle = -1;
for (int i = 0; i < List_TraceWidth.size(); i++) {
if (List_TraceWidth.at(i)->objectName() == ID) {
index_to_change_linestyle = i;
break;
}
}
QLabel* label = List_TraceNames.at(index_to_change_linestyle);
QString trace_name = label->text();
for (QAbstractSeries *s : seriesList) {
QLineSeries *lineSeries = qobject_cast<QLineSeries*>(s);
if (lineSeries && lineSeries->name() == trace_name) {
QPen pen = lineSeries->pen();
pen.setWidth(spinbox->value());
lineSeries->setPen(pen);
break;
}
}
}
void Qucs_S_SPAR_Viewer::updatePlot()
{
if (lock_axis == false){
// Update axes
update_X_axis();
update_Y_axis();
}
// Trim the traces according to the new settings
updateTraces();
updateMarkerTable();
}
// This is the handler that updates the x-axis when the x-axis QSpinBoxes change their value
void Qucs_S_SPAR_Viewer::update_X_axis()
{
// Get the user limits or adjust
adjust_x_axis_div();
double x_min = QSpinBox_x_axis_min->value();
double x_max = QSpinBox_x_axis_max->value();
double x_div = QComboBox_x_axis_div->currentText().toDouble();
// Update spinbox limits
disconnect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QSpinBox_x_axis_min->setMaximum(x_max);
QSpinBox_x_axis_max->setMinimum(x_min);
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
// Remove the axis in order to build a new one later
if (xAxis != NULL) {
chart->removeAxis(xAxis);
}
// x-axis settings
xAxis = new QValueAxis();
xAxis->setRange(x_min, x_max); // Set the range of the axis
xAxis->setTickInterval(x_div); // Set the interval between ticks
xAxis->setTickCount(floor((x_max-x_min)/x_div)+1);
xAxis->setTitleText("frequency (" + QCombobox_x_axis_units->currentText() + ")");
// Add the axis to the chart
chart->addAxis(xAxis, Qt::AlignBottom);
chart->legend()->hide();
}
// This is the handler that updates the y-axis when the y-axis QSpinBoxes change their value
void Qucs_S_SPAR_Viewer::update_Y_axis()
{
// y-axis
double y_min = QSpinBox_y_axis_min->value();
double y_max = QSpinBox_y_axis_max->value();
double y_div = QComboBox_y_axis_div->currentText().toDouble();
// Update spinbox limits
disconnect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QSpinBox_y_axis_min->setMaximum(y_max);
QSpinBox_y_axis_max->setMinimum(y_min);
connect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
if (yAxis != NULL){
chart->removeAxis(yAxis);
}
// y-axis settings
yAxis = new QValueAxis();
yAxis->setRange(y_min, y_max); // Set the range of the axis
yAxis->setTickInterval(y_div); // Set the interval between ticks
yAxis->setTickCount(floor((y_max-y_min)/y_div)+1);
yAxis->setTitleText("S (dB)");
// Add the axis to the chart
chart->addAxis(yAxis, Qt::AlignLeft);
}
// Each time the x-axis or the y-axis settings change, the traces need to be realigned with respect to
// the new axis. Otherwise, the trace is show as it was with the initial axis settings, without any kind of rescaling
void Qucs_S_SPAR_Viewer::updateTraces()
{
// Get the series
QList<QAbstractSeries *> seriesList = chart->series();
// Remove series from the chart
for (QAbstractSeries *series : qAsConst(seriesList)) {
chart->removeSeries(series);
}
// Remove all custom labels
for (QGraphicsItem* label : textLabels) {
chart->scene()->removeItem(label);
delete label;
}
textLabels.clear();
double freq_scale = getFreqScale();
// User settings
double x_axis_min = QSpinBox_x_axis_min->value()/freq_scale;
double x_axis_max = QSpinBox_x_axis_max->value()/freq_scale;
double y_axis_min = QSpinBox_y_axis_min->value();
double y_axis_max = QSpinBox_y_axis_max->value();
// Remove marker and limit traces
// Iterate through the series list
QList<QAbstractSeries *> seriesToRemove;
for (QAbstractSeries *series : qAsConst(seriesList)) {
//qDebug() << series->name();
if (series->name().startsWith("Mkr", Qt::CaseInsensitive)) {
seriesToRemove.append(series);
}
if (series->name().startsWith("Limit", Qt::CaseInsensitive)) {
seriesToRemove.append(series);
}
}
for (QAbstractSeries *series : qAsConst(seriesToRemove)) {
seriesList.removeOne(series);
// If the series is added to a chart, remove it from the chart as well
if (series->chart()) {
series->chart()->removeSeries(series);
}
// Delete the series object to free memory
delete series;
}
// Iterate over all the traces and, if needed:
// 1) Find if the data in the dataset can cover the new frequency span
// 2) If so, trim the trace according to the new limits
// 3) If not, add extra padding
for (QAbstractSeries *series : qAsConst(seriesList)) {
QString trace_name = series->name();
qreal minX_trace, maxX_trace, minY_trace, maxY_trace;
QStringList trace_name_parts = {
trace_name.section('.', 0, -2),
trace_name.section('.', -1)
};
QString data_file = trace_name_parts[0];
QString trace_file = trace_name_parts[1];
if (trace_file.at(0) == 'S'){
trace_file = trace_file + QStringLiteral("_dB");
}
if (trace_file == QStringLiteral("|%1|").arg(QChar(0x0394))){
trace_file = "delta";
}
if (trace_file == QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209B))){
trace_file = "mu";
}
if (trace_file == QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209A))){
trace_file = "mu_p";
}
// Check if the trace is empty or not. If empty, it is because the user wants to see K, mu, mu_p, etc. and
// these traces are not calculated at the file load.
if (datasets[data_file][trace_file].isEmpty()){
calculate_Sparameter_trace(data_file, trace_file);
}
// Check the limits of the data in the dataset in order to see if the new settings given by the user
// exceed the limits of the available data
getMinMaxValues(data_file, trace_file, minX_trace, maxX_trace, minY_trace, maxY_trace);
// Find the closest indices to the minimum and the maximum given by the user
int minIndex = findClosestIndex(datasets[data_file]["frequency"], x_axis_min);
int maxIndex = findClosestIndex(datasets[data_file]["frequency"], x_axis_max);
QList<double> freq_trimmed = datasets[data_file]["frequency"].mid(minIndex, maxIndex - minIndex + 1);
std::transform(freq_trimmed.begin(), freq_trimmed.end(), freq_trimmed.begin(),
[freq_scale](double value) { return value * freq_scale; });
QList<double> data_trimmed = datasets[data_file][trace_file].mid(minIndex, maxIndex - minIndex + 1);
// Get the series data
QXYSeries *xySeries = qobject_cast<QXYSeries*>(series);
xySeries->clear(); // Remove its data
// Apply clipping if the data exceeds the lower/upper limits
for (int i = 0; i < freq_trimmed.size(); i++) {
double y_value = data_trimmed[i];
// Data exceeds the upper limit
if (y_value > y_axis_max){
y_value = y_axis_max;
}
// Data exceeds the lower limit
if (y_value < y_axis_min){
y_value = y_axis_min;
}
// Add (clipped) data to the series
xySeries->append(QPointF(freq_trimmed[i], y_value));
}
}
// Add marker traces. One per trace
for (int c = 1; c<tableMarkers->columnCount(); c++){//Traces
QScatterSeries *marker_series = new QScatterSeries();
marker_series->setMarkerShape(QScatterSeries::MarkerShapeCircle);
marker_series->setMarkerSize(10);
marker_series->setColor(Qt::black);
for (int r = 0; r<tableMarkers->rowCount(); r++){//Marker
QString y_val = tableMarkers->item(r,c)->text();
QString text = tableMarkers->item(r,0)->text();
QStringList parts = text.split(' ');
QString freq = parts[0];
QString freq_scale = parts[1];
double x = freq.toDouble()/getFreqScale(freq_scale);
x *= getFreqScale();// Normalize x with respect to the axis scale
double y = y_val.toDouble();
marker_series->append(x, y);
}
QString trace_name = tableMarkers->horizontalHeaderItem(c)->text();
QString marker_series_name = QStringLiteral("Mkr_%1").arg(trace_name);
marker_series->setName(marker_series_name);
seriesList.append(marker_series);
}
// Add the marker vertical bar
int n_rows = tableMarkers->rowCount();
int n_cols = tableMarkers->columnCount();
if (n_cols > 1){
for (int r = 0; r<n_rows; r++){//Marker
QString text = tableMarkers->item(r,0)->text();
QStringList parts = text.split(' ');
QString freq = parts[0];
QString freq_scale = parts[1];
double x = freq.toDouble()/getFreqScale(freq_scale);
x *= getFreqScale();// Normalize x with respect to the axis scale
QLineSeries *verticalLine = new QLineSeries();
verticalLine->append(x, y_axis_min);
verticalLine->append(x, y_axis_max);
verticalLine->setPen(QPen(Qt::black, 1, Qt::DashLine));
QString verticalLine_name = QStringLiteral("Mkr_%1").arg(r);
verticalLine->setName(verticalLine_name);
seriesList.append(verticalLine);
QGraphicsTextItem *textItem = new QGraphicsTextItem(chart);
QString freq_marker = tableMarkers->item(r,0)->text();
textItem->setPlainText(QStringLiteral("%1").arg(freq_marker));
textItem->setFont(QFont("Arial", 8));
// Get the axes
auto axes = chart->axes(Qt::Horizontal);
QValueAxis *xAxis = qobject_cast<QValueAxis*>(axes.first());
qreal xRatio = (x - xAxis->min()) / (xAxis->max() - xAxis->min());
// Calculate the position
QRectF plotArea = chart->plotArea();
qreal xPixel = plotArea.left() + xRatio * plotArea.width();
// Center the text horizontally
QFontMetrics fm(textItem->font());
int textWidth = fm.horizontalAdvance(textItem->toPlainText());
qreal textX = xPixel - textWidth / 2;
// Position above the chart area
qreal textY = plotArea.top() - fm.height() - 5; // 5 pixels above the plot area
textItem->setPos(textX, textY);
textLabels.append(textItem);
}
}
// Add limits
double limits_offset = Limits_Offset->value();
for (int i = 0; i < List_LimitNames.size(); i++){
// Start frequency
double fstart = List_Limit_Start_Freq[i]->value();
double fstart_scale = getFreqScale(List_Limit_Start_Freq_Scale[i]->currentText());
fstart = fstart / fstart_scale;// Hz
fstart *= getFreqScale();// Normalize x with respect to the axis scale
// Stop frequency
double fstop = List_Limit_Stop_Freq[i]->value();
double fstop_scale = getFreqScale(List_Limit_Stop_Freq_Scale[i]->currentText());
fstop = fstop / fstop_scale;// Hz
fstop *= getFreqScale();// Normalize x with respect to the axis scale
// Start value
double val_start = List_Limit_Start_Value[i]->value()+limits_offset;
// Stop value
double val_stop = List_Limit_Stop_Value[i]->value()+limits_offset;
QLineSeries *limitLine = new QLineSeries();
limitLine->append(fstart, val_start);
limitLine->append(fstop, val_stop);
limitLine->setPen(QPen(Qt::black, 2));
QString limitLine_name = QStringLiteral("Limit_%1").arg(i);
limitLine->setName(limitLine_name);
seriesList.append(limitLine);
}
// Add series again to the chart. Each series must be linked to an axis
for (QAbstractSeries *series : qAsConst(seriesList)) {
chart->addSeries(series);
series->attachAxis(xAxis);
series->attachAxis(yAxis);
}
chart->update();
}
// Given a trace, it gives the minimum and the maximum values at both axis.
void Qucs_S_SPAR_Viewer::getMinMaxValues(QString filename, QString tracename, qreal& minX, qreal& maxX, qreal& minY, qreal& maxY) {
// Find the minimum and the maximum in the x-axis
QList<double> freq = datasets[filename]["frequency"];
minX = freq.first();
maxX = freq.last();
// Find minimum and maximum in the y-axis
QList<double> trace_data = datasets[filename][tracename];
auto minIterator = std::min_element(trace_data.begin(), trace_data.end());
auto maxIterator = std::max_element(trace_data.begin(), trace_data.end());
minY = *minIterator;
maxY = *maxIterator;
}
int Qucs_S_SPAR_Viewer::findClosestIndex(const QList<double>& list, double value)
{
return std::min_element(list.begin(), list.end(),
[value](double a, double b) {
return std::abs(a - value) < std::abs(b - value);
}) - list.begin();
}
// Ensures that the frequency settings limits does not show numbers like 0.001 or 500000
void Qucs_S_SPAR_Viewer::checkFreqSettingsLimits(QString filename, double& fmin, double& fmax){
QList<double> frequency = datasets[filename]["frequency"];
while (true) {
fmin = frequency.first();
fmax = frequency.last();
// Check frequency scale setting
double freq_scale = getFreqScale();
// Normalize the minimum and maximum frequencies
fmin *= freq_scale;
fmax *= freq_scale;
// Exit condition
if ((fmax > 1) && (fmax < 3000)){
break;
}
if (fmax > 3000){
// Downscale
int index = QCombobox_x_axis_units->currentIndex();
if (index < 3) {
disconnect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_max, SIGNAL(valueChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_min, SIGNAL(valueChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QCombobox_x_axis_units->setCurrentIndex(index+1);
QSpinBox_x_axis_min->setValue(fmin);
QSpinBox_x_axis_max->setValue(fmax);
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(int)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(int)), SLOT(updatePlot()));
} else{
// It's not possible to downscale more. Break the loop
break;
}
}else{
// Upscale
int index = QCombobox_x_axis_units->currentIndex();
if (index > 0) {
disconnect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_max, SIGNAL(valueChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_min, SIGNAL(valueChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QCombobox_x_axis_units->setCurrentIndex(index-1);
QSpinBox_x_axis_min->setValue(fmin);
QSpinBox_x_axis_max->setValue(fmax);
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(int)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(int)), SLOT(updatePlot()));
} else{
// It's not possible to upscale more. Break the loop
break;
}
}
}
return;
}
// Automatically adjust the y-axis depending on the y-axis values of the traces displayed
void Qucs_S_SPAR_Viewer::adjust_y_axis_to_trace(QString filename, QString tracename){
qreal minX, maxX, minY, maxY;
if (tracename.at(0) == 'S'){
tracename = tracename + QStringLiteral("_dB");
}
if (tracename == QStringLiteral("|%1|").arg(QChar(0x0394))){
tracename = "delta";
}
if (tracename == QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209B))){
tracename = "mu";
}
if (tracename == QStringLiteral("%1%2").arg(QChar(0x03BC)).arg(QChar(0x209A))){
tracename = "mu_p";
}
getMinMaxValues(filename, tracename, minX, maxX, minY, maxY);
if (maxY > this->y_max) {
maxY = 5.0 * std::ceil(maxY / 5.0);
this->y_max = maxY;
}
if (minY < this->y_min) {
minY = 5.0 * std::floor(minY / 5.0);
this->y_min = minY;
}
//Adjust the y-axis div depending on the limits
double y_div = QComboBox_y_axis_div->currentText().toDouble();
if ((y_div > y_max-y_min) || ((y_max-y_min)/y_div > 10) || ((y_max-y_min)/y_div < 5)){
// No ticks or excesive ticks
int new_index = findClosestIndex(available_y_axis_div, (y_max-y_min)/10);
disconnect(QComboBox_y_axis_div, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot()));
QComboBox_y_axis_div->setCurrentIndex(new_index);
connect(QComboBox_y_axis_div, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
}
disconnect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
disconnect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
QSpinBox_y_axis_min->setValue(y_min);
QSpinBox_y_axis_max->setValue(y_max);
connect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
updatePlot();
}
// Automatically adjust the x-axis depending on the range of the traces displayed
void Qucs_S_SPAR_Viewer::adjust_x_axis_to_file(QString filename){
QList<double> frequency = datasets[filename]["frequency"];
double fmin = frequency.first();
double fmax = frequency.last();
if (fmin < this->f_min) this->f_min = fmin;
if (fmax > this->f_max) this->f_max = fmax;
while (true) {
fmin = this->f_min;
fmax = this->f_max;
// Check frequency scale setting
double freq_scale = getFreqScale();
// Normalize the minimum and maximum frequencies
fmin *= freq_scale;
fmax *= freq_scale;
// Exit condition
if ((fmax > 1) && (fmax < 3000)){
break;
}
if (fmax >= 3000){
// Downscale
int index = QCombobox_x_axis_units->currentIndex();
if (index < 3) {
disconnect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QCombobox_x_axis_units->setCurrentIndex(index+1);
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
} else{
// It's not possible to downscale more. Break the loop
break;
}
}else{
// Upscale
int index = QCombobox_x_axis_units->currentIndex();
if (index > 0) {
disconnect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot())); // Needed to avoid duplicating the call to the update function
QCombobox_x_axis_units->setCurrentIndex(index-1);
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
} else{
// It's not possible to upscale more. Break the loop
break;
}
}
}
// Disconnect handlers to avoid duplicating the call to the update function
disconnect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
disconnect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
// Round to 1 decimal place
fmin = round(fmin * 10.0) / 10.0;
fmax = round(fmax * 10.0) / 10.0;
QSpinBox_x_axis_min->setValue(fmin);
QSpinBox_x_axis_max->setValue(fmax);
QSpinBox_x_axis_max->setMinimum(fmin); // The upper limit cannot be lower than the lower limit
QSpinBox_x_axis_max->setMaximum(fmax); // The lower limit cannot be higher than the higher limit
// Update x-axis tick
adjust_x_axis_div();
// Connect the handlers again
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
updatePlot();
}
void Qucs_S_SPAR_Viewer::addMarker(double freq){
// If there are no traces in the display, show a message and exit
if (trace_list.size() == 0){
QMessageBox::information(
this,
tr("Warning"),
tr("The display contains no traces.") );
return;
}
double f_marker;
if (freq == -1) {
// There's no specific frequency argument, then pick the middle point
double f1 = QSpinBox_x_axis_min->value();
double f2 = QSpinBox_x_axis_max->value();
f_marker = f1 + 0.5*(f2-f1);
} else {
f_marker= freq;
f_marker *= getFreqScale();// Scale according to the x-axis units
}
QString Freq_Marker_Scale = QCombobox_x_axis_units->currentText();
int n_markers = List_MarkerNames.size();
n_markers++;
QString new_marker_name = QStringLiteral("Mkr%1").arg(n_markers);
QLabel * new_marker_label = new QLabel(new_marker_name);
new_marker_label->setObjectName(new_marker_name);
List_MarkerNames.append(new_marker_label);
this->MarkersGrid->addWidget(new_marker_label, n_markers, 0);
QString SpinBox_name = QStringLiteral("Mkr_SpinBox%1").arg(n_markers);
QDoubleSpinBox * new_marker_Spinbox = new QDoubleSpinBox();
new_marker_Spinbox->setObjectName(SpinBox_name);
new_marker_Spinbox->setMaximum(QSpinBox_x_axis_max->minimum());
new_marker_Spinbox->setMaximum(QSpinBox_x_axis_max->maximum());
new_marker_Spinbox->setValue(f_marker);
connect(new_marker_Spinbox, SIGNAL(valueChanged(double)), SLOT(updateMarkerTable()));
List_MarkerFreq.append(new_marker_Spinbox);
this->MarkersGrid->addWidget(new_marker_Spinbox, n_markers, 1);
QString Combobox_name = QStringLiteral("Mkr_ComboBox%1").arg(n_markers);
QComboBox * new_marker_Combo = new QComboBox();
new_marker_Combo->setObjectName(Combobox_name);
new_marker_Combo->addItems(frequency_units);
new_marker_Combo->setCurrentIndex(QCombobox_x_axis_units->currentIndex());
connect(new_marker_Combo, SIGNAL(currentIndexChanged(int)), SLOT(changeMarkerLimits()));
List_MarkerScale.append(new_marker_Combo);
this->MarkersGrid->addWidget(new_marker_Combo, n_markers, 2);
// Remove button
QString DeleteButton_name = QStringLiteral("Mkr_Delete_Btn%1").arg(n_markers);
QToolButton * new_marker_removebutton = new QToolButton();
new_marker_removebutton->setObjectName(DeleteButton_name);
QIcon icon(":/bitmaps/trash.png"); // Use a resource path or a relative path
new_marker_removebutton->setIcon(icon);
new_marker_removebutton->setStyleSheet(R"(
QToolButton {
background-color: #FF0000;
color: white;
border-radius: 20px;
}
)");
connect(new_marker_removebutton, SIGNAL(clicked()), SLOT(removeMarker()));
List_Button_DeleteMarker.append(new_marker_removebutton);
this->MarkersGrid->addWidget(new_marker_removebutton, n_markers, 3, Qt::AlignCenter);
// Add new entry to the table
tableMarkers->setRowCount(n_markers);
QString new_freq = QStringLiteral("%1 ").arg(QString::number(f_marker, 'f', 2)) + Freq_Marker_Scale;
QTableWidgetItem *newfreq = new QTableWidgetItem(new_freq);
tableMarkers->setItem(n_markers-1, 0, newfreq);
changeMarkerLimits(Combobox_name);
}
void Qucs_S_SPAR_Viewer::updateMarkerTable(){
//If there are no markers, remove the entries and return
int n_markers = List_MarkerNames.size();
if (n_markers == 0){
tableMarkers->clear();
tableMarkers->setColumnCount(0);
tableMarkers->setRowCount(0);
updateTraces();
return;
}
//Ensure that the size of the table is correct
QList<QAbstractSeries *> seriesList = chart->series();
// Update marker header
QStringList headers;
headers.clear();
headers.append("freq");
for (QAbstractSeries *series : qAsConst(seriesList)) {
QString series_name = series->name();
if (series_name.startsWith("Mkr", Qt::CaseSensitive) || series_name.startsWith("Limit", Qt::CaseSensitive)){
//Markers and limits are traces in the QChart, but they cannot be added as markers again!
continue;
}
headers.append(series_name);
}
tableMarkers->setColumnCount(headers.size());// The first row is for the frequency
tableMarkers->setRowCount(n_markers);
tableMarkers->setHorizontalHeaderLabels(headers);
QPointF P;
qreal targetX;
QString new_val;
QString freq_marker;
// Update each marker
// Columns are traces. Rows are markers
for (int c = 0; c<tableMarkers->columnCount(); c++){//Traces
for (int r = 0; r<tableMarkers->rowCount(); r++){//Marker
freq_marker = QStringLiteral("%1 ").arg(QString::number(List_MarkerFreq[r]->value(), 'f', 1)) + List_MarkerScale[r]->currentText();
if (c==0){
// First column
QTableWidgetItem *new_item = new QTableWidgetItem(freq_marker);
tableMarkers->setItem(r, c, new_item);
continue;
}
targetX = getFreqFromText(freq_marker);
// Look into dataset, traces may be clipped.
// It is important to grab the data from the dataset, not from the displayed trace.
QString trace_name = seriesList[c-1]->name();
QStringList parts = {
trace_name.section('.', 0, -2),
trace_name.section('.', -1)
};
QString file = parts[0];
QString trace = parts[1];
if (trace.at(0) == 'S'){
trace.append("_dB");
}
P = findClosestPoint(datasets[file]["frequency"], datasets[file][trace], targetX);
new_val = QStringLiteral("%1").arg(QString::number(P.y(), 'f', 2));
QTableWidgetItem *new_item = new QTableWidgetItem(new_val);
tableMarkers->setItem(r, c, new_item);
}
}
updateTraces();//The markers need to be updated in the chart
}
// Find the closest x-axis value in a series given a x value (not necesarily in the grid)
QPointF Qucs_S_SPAR_Viewer::findClosestPoint(const QList<double>& xValues, const QList<double>& yValues, double targetX)
{
if (xValues.isEmpty() || yValues.isEmpty() || xValues.size() != yValues.size()) {
return QPointF(); // Return invalid point if lists are empty or have different sizes
}
// Initialize with the first point
QPointF closestPoint(xValues.first(), yValues.first());
double minDistance = qAbs(targetX - closestPoint.x());
// Iterate through all points to find the closest one
for (int i = 0; i < xValues.size(); ++i) {
double distance = qAbs(targetX - xValues[i]);
if (distance < minDistance) {
minDistance = distance;
closestPoint = QPointF(xValues[i], yValues[i]);
}
}
return closestPoint;
}
double Qucs_S_SPAR_Viewer::getFreqFromText(QString freq)
{
// Remove any whitespace from the string
freq = freq.simplified();
// Regular expression to match the number and unit
QRegularExpression re("(\\d+(?:\\.\\d+)?)(\\s*)(Hz|kHz|MHz|GHz)");
re.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
QRegularExpressionMatch match = re.match(freq);
if (match.hasMatch()) {
double value = match.captured(1).toDouble();
QString unit = match.captured(3).toLower();
// Convert to Hz based on the unit
if (unit == "khz") {
return value * 1e3;
} else if (unit == "mhz") {
return value * 1e6;
} else if (unit == "ghz") {
return value * 1e9;
} else {
// Assume Hz if no unit or Hz is specified
return value;
}
}
// Return -1 if the input doesn't match the expected format
return -1;
}
// This function is called when the user wants to remove a marker from the plot
void Qucs_S_SPAR_Viewer::removeMarker()
{
QString ID = qobject_cast<QToolButton*>(sender())->objectName();
//qDebug() << "Clicked button:" << ID;
//Find the index of the button to remove
int index_to_delete = -1;
for (int i = 0; i < List_Button_DeleteMarker.size(); i++) {
if (List_Button_DeleteMarker.at(i)->objectName() == ID) {
index_to_delete = i;
break;
}
}
removeMarker(index_to_delete);
}
void Qucs_S_SPAR_Viewer::removeMarker(int index_to_delete)
{
// Delete the label
QLabel* labelToRemove = List_MarkerNames.at(index_to_delete);
MarkersGrid->removeWidget(labelToRemove);
List_MarkerNames.removeAt(index_to_delete);
delete labelToRemove;
// Delete the SpinBox
QDoubleSpinBox * SpinBoxToRemove = List_MarkerFreq.at(index_to_delete);
MarkersGrid->removeWidget(SpinBoxToRemove);
List_MarkerFreq.removeAt(index_to_delete);
delete SpinBoxToRemove;
// Delete the linestyle combo
QComboBox* ComboToRemove = List_MarkerScale.at(index_to_delete);
MarkersGrid->removeWidget(ComboToRemove);
List_MarkerScale.removeAt(index_to_delete);
delete ComboToRemove;
// Delete the "delete" button
QToolButton* ButtonToRemove = List_Button_DeleteMarker.at(index_to_delete);
MarkersGrid->removeWidget(ButtonToRemove);
List_Button_DeleteMarker.removeAt(index_to_delete);
delete ButtonToRemove;
updateMarkerTable();
updateMarkerNames();
updateGridLayout(MarkersGrid);
}
void Qucs_S_SPAR_Viewer::removeAllMarkers()
{
int n_markers = List_MarkerNames.size();
for (int i = 0; i < n_markers; i++) {
removeMarker(n_markers-i-1);
}
}
// After removing a marker, the names of the other markers must be updated
void Qucs_S_SPAR_Viewer::updateMarkerNames()
{
int n_markers = List_MarkerNames.size();
for (int i = 0; i < n_markers; i++) {
QLabel * MarkerLabel = List_MarkerNames[i];
MarkerLabel->setText(QStringLiteral("Mkr%1").arg(i+1));
}
}
// After removing a marker, the names of the other markers must be updated
void Qucs_S_SPAR_Viewer::updateLimitNames()
{
int n_limits = List_LimitNames.size();
for (int i = 0; i < n_limits; i++) {
QLabel * LimitLabel = List_LimitNames[i];
LimitLabel->setText(QStringLiteral("Limit %1").arg(i+1));
}
}
// This function is called when the user wants to remove a limit from the plot
void Qucs_S_SPAR_Viewer::removeLimit()
{
QString ID = qobject_cast<QToolButton*>(sender())->objectName();
//qDebug() << "Clicked button:" << ID;
//Find the index of the button to remove
int index_to_delete = -1;
for (int i = 0; i < List_Button_Delete_Limit.size(); i++) {
if (List_Button_Delete_Limit.at(i)->objectName() == ID) {
index_to_delete = i;
break;
}
}
removeLimit(index_to_delete);
}
void Qucs_S_SPAR_Viewer::removeLimit(int index_to_delete)
{
// Delete the label
QLabel* labelToRemove = List_LimitNames.at(index_to_delete);
LimitsGrid->removeWidget(labelToRemove);
List_LimitNames.removeAt(index_to_delete);
delete labelToRemove;
// Delete the fstart SpinBox
QDoubleSpinBox * SpinBox_fstart_ToRemove = List_Limit_Start_Freq.at(index_to_delete);
LimitsGrid->removeWidget(SpinBox_fstart_ToRemove);
List_Limit_Start_Freq.removeAt(index_to_delete);
delete SpinBox_fstart_ToRemove;
// Delete the fstop SpinBox
QDoubleSpinBox * SpinBox_fstop_ToRemove = List_Limit_Stop_Freq.at(index_to_delete);
LimitsGrid->removeWidget(SpinBox_fstop_ToRemove);
List_Limit_Stop_Freq.removeAt(index_to_delete);
delete SpinBox_fstop_ToRemove;
// Delete the start value SpinBox
QDoubleSpinBox * SpinBox_val_start_ToRemove = List_Limit_Start_Value.at(index_to_delete);
LimitsGrid->removeWidget(SpinBox_val_start_ToRemove);
List_Limit_Start_Value.removeAt(index_to_delete);
delete SpinBox_val_start_ToRemove;
// Delete the stop value SpinBox
QDoubleSpinBox * SpinBox_val_stop_ToRemove = List_Limit_Stop_Value.at(index_to_delete);
LimitsGrid->removeWidget(SpinBox_val_stop_ToRemove);
List_Limit_Stop_Value.removeAt(index_to_delete);
delete SpinBox_val_stop_ToRemove;
//Delete frequency scale combo. fstart
QComboBox* Combo_fstart_ToRemove = List_Limit_Start_Freq_Scale.at(index_to_delete);
LimitsGrid->removeWidget(Combo_fstart_ToRemove);
List_Limit_Start_Freq_Scale.removeAt(index_to_delete);
delete Combo_fstart_ToRemove;
//Delete frequency scale combo. fstop
QComboBox* Combo_fstop_ToRemove = List_Limit_Stop_Freq_Scale.at(index_to_delete);
LimitsGrid->removeWidget(Combo_fstop_ToRemove);
List_Limit_Stop_Freq_Scale.removeAt(index_to_delete);
delete Combo_fstop_ToRemove;
// Delete the "delete" button
QToolButton* ButtonToRemove = List_Button_Delete_Limit.at(index_to_delete);
LimitsGrid->removeWidget(ButtonToRemove);
List_Button_Delete_Limit.removeAt(index_to_delete);
delete ButtonToRemove;
// Delete the "coupled" button
QPushButton* ButtonCoupledToRemove = List_Couple_Value.at(index_to_delete);
LimitsGrid->removeWidget(ButtonCoupledToRemove);
List_Couple_Value.removeAt(index_to_delete);
delete ButtonCoupledToRemove;
// Delete the separator
QFrame* SeparatorToRemove = List_Separators.at(index_to_delete);
LimitsGrid->removeWidget(SeparatorToRemove);
List_Separators.removeAt(index_to_delete);
delete SeparatorToRemove;
updateTraces();
updateGridLayout(LimitsGrid);
updateLimitNames();
}
void Qucs_S_SPAR_Viewer::removeAllLimits()
{
int n_limits = List_LimitNames.size();
for (int i = 0; i < n_limits; i++) {
removeLimit(n_limits-i-1);
}
}
void Qucs_S_SPAR_Viewer::changeFreqUnits()
{
// Adjust x-axis settings maximum depending on the units combo
double freq_scale = getFreqScale();
double fmax = this->f_max*freq_scale;
double fmin = this->f_min*freq_scale;
// Update fmax Spinbox
QSpinBox_x_axis_max->setMaximum(fmax);
QSpinBox_x_axis_max->setValue(fmax);
if (fmax > 1000){
// Step 1
QSpinBox_x_axis_max->setSingleStep(1);
} else {
if (fmax > 100){
// Step 0.1
QSpinBox_x_axis_max->setSingleStep(0.1);
} else {
// Step 0.01
QSpinBox_x_axis_max->setSingleStep(0.01);
}
}
// Update fmin Spinbox
QSpinBox_x_axis_min->setMaximum(fmin);
QSpinBox_x_axis_min->setValue(fmin);
if (fmin > 1000){
// Step 1
QSpinBox_x_axis_min->setSingleStep(1);
} else {
if (fmin > 100){
// Step 0.1
QSpinBox_x_axis_min->setSingleStep(0.1);
} else {
// Step 0.01
QSpinBox_x_axis_min->setSingleStep(0.01);
}
}
// Adjust div
adjust_x_axis_div();
updatePlot();
}
void Qucs_S_SPAR_Viewer::adjust_x_axis_div()
{
double x_min = QSpinBox_x_axis_min->value();
double x_max = QSpinBox_x_axis_max->value();
double x_div = QComboBox_x_axis_div->currentText().toDouble();
if ((x_div > x_max-x_min) || ((x_max-x_min)/x_div > 15) || ((x_max-x_min)/x_div < 5) ){
// No ticks or excesive ticks
int new_index = findClosestIndex(available_x_axis_div, (x_max-x_min)/5);
disconnect(QComboBox_x_axis_div, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot()));
QComboBox_x_axis_div->setCurrentIndex(new_index);
connect(QComboBox_x_axis_div, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
//Update the step of the spinboxes
double step = QComboBox_x_axis_div->currentText().toDouble()/10;
QSpinBox_x_axis_min->setSingleStep(step);
QSpinBox_x_axis_max->setSingleStep(step);
}
}
// If the combobox associated to a marker changes, the limits of the marker must be updated too
void Qucs_S_SPAR_Viewer::changeMarkerLimits()
{
QString ID = qobject_cast<QComboBox*>(sender())->objectName();
//qDebug() << "Clicked button:" << ID;
changeMarkerLimits(ID);
}
// If the combobox associated to a marker changes, the limits of the marker must be updated too
void Qucs_S_SPAR_Viewer::changeMarkerLimits(QString ID)
{
//Find the index of the marker
int index = -1;
for (int i = 0; i < List_MarkerScale.size(); i++) {
if (List_MarkerScale.at(i)->objectName() == ID) {
index = i;
break;
}
}
// The lower and upper limits are given by the axis settings
double f_upper = QSpinBox_x_axis_max->value();
double f_lower = QSpinBox_x_axis_min->value();
double f_scale = getFreqScale();
f_upper /=f_scale;
f_lower /=f_scale;
// Now we have to normalize this with respect to the marker's combo
QString new_scale = List_MarkerScale.at(index)->currentText();
double f_scale_combo = getFreqScale(new_scale);
f_upper *= f_scale_combo;
f_lower *= f_scale_combo;
List_MarkerFreq.at(index)->setMinimum(f_lower);
List_MarkerFreq.at(index)->setMaximum(f_upper);
// Update minimum step
double diff = f_upper - f_lower;
if (diff < 1){
List_MarkerFreq.at(index)->setSingleStep(0.01);
}else{
if (diff < 10){
List_MarkerFreq.at(index)->setSingleStep(0.1);
}else{
if (diff < 100){
List_MarkerFreq.at(index)->setSingleStep(1);
}else{
List_MarkerFreq.at(index)->setSingleStep(10);
}
}
}
updateMarkerTable();
}
void Qucs_S_SPAR_Viewer::dragEnterEvent(QDragEnterEvent *event)
{
if (event->mimeData()->hasUrls()) {
event->acceptProposedAction();
}
}
void Qucs_S_SPAR_Viewer::dropEvent(QDropEvent *event)
{
QList<QUrl> urls = event->mimeData()->urls();
QStringList fileList;
for (const QUrl &url : qAsConst(urls)) {
if (url.isLocalFile()) {
fileList << url.toLocalFile();
}
}
if (!fileList.isEmpty()) {
// Check if this is a session file
if (fileList.size() == 1){
if (fileList.first().endsWith(".spar", Qt::CaseInsensitive)) {// Then open it as a session settings file.
// Remove traces and the dataset from the current session before loading the session file
removeAllFiles();
loadSession(fileList.first());
this->activateWindow();
return;
}
}
addFiles(fileList);
this->activateWindow();
}
}
void Qucs_S_SPAR_Viewer::lock_unlock_axis_settings(bool toogle)
{
if (toogle == true) {
lock_axis = !lock_axis;
}
if (lock_axis == false){
Lock_axis_settings_Button->setText("Lock Axes");
//Frozen axes inputs
QSpinBox_x_axis_min->setEnabled(true);
QSpinBox_x_axis_max->setEnabled(true);
QComboBox_x_axis_div->setEnabled(true);
QCombobox_x_axis_units->setEnabled(true);
QSpinBox_y_axis_min->setEnabled(true);
QSpinBox_y_axis_max->setEnabled(true);
QComboBox_y_axis_div->setEnabled(true);
}
else{
Lock_axis_settings_Button->setText("Unlock Axes");
//Unfrozen axes inputs
QSpinBox_x_axis_min->setDisabled(true);
QSpinBox_x_axis_max->setDisabled(true);
QComboBox_x_axis_div->setDisabled(true);
QCombobox_x_axis_units->setDisabled(true);
QSpinBox_y_axis_min->setDisabled(true);
QSpinBox_y_axis_max->setDisabled(true);
QComboBox_y_axis_div->setDisabled(true);
}
}
void Qucs_S_SPAR_Viewer::addLimit(double f_limit1, QString f_limit1_unit, double f_limit2, QString f_limit2_unit, double y_limit1, double y_limit2, bool coupled)
{
// If there are no traces in the display, show a message and exit
if (trace_list.size() == 0){
QMessageBox::information(
this,
tr("Warning"),
tr("The display contains no traces.") );
return;
}
if (f_limit1 == -1) {
// There's no specific data passed. Then get it from the widgets
double f1 = QSpinBox_x_axis_min->value();
double f2 = QSpinBox_x_axis_max->value();
f_limit1 = f1 + 0.25*(f2-f1);
f_limit2 = f1 + 0.75*(f2-f1);
double y1 = QSpinBox_y_axis_min->value();
double y2 = QSpinBox_y_axis_max->value();
y_limit1 = y1 + (y2-y1)/2;
y_limit2 = y_limit1;
}
int n_limits = List_LimitNames.size();
n_limits++;
int limit_index = 3*n_limits-2;
QString tooltip_message;
QString new_limit_name = QStringLiteral("Limit %1").arg(n_limits);
QLabel * new_limit_label = new QLabel(new_limit_name);
new_limit_label->setObjectName(new_limit_name);
List_LimitNames.append(new_limit_label);
this->LimitsGrid->addWidget(new_limit_label, limit_index, 0);
QString SpinBox_fstart_name = QStringLiteral("Lmt_Freq_Start_SpinBox_%1").arg(new_limit_name);
QDoubleSpinBox * new_limit_fstart_Spinbox = new QDoubleSpinBox();
new_limit_fstart_Spinbox->setObjectName(SpinBox_fstart_name);
new_limit_fstart_Spinbox->setMaximum(QSpinBox_x_axis_max->minimum());
new_limit_fstart_Spinbox->setMaximum(QSpinBox_x_axis_max->maximum());
new_limit_fstart_Spinbox->setSingleStep(QComboBox_x_axis_div->currentText().toDouble()/5);
new_limit_fstart_Spinbox->setValue(f_limit1);
connect(new_limit_fstart_Spinbox, SIGNAL(valueChanged(double)), SLOT(updateTraces()));
List_Limit_Start_Freq.append(new_limit_fstart_Spinbox);
this->LimitsGrid->addWidget(new_limit_fstart_Spinbox, limit_index, 1);
QString Combobox_start_name = QStringLiteral("Lmt_Start_ComboBox_%1").arg(new_limit_name);
QComboBox * new_start_limit_Combo = new QComboBox();
new_start_limit_Combo->setObjectName(Combobox_start_name);
new_start_limit_Combo->addItems(frequency_units);
if (f_limit1_unit.isEmpty()){
new_start_limit_Combo->setCurrentIndex(QCombobox_x_axis_units->currentIndex());
} else {
int index = new_start_limit_Combo->findText(f_limit1_unit);
new_start_limit_Combo->setCurrentIndex(index);
}
connect(new_start_limit_Combo, SIGNAL(currentIndexChanged(int)), SLOT(updateTraces()));
List_Limit_Start_Freq_Scale.append(new_start_limit_Combo);
this->LimitsGrid->addWidget(new_start_limit_Combo, limit_index, 2);
QString SpinBox_fstop_name = QStringLiteral("Lmt_Freq_Stop_SpinBox_%1").arg(new_limit_name);
QDoubleSpinBox * new_limit_fstop_Spinbox = new QDoubleSpinBox();
new_limit_fstop_Spinbox->setObjectName(SpinBox_fstop_name);
new_limit_fstop_Spinbox->setMaximum(QSpinBox_x_axis_max->minimum());
new_limit_fstop_Spinbox->setMaximum(QSpinBox_x_axis_max->maximum());
new_limit_fstop_Spinbox->setSingleStep(QComboBox_x_axis_div->currentText().toDouble()/5);
new_limit_fstop_Spinbox->setValue(f_limit2);
connect(new_limit_fstop_Spinbox, SIGNAL(valueChanged(double)), SLOT(updateTraces()));
List_Limit_Stop_Freq.append(new_limit_fstop_Spinbox);
this->LimitsGrid->addWidget(new_limit_fstop_Spinbox, limit_index, 3);
QString Combobox_stop_name = QStringLiteral("Lmt_Stop_ComboBox_%1").arg(new_limit_name);
QComboBox * new_stop_limit_Combo = new QComboBox();
new_stop_limit_Combo->setObjectName(Combobox_stop_name);
new_stop_limit_Combo->addItems(frequency_units);
if (f_limit2_unit.isEmpty()){
new_stop_limit_Combo->setCurrentIndex(QCombobox_x_axis_units->currentIndex());
} else {
int index = new_stop_limit_Combo->findText(f_limit2_unit);
new_stop_limit_Combo->setCurrentIndex(index);
}
connect(new_stop_limit_Combo, SIGNAL(currentIndexChanged(int)), SLOT(updateTraces()));
List_Limit_Stop_Freq_Scale.append(new_stop_limit_Combo);
this->LimitsGrid->addWidget(new_stop_limit_Combo, limit_index, 4);
// Remove button
QString DeleteButton_name = QStringLiteral("Lmt_Delete_Btn_%1").arg(new_limit_name);
QToolButton * new_limit_removebutton = new QToolButton();
new_limit_removebutton->setObjectName(DeleteButton_name);
tooltip_message = QStringLiteral("Remove this limit");
new_limit_removebutton->setToolTip(tooltip_message);
QIcon icon(":/bitmaps/trash.png");
new_limit_removebutton->setIcon(icon);
new_limit_removebutton->setStyleSheet(R"(
QToolButton {
background-color: #FF0000;
color: white;
border-radius: 20px;
}
)");
connect(new_limit_removebutton, SIGNAL(clicked()), SLOT(removeLimit()));
List_Button_Delete_Limit.append(new_limit_removebutton);
this->LimitsGrid->addWidget(new_limit_removebutton, limit_index, 5, Qt::AlignCenter);
QString SpinBox_val_start_name = QStringLiteral("Lmt_Val_Start_SpinBox_%1").arg(new_limit_name);
QDoubleSpinBox * new_limit_val_start_Spinbox = new QDoubleSpinBox();
new_limit_val_start_Spinbox->setObjectName(SpinBox_val_start_name);
new_limit_val_start_Spinbox->setMaximum(QSpinBox_y_axis_max->minimum());
new_limit_val_start_Spinbox->setMaximum(QSpinBox_y_axis_max->maximum());
new_limit_val_start_Spinbox->setValue(y_limit1);
new_limit_val_start_Spinbox->setSingleStep(QComboBox_y_axis_div->currentText().toDouble()/5);
connect(new_limit_val_start_Spinbox, SIGNAL(valueChanged(double)), SLOT(updateLimits()));
List_Limit_Start_Value.append(new_limit_val_start_Spinbox);
this->LimitsGrid->addWidget(new_limit_val_start_Spinbox, limit_index+1, 1);
// Coupled spinbox value
QString CoupleButton_name = QStringLiteral("Lmt_Couple_Btn_%1").arg(new_limit_name);
QPushButton * new_limit_CoupleButton = new QPushButton("<--->");
new_limit_CoupleButton->setObjectName(CoupleButton_name);
new_limit_CoupleButton->setChecked(coupled);
tooltip_message = QStringLiteral("Couple start and stop values");
new_limit_CoupleButton->setToolTip(tooltip_message);
connect(new_limit_CoupleButton, SIGNAL(clicked(bool)), SLOT(coupleSpinBoxes()));
List_Couple_Value.append(new_limit_CoupleButton);
this->LimitsGrid->addWidget(new_limit_CoupleButton, limit_index+1, 2);
QString SpinBox_val_stop_name = QStringLiteral("Lmt_Val_Stop_SpinBox_%1").arg(new_limit_name);
QDoubleSpinBox * new_limit_val_stop_Spinbox = new QDoubleSpinBox();
new_limit_val_stop_Spinbox->setObjectName(SpinBox_val_stop_name);
new_limit_val_stop_Spinbox->setMaximum(QSpinBox_y_axis_max->minimum());
new_limit_val_stop_Spinbox->setMaximum(QSpinBox_y_axis_max->maximum());
new_limit_val_stop_Spinbox->setValue(y_limit2);
new_limit_val_stop_Spinbox->setSingleStep(QComboBox_y_axis_div->currentText().toDouble()/5);
connect(new_limit_val_stop_Spinbox, SIGNAL(valueChanged(double)), SLOT(updateLimits()));
List_Limit_Stop_Value.append(new_limit_val_stop_Spinbox);
this->LimitsGrid->addWidget(new_limit_val_stop_Spinbox, limit_index+1, 3);
if (coupled){
new_limit_CoupleButton->setText("<--->");
} else {
new_limit_CoupleButton->setText("<-X->");
}
new_limit_CoupleButton->click();
QString Separator_name = QStringLiteral("Lmt_Separator_%1").arg(new_limit_name);
QFrame * new_Separator = new QFrame();
new_Separator->setObjectName(Separator_name);
new_Separator->setFrameShape(QFrame::HLine);
new_Separator->setFrameShadow(QFrame::Sunken);
List_Separators.append(new_Separator);
this->LimitsGrid->addWidget(new_Separator, limit_index+2, 0, 1, 6);
updateTraces();
}
void Qucs_S_SPAR_Viewer::coupleSpinBoxes(){
QPushButton* button = qobject_cast<QPushButton*>(sender());
// Get the button ID, from it we can get the index and then lock the upper limit spinbox
QString name_button = button->objectName();
// Get the limit name
int lastUnderscoreIndex = name_button.lastIndexOf('_');
QString limit_name = name_button.mid(lastUnderscoreIndex + 1);
// Get a list with the limit names
QList<QString> labelNames;
for (const QLabel *label : qAsConst(List_LimitNames)) {
labelNames.append(label->text());
}
int index = labelNames.indexOf(limit_name);
QDoubleSpinBox * upper_limit_spinbox = List_Limit_Stop_Value.at(index);
if (button->text() == "<--->"){
button->setText("<-X->");
QString tooltip_message = QStringLiteral("Uncouple start and stop values");
button->setToolTip(tooltip_message);
QDoubleSpinBox * lower_limit_spinbox = List_Limit_Start_Value.at(index);
upper_limit_spinbox->setValue(lower_limit_spinbox->value());
upper_limit_spinbox->setDisabled(true);
}else{
button->setText("<--->");
upper_limit_spinbox->setEnabled(true);
}
}
// This function is called when a limit widget is changed. It is needed in case some value-coupling
// button is activated
void Qucs_S_SPAR_Viewer::updateLimits()
{
// First check if some value-coupling button is activated. If not, simply call updateTraces()
int n_limits = List_Couple_Value.size();
for (int i = 0; i < n_limits; i++) {
QPushButton* button = List_Couple_Value.at(i);
if (button->text() == "<-X->"){
// The control is locked. Set the stop value equal to the start value
QDoubleSpinBox* start = List_Limit_Start_Value.at(i);
QDoubleSpinBox* stop = List_Limit_Stop_Value.at(i);
double val_start = start->value();
stop->setValue(val_start);
}
}
updateTraces();
}
void Qucs_S_SPAR_Viewer::slotSave()
{
if (savepath.isEmpty()){
slotSaveAs();
return;
}
save();
}
void Qucs_S_SPAR_Viewer::slotSaveAs()
{
if (datasets.isEmpty()){
// Nothing to save
QMessageBox::information(
this,
tr("Error"),
tr("Nothing to save: No data was loaded.") );
return;
}
// Get the path to save
savepath = QFileDialog::getSaveFileName(this,
tr("Save session"),
QDir::homePath() + "/ViewerSession.spar",
tr("Qucs-S snp viewer session (*.spar);"));
// If the user decides not to enter a path, then return.
if (savepath.isEmpty()){
return;
}
save();
}
bool Qucs_S_SPAR_Viewer::save()
{
if (datasets.isEmpty()){
// Nothing to save
QMessageBox::information(
this,
tr("Error"),
tr("Nothing to save: No data was loaded.") );
return false;
}
QFile file(savepath);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
{
return false;
}
QXmlStreamWriter xmlWriter(&file);
xmlWriter.setAutoFormatting(true);
xmlWriter.writeStartDocument();
xmlWriter.writeStartElement("DATA");//Top level
// ----------------------------------------------------------------
// Save the markers
if (List_MarkerFreq.size() != 0){
xmlWriter.writeStartElement("MARKERS");
double freq;
for (int i = 0; i < List_MarkerFreq.size(); i++)
{
freq = List_MarkerFreq[i]->value();
QString scale = List_MarkerScale[i]->currentText();
freq /= getFreqScale(scale);
xmlWriter.writeTextElement("Mkr", QString::number(freq));
}
xmlWriter.writeEndElement(); // Markers
}
// ----------------------------------------------------------------
// Save the limits
if (List_Limit_Start_Freq.size() != 0){
double freq, value;
bool Coupled_Limits;
xmlWriter.writeStartElement("LIMITS");
// Offset
value = Limits_Offset->value();
xmlWriter.writeTextElement("offset", QString::number(value));
for (int i = 0; i < List_Limit_Start_Freq.size(); i++)
{
xmlWriter.writeStartElement("Limit");
// fstart
freq = List_Limit_Start_Freq[i]->value();
xmlWriter.writeTextElement("fstart", QString::number(freq));
// fstart unit
QString fstart_unit = List_Limit_Start_Freq_Scale[i]->currentText();
xmlWriter.writeTextElement("fstart_unit", fstart_unit);
// Start value
value = List_Limit_Start_Value[i]->value();
xmlWriter.writeTextElement("val_start", QString::number(value));
// fstop
freq = List_Limit_Stop_Freq[i]->value();
xmlWriter.writeTextElement("fstop", QString::number(freq));
// fstop unit
QString fstop_unit = List_Limit_Stop_Freq_Scale[i]->currentText();
xmlWriter.writeTextElement("fstop_unit", fstop_unit);
// Stop value
value = List_Limit_Stop_Value[i]->value();
xmlWriter.writeTextElement("val_stop", QString::number(value));
// Couple values
Coupled_Limits = (List_Couple_Value[i]->text() == "<-X->");
xmlWriter.writeTextElement("couple_values", QString::number(Coupled_Limits));
xmlWriter.writeEndElement(); // Limit
}
xmlWriter.writeEndElement(); // Limits
}
// ----------------------------------------------------------------
// Save the traces displayed and their properties
if (List_TraceNames.size() != 0){
xmlWriter.writeStartElement("DISPLAYED_TRACES");
QString trace_name, color, style;
int width;
for (int i = 0; i < List_TraceNames.size(); i++){
xmlWriter.writeStartElement("trace");
// Trace name
trace_name = List_TraceNames[i]->text();
xmlWriter.writeTextElement("trace_name", trace_name);
// Trace width
width = List_TraceWidth[i]->value();
xmlWriter.writeTextElement("trace_width", QString::number(width));
// Trace color
color = List_Trace_Color[i]->palette().color(QPalette::Button).name();
xmlWriter.writeTextElement("trace_color", color);
// Trace style
style = List_Trace_LineStyle[i]->currentText();
xmlWriter.writeTextElement("trace_style", style);
xmlWriter.writeEndElement(); // Trace
}
xmlWriter.writeEndElement(); // Displayed traces
}
// ----------------------------------------------------------------
// Save the axes settings
xmlWriter.writeStartElement("AXES");
xmlWriter.writeTextElement("x-axis-min", QString::number(QSpinBox_x_axis_min->value()));
xmlWriter.writeTextElement("x-axis-max", QString::number(QSpinBox_x_axis_max->value()));
xmlWriter.writeTextElement("x-axis-div", QComboBox_x_axis_div->currentText());
xmlWriter.writeTextElement("x-axis-scale", QCombobox_x_axis_units->currentText());
xmlWriter.writeTextElement("y-axis-min", QString::number(QSpinBox_y_axis_min->value()));
xmlWriter.writeTextElement("y-axis-max", QString::number(QSpinBox_y_axis_max->value()));
xmlWriter.writeTextElement("y-axis-div", QComboBox_y_axis_div->currentText());
xmlWriter.writeTextElement("lock_status", QString::number(lock_axis));
xmlWriter.writeEndElement(); // Axes
// ----------------------------------------------------------------
// Save notes
xmlWriter.writeStartElement("NOTES");
xmlWriter.writeTextElement("note", Notes_Widget->getText());
xmlWriter.writeEndElement();
// ----------------------------------------------------------------
// Save the datasets
// Only S-parameter data is saved. This is done to minimize the size of the session file.
xmlWriter.writeStartElement("DATASETS");
for (auto outerIt = datasets.constBegin(); outerIt != datasets.constEnd(); ++outerIt)
{
xmlWriter.writeStartElement("file");
xmlWriter.writeAttribute("file_name", outerIt.key());
const QMap<QString, QList<double>>& innerMap = outerIt.value();
for (auto innerIt = innerMap.constBegin(); innerIt != innerMap.constEnd(); ++innerIt)
{
QString trace_name = innerIt.key();
QStringList blacklist;
blacklist.append("K");
blacklist.append("mu");
blacklist.append("mu_p");
blacklist.append("delta");
blacklist.append("MAG");
blacklist.append("MSG");
blacklist.append("Re{Zin}");
blacklist.append("Im{Zin}");
blacklist.append("Re{Zout}");
blacklist.append("Im{Zout}");
if (blacklist.contains(trace_name)){
// Zin, Zout, K, mu, etc. traces are discarded
continue;
}
// Only S (Re/Im ang dB/ang) traces here
xmlWriter.writeStartElement("trace");
xmlWriter.writeAttribute("trace_name", trace_name);
const QList<double>& values = innerIt.value();
for (const double& value : values)
{
xmlWriter.writeTextElement("value", QString::number(value));
}
xmlWriter.writeEndElement(); // inner-item
}
xmlWriter.writeEndElement(); // outer-item
}
xmlWriter.writeEndElement(); // Datasets
// ----------------------------------------------------------------
xmlWriter.writeEndElement(); // Top level
xmlWriter.writeEndDocument();
file.close();
return true;
}
void Qucs_S_SPAR_Viewer::slotLoadSession()
{
QString fileName = QFileDialog::getOpenFileName(this,
tr("Open S-parameter Viewer Session"),
QDir::homePath(),
tr("Qucs-S snp viewer session (*.spar);"));
loadSession(fileName);
}
void Qucs_S_SPAR_Viewer::loadSession(QString session_file)
{
QFile file(session_file);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Error opening file:" << file.errorString();
return;
}
savepath = session_file;
addRecentFile(session_file);// Add it to the "Recent Files" list
QXmlStreamReader xml(&file);
// Trace properties
QList<int> trace_width;
QList<QString> trace_name, trace_color, trace_style;
// Limit data
QList<double> Limit_Start_Freq, Limit_Start_Val, Limit_Stop_Freq, Limit_Stop_Val;
QList<int> Limit_Couple_Values;
QList<QString> Limit_Start_Freq_Unit, Limit_Stop_Freq_Unit;
double x_axis_min, x_axis_max, y_axis_min, y_axis_max;
int index_x_axis_units, index_x_axis_div, index_y_axis_div;
bool lock_axis_setting;
// Markers
QList<double> Markers;
// Clear current dataset
datasets.clear();
// Ensure that the axes settings are unlocked
lock_axis = true;
lock_unlock_axis_settings();
while (!xml.atEnd() && !xml.hasError()) {
// Read next element
QXmlStreamReader::TokenType token = xml.readNext();
//qDebug() << xml.name().toString();
if (token == QXmlStreamReader::StartElement) {
if (xml.name() == QStringLiteral("trace")) {
while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == QStringLiteral("trace"))) {
xml.readNext();
if (xml.tokenType() == QXmlStreamReader::StartElement) {
if (xml.name() == QStringLiteral("trace_name")) {
trace_name.append(xml.readElementText());
} else if (xml.name() == QStringLiteral("trace_width")) {
trace_width.append(xml.readElementText().toInt());
} else if (xml.name() == QStringLiteral("trace_color")) {
trace_color.append(xml.readElementText());
} else if (xml.name() == QStringLiteral("trace_style")) {
trace_style.append(xml.readElementText());
}
}
}
} else if (xml.name().toString().contains("x-axis-min")) {
x_axis_min = xml.readElementText().toDouble();
} else if (xml.name().toString().contains("x-axis-max")) {
x_axis_max = xml.readElementText().toDouble();
} else if (xml.name().toString().contains("x-axis-div")) {
int x_axis_div = xml.readElementText().toInt();
index_x_axis_div = available_x_axis_div.indexOf(x_axis_div);
} else if (xml.name().toString().contains("x-axis-scale")) {
QString x_axis_scale = xml.readElementText();
index_x_axis_units = frequency_units.indexOf(x_axis_scale);
} else if (xml.name().toString().contains("y-axis-min")) {
y_axis_min = xml.readElementText().toDouble();
} else if (xml.name().toString().contains("y-axis-max")) {
y_axis_max = xml.readElementText().toDouble();
} else if (xml.name().toString().contains("y-axis-div")) {
int y_axis_div = xml.readElementText().toInt();
index_y_axis_div = available_y_axis_div.indexOf(y_axis_div);
} else if (xml.name().toString().contains("lock_status")) {
lock_axis_setting = xml.readElementText().toInt();
} else if (xml.name() == QStringLiteral("Limit")) {
while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == QStringLiteral("Limit"))) {
xml.readNext();
if (xml.tokenType() == QXmlStreamReader::StartElement) {
if (xml.name() == QStringLiteral("fstart")) {
Limit_Start_Freq.append(xml.readElementText().toDouble());
} else if (xml.name() == QStringLiteral("val_start")) {
Limit_Start_Val.append(xml.readElementText().toDouble());
} else if (xml.name() == QStringLiteral("fstop")) {
Limit_Stop_Freq.append(xml.readElementText().toDouble());
} else if (xml.name() == QStringLiteral("val_stop")) {
Limit_Stop_Val.append(xml.readElementText().toDouble());
} else if (xml.name() == QStringLiteral("fstart_unit")) {
Limit_Start_Freq_Unit.append(xml.readElementText());
} else if (xml.name() == QStringLiteral("fstop_unit")) {
Limit_Stop_Freq_Unit.append(xml.readElementText());
} else if (xml.name() == QStringLiteral("couple_values")) {
Limit_Couple_Values.append(xml.readElementText().toInt());
}else if (xml.name() == QStringLiteral("offset")) {
Limits_Offset->setValue(xml.readElementText().toDouble());
}
}
}
} else if (xml.name() == QStringLiteral("MARKERS")){
while (!(xml.tokenType() == QXmlStreamReader::EndElement && xml.name() == QStringLiteral("MARKERS"))) {
xml.readNext();
if (xml.tokenType() == QXmlStreamReader::StartElement) {
double value = xml.readElementText().toDouble();
Markers.append(value);
}
}
} else if (xml.name() == QStringLiteral("file")) {
// Load datasets
QString fileName, traceName;
while (!xml.atEnd() && !xml.hasError())
{
if (xml.tokenType() == QXmlStreamReader::StartElement)
{
if (xml.name() == QStringLiteral("file"))
{
fileName = xml.attributes().value("file_name").toString();
//qDebug() << "File name:" << fileName;
}
else if (xml.name() == QStringLiteral("trace"))
{
traceName = xml.attributes().value("trace_name").toString();
//qDebug() << "Trace name:" << traceName;
}
else if (xml.name() == QStringLiteral("value"))
{
QString value = xml.readElementText();
//qDebug() << "Value:" << value;
datasets[fileName][traceName].append(value.toDouble());
}
}
xml.readNext();
}
} else if (xml.name().toString().contains("note")){
QString note = xml.readElementText();
Notes_Widget->loadText(note);
}
}
}
if (xml.hasError()) {
qDebug() << "Error parsing XML: " << xml.errorString();
}
// Close the file
file.close();
// Update dataset and trace selection comboboxes
QStringList files = datasets.keys();
for (int i = 0; i < files.size(); i++){
QString file = files.at(i);
QCombobox_datasets->addItem(file);
// Add file management widgets
// Label
QLabel * Filename_Label = new QLabel(file);
Filename_Label->setObjectName(QStringLiteral("File_") + QString::number(i));
List_FileNames.append(Filename_Label);
this->FilesGrid->addWidget(List_FileNames.last(), i, 0, 1, 1);
// Create the "Remove" button
QToolButton * RemoveButton = new QToolButton();
RemoveButton->setObjectName(QStringLiteral("Remove_") + QString::number(i));
QIcon icon(":/bitmaps/trash.png"); // Use a resource path or a relative path
RemoveButton->setIcon(icon);
RemoveButton->setStyleSheet("QToolButton {background-color: red;\
border-width: 2px;\
border-radius: 10px;\
border-color: beige;\
font: bold 14px;\
}");
List_RemoveButton.append(RemoveButton);
this->FilesGrid->addWidget(List_RemoveButton.last(), i, 1, 1, 1);
connect(RemoveButton, SIGNAL(clicked()), SLOT(removeFile())); // Connect button with the handler to remove the entry.
}
updateTracesCombo();// Update traces
// Add traces to the display
for (int i = 0; i < trace_name.size(); i++){
QStringList parts = {
trace_name[i].section('.', 0, -2),
trace_name[i].section('.', -1)
};
addTrace(parts[0], parts[1], trace_color.at(i), trace_width.at(i), trace_style.at(i));
}
// Apply axis settings
// It's needed to disconnect the signals first in order to avoid unneeded calls to the slots
disconnect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
disconnect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
disconnect(QComboBox_x_axis_div, SIGNAL(currentIndexChanged(int)), this, SLOT(updatePlot()));
disconnect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), this, SLOT(changeFreqUnits()));
disconnect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
disconnect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), this, SLOT(updatePlot()));
QSpinBox_x_axis_min->setValue(x_axis_min);
QSpinBox_x_axis_max->setValue(x_axis_max);
QComboBox_x_axis_div->setCurrentIndex(index_x_axis_div);
QCombobox_x_axis_units->setCurrentIndex(index_x_axis_units);
QSpinBox_y_axis_min->setValue(y_axis_min);
QSpinBox_y_axis_max->setValue(y_axis_max);
QComboBox_y_axis_div->setCurrentIndex(index_y_axis_div);
connect(QSpinBox_x_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_x_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QComboBox_x_axis_div, SIGNAL(currentIndexChanged(int)), SLOT(updatePlot()));
connect(QCombobox_x_axis_units, SIGNAL(currentIndexChanged(int)), SLOT(changeFreqUnits()));
connect(QSpinBox_y_axis_min, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
connect(QSpinBox_y_axis_max, SIGNAL(valueChanged(double)), SLOT(updatePlot()));
// Apply lock axes status
lock_axis = lock_axis_setting;
lock_unlock_axis_settings(false);//false means "don't change the state" inside the function
// Update chart frequency limits
this->f_min = x_axis_min*getFreqScale(QCombobox_x_axis_units->currentText());
this->f_max = x_axis_max*getFreqScale(QCombobox_x_axis_units->currentText());
// Add markers
for (int i = 0; i < Markers.size(); i++){
addMarker(Markers.at(i));
}
// Add limits
for (int i = 0; i < Limit_Start_Freq.size(); i++){
addLimit(Limit_Start_Freq.at(i), Limit_Start_Freq_Unit.at(i), Limit_Stop_Freq.at(i), Limit_Stop_Freq_Unit.at(i), Limit_Start_Val.at(i), Limit_Stop_Val.at(i), Limit_Couple_Values.at(i));
}
// Show the trace settings widget
dockTracesList->raise();
return;
}
void Qucs_S_SPAR_Viewer::updateGridLayout(QGridLayout* layout)
{
// Store widget information
struct WidgetInfo {
QWidget* widget;
int row, column, rowSpan, columnSpan;
Qt::Alignment alignment;
};
QVector<WidgetInfo> widgetInfos;
// Collect information about remaining widgets
for (int i = 0; i < layout->count(); ++i) {
QLayoutItem* item = layout->itemAt(i);
QWidget* widget = item->widget();
if (widget) {
int row, column, rowSpan, columnSpan;
layout->getItemPosition(i, &row, &column, &rowSpan, &columnSpan);
widgetInfos.push_back({widget, row, column, rowSpan, columnSpan, item->alignment()});
}
}
// Clear the layout
while (layout->count() > 0) {
QLayoutItem* item = layout->takeAt(0);
delete item;
}
// Re-add widgets with updated positions
int row = 0;
for (const auto& info : widgetInfos) {
int newColumn = info.column;
if (info.columnSpan == layout->columnCount()){// Separator widget
row++;
}
layout->addWidget(info.widget, row, newColumn, info.rowSpan, info.columnSpan, info.alignment);
if (info.columnSpan == layout->columnCount()){
row++;
}
if (newColumn == layout->columnCount()-1) {
row++;
}
}
}
// Add session file to the recent files list
void Qucs_S_SPAR_Viewer::addRecentFile(const QString& filePath) {
recentFiles.insert(recentFiles.begin(), filePath);
recentFiles.erase(std::unique(recentFiles.begin(), recentFiles.end()), recentFiles.end());
if (recentFiles.size() > 10) {
recentFiles.resize(10);
}
}
// This function updates teh "Recent Files" list whenever the user hovers the mouse over the menu
void Qucs_S_SPAR_Viewer::updateRecentFilesMenu() {
recentFilesMenu->clear();
for (const auto& filePath : recentFiles) {
QAction* action = recentFilesMenu->addAction(filePath);
connect(action, &QAction::triggered, this, [this, filePath]() {
loadSession(filePath);
});
}
recentFilesMenu->addSeparator();
recentFilesMenu->addAction("Clear Recent Files", this, &Qucs_S_SPAR_Viewer::clearRecentFiles);
}
void Qucs_S_SPAR_Viewer::clearRecentFiles() {
recentFiles.clear();
}
// Save "Recent Files" list. This is called when the program is about to close
void Qucs_S_SPAR_Viewer::saveRecentFiles() {
QSettings settings;
settings.setValue("recentFiles", QVariant::fromValue(recentFiles));
}
// Load "Recent Files" list. This is called when the program starts up
void Qucs_S_SPAR_Viewer::loadRecentFiles() {
QSettings settings;
recentFiles = settings.value("recentFiles").value<std::vector<QString>>();
}
// This function is called when the user wants to see a trace which can be calculated from the S-parameters
void Qucs_S_SPAR_Viewer::calculate_Sparameter_trace(QString file, QString metric){
std::complex<double> s11, s12, s21, s22, s11_conj, s22_conj;
double Z0 = datasets[file]["Rn"].last();
for (int i = 0; i < datasets[file]["S11_re"].size(); i++) {
// S-parameter data (n.u.)
double s11_re = datasets[file]["S11_re"][i];
double s11_im = datasets[file]["S11_im"][i];
s11 = std::complex<double>(s11_re, s11_im);
s11_conj = std::complex<double>(s11_re, -s11_im);
if ( datasets[file]["n_ports"].last() == 2) {
double s12_re = datasets[file]["S12_re"][i];
double s12_im = datasets[file]["S12_im"][i];
double s21_re = datasets[file]["S21_re"][i];
double s21_im = datasets[file]["S21_im"][i];
double s22_re = datasets[file]["S22_re"][i];
double s22_im = datasets[file]["S22_im"][i];
s12 = std::complex<double> (s12_re, s12_im);
s21 = std::complex<double> (s21_re, s21_im);
s22 = std::complex<double> (s22_re, s22_im);
s22_conj = std::complex<double> (s22_re, -s22_im);
}
double delta = abs(s11*s22 - s12*s21); // Determinant of the S matrix
if (!metric.compare("delta")) {
datasets[file]["delta"].append(delta);
} else {
if (!metric.compare("K")) {
double K = (1 - abs(s11)*abs(s11) - abs(s22)*abs(s22) + delta*delta) / (2*abs(s12*s21)); // Rollet factor.
datasets[file]["K"].append(K);
} else {
if (!metric.compare("mu")) {
double mu = (1 - abs(s11)*abs(s11)) / (abs(s22-delta*s11_conj) + abs(s12*s21));
datasets[file]["mu"].append(mu);
} else {
if (!metric.compare("mu_p")) {
double mu_p = (1 - abs(s22)*abs(s22)) / (abs(s11-delta*s22_conj) + abs(s12*s21));
datasets[file]["mu_p"].append(mu_p);
} else {
if (!metric.compare("MSG")) {
double MSG = abs(s21) / abs(s12);
MSG = 10*log10(MSG);
datasets[file]["MSG"].append(MSG);
} else {
if (!metric.compare("MSG")) {
double K = (1 - abs(s11)*abs(s11) - abs(s22)*abs(s22) + delta*delta) / (2*abs(s12*s21)); // Rollet factor.
double MSG = abs(s21) / abs(s12);
double MAG = MSG * (K - std::sqrt(K * K - 1));
MAG = 10*log10(abs(MAG));
datasets[file]["MAG"].append(MAG);
} else {
if (metric.contains("Zin")) {
std::complex<double> Zin = std::complex<double>(Z0) * (1.0 + s11) / (1.0 - s11);
datasets[file]["Re{Zin}"].append(Zin.real());
datasets[file]["Im{Zin}"].append(Zin.imag());
} else {
if (metric.contains("Zout")) {
std::complex<double> Zout = std::complex<double>(Z0) * (1.0 + s22) / (1.0 - s22);
datasets[file]["Re{Zout}"].append(Zout.real());
datasets[file]["Im{Zout}"].append(Zout.imag());
}
}
}
}
}
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink