qucs-s-spar-viewer.h

Go to the documentation of this file.

 
 
#ifndef QUCSSPARVIEWER_H
#define QUCSSPARVIEWER_H
 
#include "UI/PlotWidgets/polarplotwidget.h"
#include "UI/PlotWidgets/rectangularplotwidget.h"
#include "UI/PlotWidgets/smithchartwidget.h"
 
#include "UI/CustomWidgets/codeeditor.h"
#include "UI/CustomWidgets/matrixcombopopup.h"
#include "UI/CustomWidgets/CustomDoubleSpinBox.h"
 
#include "Tools/DesignTools/AttenuatorDesign/AttenuatorDesignTool.h"
#include "Tools/DesignTools/Filtering/FilterDesignTool.h"
#include "Tools/DesignTools/MatchingNetwork/MatchingNetworkDesignTool.h"
#include "Tools/DesignTools/NetlistScratchPad/netlistscratchpad.h"
#include "Tools/DesignTools/PowerCombining/PowerCombiningTool.h"
#include "Tools/DesignTools/SimulationSetup/simulationsetup.h"
 
#include "SPAR/SParameterCalculator.h"
 
#include "Misc/general.h"
 
#include "aboutdialog.h"
 
 
#include <QCheckBox>
#include <QColorDialog>
#include <QDoubleSpinBox>
#include <QGridLayout>
#include <QLabel>
#include <QMainWindow>
#include <QScrollArea>
#include <QTableWidget>
#include <QtGlobal>
#include <complex>
#include <utility> // std::as_const()
 
 
 
class QComboBox;
class QTableWidget;
class QLineEdit;
class QIntValidator;
class QDoubleValidator;
class QLabel;
class QPushButton;
 
class GammaCalculatorDialog;
 
struct tQucsSettings {
  int x, y;                 
  QFont font;               
  QString LangDir;          
  QString Language;         
  QString theme;            
  QString customThemePath;  
};
 
extern struct tQucsSettings QucsSettings;
 
struct MarkerProperties {
  QLabel* nameLabel;           
  QDoubleSpinBox* freqSpinBox; 
  QComboBox* scaleComboBox;    
  QToolButton* deleteButton;   
};
 
enum class DisplayMode {
  Magnitude_dB,   
  Phase,          
  Smith,          
  Polar,          
  PortImpedance,  
  Stability,      
  VSWR,           
  GroupDelay      
};
 
struct TraceProperties {
  QLabel* nameLabel;             
  QSpinBox* width;               
  QPushButton* colorButton;      
  QComboBox* LineStyleComboBox;  
  QToolButton* deleteButton;     
  QString display_mode;          
};
 
 
struct LimitProperties {
  QLabel* LimitLabel;                 
  QDoubleSpinBox* Start_Freq;         
  QDoubleSpinBox* Stop_Freq;          
  QDoubleSpinBox* Start_Value;        
  QDoubleSpinBox* Stop_Value;         
  QComboBox* Start_Freq_Scale;        
  QComboBox* Stop_Freq_Scale;         
  QComboBox* axis;                    
  QToolButton* Button_Delete_Limit;   
  QFrame* Separator;                  
  QPushButton* Couple_Value;          
};
 
struct TraceInfo {
  QString dataset;          
  QString parameter;        
  DisplayMode displayMode;  
 
  QString uniqueId() const {
    if ((displayMode == DisplayMode::Magnitude_dB) ||
        (displayMode == DisplayMode::Phase)) {
      QString displayMode_str = QString::number(static_cast<int>(displayMode)); // Assign to variable to avoid warning
      return QString("%1.%2_%3")
          .arg(dataset, parameter, displayMode_str);
    } else {
      return QString("%1.%2").arg(dataset, parameter);
    }
  }
 
  QString displayName() const {
    QString modeName = QString("");
 
    if (displayMode == DisplayMode::Magnitude_dB) {
      modeName = "dB";
    } else {
      if (displayMode == DisplayMode::Phase) {
        modeName = "Phase";
      } else {
        return QString("%1.%2").arg(dataset, parameter);
      }
    }
    return QString("%1.%2_%3").arg(dataset, parameter, modeName);
  }
};
 
 
class Qucs_S_SPAR_Viewer : public QMainWindow {
    Q_OBJECT
  public:
    Qucs_S_SPAR_Viewer();
 
    ~Qucs_S_SPAR_Viewer();
 
    void addPathToWatcher(const QString& path);
 
    void addFile(const QFileInfo& fileInfo);
 
 
  private slots:
    // Menu actions
    void slotHelpIntro();
 
