SParameterCalculator.h

Go to the documentation of this file.

 
 
#ifndef SPARAMETERCALCULATOR_H
#define SPARAMETERCALCULATOR_H
 
#include <QFile>
#include <QList>
#include <QMap>
#include <QRegularExpression>
#include <QString>
#include <QStringList>
#include <QTextStream>
#include <algorithm>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <utility> // std::as_const()
 
#include "Misc/general.h"
 
using namespace std;
using Complex = complex<double>;
 
enum class ComponentType_SPAR {
  RESISTOR,
  CAPACITOR,
  INDUCTOR,
  VOLTAGE_SOURCE,
  CURRENT_SOURCE,
  TRANSMISSION_LINE,
  OPEN_STUB,
  SHORT_STUB,
  COUPLED_LINE,
  IDEAL_COUPLER,
  COMPLEX_IMPEDANCE,
  SPAR_BLOCK,
  FREQUENCY_DEPENDENT_SPAR_BLOCK,
  MICROSTRIP_LINE,
  MICROSTRIP_STEP,
  MICROSTRIP_OPEN,
  MICROSTRIP_VIA,
  MICROSTRIP_COUPLED_LINES
};
 
struct Component_SPAR {
  ComponentType_SPAR type;          
  string name;                       
  vector<int> nodes;                 
  double frequency;                  
  QMap<QString, double> value;       
  QMap<QString, Complex> Zvalue;     
  vector<vector<Complex>> Smatrix;   
  QMap<QString, QList<double>> freqDepData; 
  int numRFPorts;                    
  double referenceImpedance;         
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 const vector<vector<Complex>>& S, int rfPorts,
                 double Z0 = 50.0)
      : type(t), name(n), nodes(nds), frequency(0.0),
        Smatrix(S), numRFPorts(rfPorts), referenceImpedance(Z0) {}
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 QMap<QString, QList<double>> freqData, int rfPorts,
                 double Z0 = 50.0)
      : type(t), name(n), nodes(nds), frequency(0.0),
        freqDepData(freqData), numRFPorts(rfPorts), referenceImpedance(Z0) {}
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 QMap<QString, double> val)
      : type(t), name(n), nodes(nds), frequency(0.0), value(val) {}
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 QMap<QString, Complex> zval)
      : type(t), name(n), nodes(nds), frequency(0.0), Zvalue(zval) {}
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 const vector<vector<Complex>>& S)
      : type(t), name(n), nodes(nds), frequency(0.0), Smatrix(S) {}
 
  Component_SPAR(ComponentType_SPAR t, const string& n, const vector<int>& nds,
                 QMap<QString, QList<double>> freqData)
      : type(t), name(n), nodes(nds), frequency(0.0), freqDepData(freqData) {}
};
 
struct Port {
  int node;              
  double impedance;      
 
  Port(int n, double z = 50.0) : node(n), impedance(z) {}
};
 
class SParameterCalculator {
private:
  vector<Component_SPAR> components;  
  vector<Port> ports;                 
  int numNodes;                       
  double frequency;                   
  QString currentNetlist;             
 
  // Matrix operations
 
  vector<vector<Complex>> createMatrix(int rows, int cols) {
    return vector<vector<Complex>>(rows, vector<Complex>(cols, Complex(0, 0)));
  }
 
  vector<vector<Complex>> invertMatrix(const vector<vector<Complex>>& matrix);
 
  Complex getImpedance(const Component_SPAR& comp, double freq);
 
  vector<vector<Complex>> buildAdmittanceMatrix();
 
  void addCoupledLineToAdmittance(vector<vector<Complex>>& Y,
                                  const Component_SPAR& comp);
 
  vector<vector<Complex>> calculateCoupledLineYMatrix(double Z0e, double Z0o,
                                                      double length,
                                                      double freq);
 
  void addIdealCouplerToAdmittance(vector<vector<Complex>>& Y,
                                   const Component_SPAR& comp);
 
  vector<vector<Complex>>
  calculateIdealCouplerYMatrix(double k, double phase_deg, double Z0);
 
 
  void addTransmissionLineToAdmittance(vector<vector<Complex>>& Y,
                                       const Component_SPAR& comp);
 
  vector<vector<Complex>>
  interpolateFrequencyDependentSMatrix(const Component_SPAR& comp, double freq);
 
  vector<vector<Complex>> extractSMatrixAtIndex(const Component_SPAR& comp,
                                                int freqIndex);
 
  void addFrequencyDependentSParamBlockToAdmittance(vector<vector<Complex>>& Y,
                                                    const Component_SPAR& comp);
 
  vector<vector<Complex>> parseInlineSMatrix(const QString& matrixStr,
                                             int numPorts);
 
  void addOnePortSParamToAdmittance(vector<vector<Complex>>& Y,
                                    const Component_SPAR& comp);
 
  void addTwoPortSParamToAdmittance(vector<vector<Complex>>& Y,
                                    const Component_SPAR& comp);
 
  void addSParameterDevice(const string& name, const vector<int>& nodes,
                           const vector<vector<Complex>>& Smatrix,
                           int numRFPorts, double Z0);
 
  // Microstrip line analysis methods
 
  void addMicrostripLineToAdmittance(vector<vector<Complex>>& Y,
                                     const Component_SPAR& comp);
 
  void calcMicrostripPropagation(double W, double h, double er,
                                 double t, double tand, double rho,
                                 double frequency, double& alpha, double& beta,
                                 double& zl, double& ereff);
 
  void analyseQuasiStatic(double W, double h, double t, double er,
                          const string& Model, double& ZlEff, double& ErEff,
                          double& WEff);
 