    void slotHelpAbout() {
        AboutDialog dlg(this);
        dlg.exec();
    }
 
    void slotHelpAboutQt() { QMessageBox::aboutQt(this, tr("About Qt")); }
 
    void slotQuit() { qApp->quit(); }
 
    void slotSave();
 
    void slotSaveAs();
 
    void slotLoadSession();
 
    void slotSetLightTheme();
 
    void slotSetDarkTheme();
 
    void slotLoadCustomTheme();
 
    void raiseWidgetsOnTabSelection(int index);
 
    // File management
    void addFile();
 
    void addFiles(QStringList);
 
    void removeFile();
 
    void removeFile(QString ID);
 
    void removeAllFiles();
 
    void removeTracesByDataset(const QString& dataset_to_remove);
 
    QMap<QString, QList<double>> readQucsatorDataset(const QString& filePath);
 
    QMap<QString, QList<double>> readNGspiceData(const QString& filePath);
 
    QString extractSParamIndices(const QString& sparam);
 
    void applyDefaultVisualizations(const QStringList& fileNames);
 
    void addOptionalTraces(QMap<QString, QList<double>>& file_data);
 
    void removeTraceByProps(DisplayMode mode, const QString& traceID,
                            TraceProperties& props);
 
    void CreateFileWidgets(QString filename, int position = 0);
 
    // File watching
    void setupFileWatcher();
 
    void fileChanged(const QString& path);
 
    void directoryChanged(const QString& path); 
 
    // Trace management
    void addTrace();
 
    void addTrace(const TraceInfo& traceInfo, QColor trace_color, int trace_width,
                  QString trace_style = "Solid");
 
    void removeTrace();
 
    void removeAllTraces();
 
    void removeAll();
 
    void removeAndCollapseRow(QGridLayout* targetLayout, int row_to_remove);
 
    int getNumberOfTraces() { return traceMap.keys().size(); }
 
    void cleanToolsDatasets(const QString& excludeDataset = QString());
 
    void updateTracesCombo();
 
    void updateDisplayType();
 
    // Trace appearance
    void changeTraceColor();           
    void changeTraceLineStyle();       
    void changeTraceWidth();           
 
    void changeMarkerLimits();
 
    void changeMarkerLimits(QString);  
 
    // Marker management
    void addMarker(double freq = -1, QString Freq_Marker_Scale = QString("MHz"));
 
    void removeMarker();
 
    void removeMarker(const QString&);
 
    void removeAllMarkers();
 
    int getNumberOfMarkers() { return markerMap.keys().size(); }
 
    void updateMarkerTable();
 
    void updateMarkerNames();
 
    void updateMarkerData(QTableWidget& layout, DisplayMode mode, QStringList header);
 
    bool getMarkerByPosition(int position, QString& outMarkerName, MarkerProperties& outProperties);
 
    // Limit management
    void addLimit(double f_limit1 = -1, QString f_limit1_unit = "",
                  double f_limit2 = -1, QString f_limit2_unit = "",
                  double y_limit1 = -1, double y_limit2 = -1,
                  bool coupled = true);
 
    void onLimitDeleteClicked(bool);
 
    void removeLimit(QString);
 
    void removeAllLimits();
 
    void updateLimits();
 
    void updateLimitNames();
 
    void onLimitsOffsetChanged(double newOffset);
 
    int getNumberOfLimits() { return limitsMap.keys().size(); }
 
    bool getLimitByPosition(int, QString&, LimitProperties&);
 
    void coupleSpinBoxes();
 
    void updateGridLayout(QGridLayout*);
 
    void updateAllPlots(const QString& datasetName);
 
    void updateTracesInWidget(QWidget* widget, const QString& datasetName);
 
    void calculate_Sparameter_trace(QString, QString);
 
  protected:
    void dragEnterEvent(QDragEnterEvent* event) override;
 
    void dropEvent(QDropEvent* event) override;
 
  private:
 
    // UI Components - File Management
    QDockWidget* dockFiles;              
    QTableWidget* spar_files_Widget;     
    QPushButton *Button_Add_File;        
    QPushButton *Delete_All_Files;       
    QList<QPushButton*> Button_DeleteFile;  
    QVBoxLayout* vLayout_Files;          
    QWidget* FileList_Widget;            
    QGridLayout* FilesGrid;              
    QList<QLabel*> List_FileNames;       
    QList<QToolButton*> List_RemoveButton;  
 
    // UI Components - Trace Management
    QDockWidget* dockTracesList;         
    QWidget* TracesList_Widget;          
    QGridLayout* TracesGrid;             
 
    QMap<DisplayMode, QMap<QString, TraceProperties>> traceMap;
 
    QTabWidget* traceTabs;               
    QWidget *magnitudePhaseTab;          
    QWidget *smithTab;                   
    QWidget *polarTab;                   
    QWidget *portImpedanceTab;           
    QWidget *stabilityTab;               
    QWidget *VSWRTab;                    
    QWidget *GroupDelayTab;              
 
    QGridLayout *magnitudePhaseLayout;   
    QGridLayout *smithLayout;            
    QGridLayout *polarLayout;            
    QGridLayout *portImpedanceLayout;    
    QGridLayout *stabilityLayout;        
    QGridLayout *VSWRLayout;             
    QGridLayout *GroupDelayLayout;       
 
 
    // Trace selection widgets
    QPushButton* Lock_axis_settings_Button;  
    bool lock_axis;                          
    QStringList frequency_units;             
    QComboBox *QCombobox_datasets;           
    QComboBox *QCombobox_display_mode;       
    MatrixComboBox* QCombobox_traces;        
    QPushButton* Button_add_trace;           
    QPushButton* Button_Remove_all;          
    QTableWidget* Traces_Widget;             
 
    // Set-up Scrollable trace areas
    void setupScrollableLayout();
 
    void setupScrollAreaForLayout(QGridLayout*& layout, QWidget* parentTab,
                                  const QString& objectName);
 
 
    // Scroll areas
    QScrollArea *magnitudePhaseScrollArea;   
    QScrollArea *smithScrollArea;            
    QScrollArea *polarScrollArea;            
    QScrollArea *nuScrollArea;               
    QScrollArea *GroupDelayScrollArea;       
 
    // Datasets
    QMap<QString, QMap<QString, QList<double>>> datasets;
 
    /* DATASET STRUCTURE
        KEY       |         DATA
    Filename1.s2p | {"freq", "S11_dB", ..., "S22_ang"}
        ...       |          ...
    Filenamek.s3p | {"freq", "S11_dB", ..., "S33_ang"}
    */
 
    // File watching
    QFileSystemWatcher* fileWatcher;          
    QMap<QString, QString> watchedFilePaths;  
 
 
    // Plot widgets
    // Magnitude plot
    RectangularPlotWidget* Magnitude_PhaseChart;  
    QDockWidget* dockChart;                       
    double f_min, f_max;                          
    QList<QColor> default_colors;                 
    QList<QGraphicsItem*> textLabels;             
 
    // Smith Chart
    SmithChartWidget* smithChart;                      
    QDockWidget* dockSmithChart;                       
    QList<SmithChartWidget::Trace> SmithChartTraces;   
 
    // Polar plot
    PolarPlotWidget* polarChart;                       
    QDockWidget* dockPolarChart;                       
    QList<PolarPlotWidget::Trace> PolarChartTraces;    
 
    // Port impedance plot (Rectangular plot)
    RectangularPlotWidget* impedanceChart;                     
    QDockWidget* dockImpedanceChart;                           
    QList<RectangularPlotWidget::Trace> impedanceChartTraces;  
 
    // Stability plot (Rectangular plot)
    RectangularPlotWidget* stabilityChart;                     
    QDockWidget* dockStabilityChart;                           
    QList<RectangularPlotWidget::Trace> stabilityChartTraces;  
 
    // VSWR plot (Rectangular plot)
    RectangularPlotWidget* VSWRChart;                     
    QDockWidget* dockVSWRChart;                           
    QList<RectangularPlotWidget::Trace> VSWRChartTraces;  
 
    // Group delay plot (Rectangular plot)
    RectangularPlotWidget* GroupDelayChart;                
    QDockWidget* dockGroupDelayChart;                      
    QList<RectangularPlotWidget::Trace> GroupDelayTraces;  
 
    // Markers
    QDockWidget* dockMarkers;                
    QWidget* Marker_Widget;                  
    QGridLayout* MarkersGrid;                
    QPushButton *Button_add_marker;          
    QPushButton *Button_Remove_All_Markers;  
 
    QTableWidget *tableMarkers_Magnitude_Phase;  
    QTableWidget *tableMarkers_Smith;            
    QTableWidget *tableMarkers_Polar;            
    QTableWidget *tableMarkers_PortImpedance;    
    QTableWidget *tableMarkers_Stability;        
    QTableWidget *tableMarkers_VSWR;             
    QTableWidget *tableMarkers_GroupDelay;       
 
    QMap<QString, MarkerProperties> markerMap;
 
    double getMarkerFreq(QString);
 