  void analyseDispersion(double W, double h, double er, double ZlEff,
                         double ErEff, double frequency, const string& Model,
                         double& ZlEffFreq, double& ErEffFreq);
 
  void analyseLoss(double W, double t, double er, double rho, double D,
                   double tand, double ZlEff1, double ZlEff2, double ErEff,
                   double frequency, const string& Model, double& ac,
                   double& ad);
 
  // Helper functions for microstrip calculations
  void Hammerstad_ab(double u, double er, double& a, double& b);
 
  void Hammerstad_er(double u, double er, double a, double b, double& e);
 
  void Hammerstad_zl(double u, double& zl);
 
  void Kirschning_er(double u, double fn, double er, double ErEff, double& ErEffFreq);
 
  void Kirschning_zl(double ErEff, double ErEffFreq, double ZlEff, double& r17, double& ZlEffFreq);
 
 
  // Microstrip step
  void addMicrostripStepToAdmittance(vector<vector<Complex>>& Y,
                                     const Component_SPAR& comp);
  void calcMicrostripStepZ(double W1, double W2, double h, double er, double t,
                           double frequency, const string& SModel,
                           const string& DModel, Complex& z11, Complex& z12,
                           Complex& z21, Complex& z22);
 
  // Microstrip open
  void addMicrostripOpenToAdmittance(vector<vector<Complex>>& Y,
                                     const Component_SPAR& comp);
 
  Complex calcMicrostripOpenY(double W, double h, double er, double t,
                              double frequency, const string& Model,
                              const string& SModel, const string& DModel);
 
  double calcMicrostripOpenCend(double W, double h, double er, double t,
                                double frequency, const string& Model,
                                const string& SModel, const string& DModel);
 
  void addMicrostripViaToAdmittance(vector<vector<Complex>>& Y,
                                    const Component_SPAR& comp);
 
  Complex calcMicrostripViaImpedance(double D, double h, double t, double rho,
                                     double frequency);
 
  double calcMicrostripViaResistance(double D, double h, double t, double rho);
 
  void addMicrostripCoupledLinesToAdmittance(vector<vector<Complex>>& Y,
                                             const Component_SPAR& comp);
 
  void calcMicrostripCoupledPropagation(double W, double S, double h,
                                        double er, double t, double tand,
                                        double rho, double frequency,
                                        double& alpha_e, double& beta_e,
                                        double& zl_e, double& ereff_e,
                                        double& alpha_o, double& beta_o,
                                        double& zl_o, double& ereff_o);
 
  void analyseQuasiStaticCoupled(double W, double h, double s, double t,
                                 double er, const string& Model, double& Zle,
                                 double& Zlo, double& ErEffe, double& ErEffo);
 
  void analyseDispersionCoupled(double W, double h, double s, double t,
                                double er, double Zle, double Zlo,
                                double ErEffe, double ErEffo, double frequency,
                                const string& DModel, double& ZleFreq,
                                double& ZloFreq, double& ErEffeFreq,
                                double& ErEffoFreq);
 
  void analyseLossCoupled(double W, double t, double er, double rho,
                          double D, double tand, double ZlEff1, double ZlEff2,
                          double ErEff, double frequency, const string& Model,
                          bool evenMode, double& ac, double& ad);
 
  // Frequency sweep parameters
  double f_start = 1e6;   
  double f_stop = 1e9;    
  int n_points = 20;      
 
  // Simulation data
  std::vector<std::vector<std::vector<Complex>>> sweepResults; 
  QMap<QString, QList<double>> data; 
 
  double parseScaledValue(const QString& input,
                          QString unit_type = QString(""));
 
public:
  SParameterCalculator() : numNodes(0), frequency(1e9) {}
 
  bool setNetlist(const QString &netlist) {
    currentNetlist = netlist;
    return parseNetlist();
  }
 
  const QString& getNetlist() const { return currentNetlist; }
 
  void addComponent(ComponentType_SPAR type, const string& name,
                    const vector<int>& nodes, QMap<QString, double> value);
 
  void addComponent(ComponentType_SPAR type, const string& name,
                    const vector<int>& nodes, QMap<QString, Complex> Zvalue);
 
  void addComponent(ComponentType_SPAR type, const string& name,
                    const vector<int>& nodes,
                    QMap<QString, QList<double>> freqDepData);
 
  void addPort(int node, double impedance = 50.0);
 
  vector<vector<Complex>> calculateSParameters();
 
  // SPAR Block component
  vector<vector<Complex>> convertS2Y(const vector<vector<Complex>>& S,
                                     double Z0);
 
  void addSParamBlockToAdmittance(vector<vector<Complex>>& Y,
                                  const Component_SPAR& comp);
 
 
  void addSParameterBlock(const string& name, const vector<int>& nodes,
                          const vector<vector<Complex>>& Smatrix);
 
  void printSParameters(const vector<vector<Complex>>& S);
 
  void exportTouchstone(const QString& filename,
                        const vector<vector<Complex>>& S);
 
  void clear(){
    components.clear();
    ports.clear();
    numNodes = 0;
  }
 
  // Getter methods
  int getNumNodes() const { return numNodes; }
 
  size_t getNumComponents() const { return components.size(); }
 
  size_t getNumPorts() const { return ports.size(); }
 
  double getFrequency() const { return frequency; }
 
  QMap<QString, QList<double>> getData() { return data; }
 
  // Setter methods
  void setFrequency(double freq) { frequency = freq; }
 
  void setFrequencySweep(double start, double stop, int points);
 
  void calculateSParameterSweep();
 
  void printSParameterSweep() const;
 
  void exportSweepTouchstone(const QString& filename) const;
 
private:
  bool parseNetlist();
};
 
#endif // SPARAMETERCALCULATOR_H