    // Limit widgets
    QDockWidget* dockLimits;                 
    QWidget* Limits_Widget;                  
    QGridLayout* LimitsGrid;                 
    QPushButton *Button_add_Limit;           
    QPushButton *Button_Remove_All_Limits;   
    CustomDoubleSpinBox* Limits_Offset;           
 
    QMap<QString, LimitProperties> limitsMap;
 
    // Tools
    QDockWidget* dockTools;                  
    GraphWidget* SchematicWidget;            
    QTabWidget* toolsTabWidget;              
    SimulationSetup* SimulationSetupWidget;  
 
    SchematicContent Circuit;
 
    // Export widgets
    QLabel* LabelExportSchematic;            
    QPushButton* ButtonExportSchematic;      
    QComboBox* ComboExportSchematic;         
    QComboBox* ComboExportOutputMethod;      
 
    void updateSchematicContent();
 
    void callTools(bool visible);
 
    void onToolsTabChanged(int index);
 
    // Design tools
    QTabWidget* toolsTabs;                   
 
    QStringList Tools_Datasets;              
    FilterDesignTool* FilterTool;            
    MatchingNetworkDesignTool* MatchingTool; 
    PowerCombiningTool* PowerCombTool;       
    AttenuatorDesignTool* AttenuatorTool;    
 
    // S-parameter simulation class
    SParameterCalculator SPAR_engine;
 
    // Substrate
    MS_Substrate MS_Subs;
 
    NetlistScratchPad* Netlist_Tool;
 
    // Save
    QString savepath;
 
    bool save();
 
    void loadSession(QString path);
 
    void saveRectangularPlotSettings(QXmlStreamWriter& xml,
                                     RectangularPlotWidget* widget,
                                     const QString& elementName);
 
    void loadRectangularPlotSettings(QXmlStreamReader& xml,
                                     RectangularPlotWidget* widget,
                                     const QString& elementName);
 
    void saveSmithPlotSettings(QXmlStreamWriter& xml, SmithChartWidget* widget,
                               const QString& elementName);
 
    void loadSmithPlotSettings(QXmlStreamReader& xml, SmithChartWidget* widget,
                               const QString& elementName);
 
    void savePolarPlotSettings(QXmlStreamWriter& xml, PolarPlotWidget* widget,
                               const QString& elementName);
 
    void loadPolarPlotSettings(QXmlStreamReader& xml, PolarPlotWidget* widget,
                               const QString& elementName);
 
    // Notes
    QDockWidget* dockNotes;   
    CodeEditor* Notes_Widget; 
 
    // Recent files
    std::vector<QString> recentFiles;  
    QMenu* recentFilesMenu;            
 
    void updateRecentFilesMenu();
 
    void loadRecentFiles();
 
    void addRecentFile(const QString&);
 
    void clearRecentFiles(){ recentFiles.clear(); }
 
    void saveRecentFiles();
 
    // Setup UI
    void CreateMenuBar();              
    void CreateDisplayWidgets();       
    void CreateRightPanel();           
    void setFileManagementDock();      
    void setTraceManagementDock();     
    void setMarkerManagementDock();    
    void setLimitManagementDock();     
    void setToolsDock();               
 
    // Utility methods
    void getMinMaxValues(QString, QString, qreal&, qreal&, qreal&, qreal&);
 
    void adjust_x_axis_to_file(QString);
    void adjust_y_axis_to_trace(QString, QString);
    void adjust_x_axis_div();
 
    // File monitoring
    void setupSimulationWatcher();
    QStringList getWatchDirectories() const;
 
    bool isSparamFile(const QString& path);
 
    QStringList filePaths; // Full path of the files in the progrom. It's used for
                           // file monitoring.
 
 
    QMenu *CreateCalculatorsMenu();
 
    void applyTheme(const QString& themeName);
 
  private slots:
    void updateSimulation(SchematicContent SI);
 
    void updateSimulation();
 
    void updateSubstrate();
 
    void exportSchematic();
 
 
    // Dialog calculators
private slots:
    // ***** RF calculators *****
    void slotGammaCalculator();
 
    void slotImpedanceCalculator();
 
    void slotSwrS11Calculator();
 
    void slotOctaveBWCalculator();
 
    void slotRFPowerUnitCalculator();
 
    void slotFrequencyToWavelengthCalculator();
 
    void slotFreeSpaceLossCalculator();
 
    void slotImageFrequencyCalculator();
 
    void slotSecondaryImageFrequencyCalculator();
 
    // ***** General electronics calculators *****
    void slotVoltageDividerCalculator();
 
    void slotParallelResistorsCalculator();
 
    void slotSeriesCapacitorsCalculator();
 
    void slotParallelInductorsCalculator();
};
 
#endif