structures.h

/*
 *  Copyright (C) 2019-2025 Andrés Martínez Mera - andresmmera@protonmail.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef STRUCTURES_H
#define STRUCTURES_H
 
#include <QString>
#include <QStringList>
#include <QMap>
#include <array>
#include <complex.h>
#include <complex>
#include <deque>
#include <vector>
 
enum ComponentType {
  Capacitor,
  Inductor,
  Term,
  GND,
  ConnectionNodes,
  Resistor,
  TransmissionLine,
  MicrostripLine,
  MicrostripStep,
  MicrostripOpen,
  MicrostripVia,
  MicrostripCoupledLines,
  OpenStub,
  ShortStub,
  CoupledLines,
  Coupler,
  ComplexImpedance,
  SPAR_Block
};
 
inline QString ComponentTypeToString(ComponentType type){
  static const QMap<ComponentType, QString> names = {
                                                     {Capacitor, "Capacitor"},
                                                     {Inductor, "Inductor"},
                                                     {Term, "Term"},
                                                     {GND, "GND"},
                                                     {ConnectionNodes, "ConnectionNodes"},
                                                     {Resistor, "Resistor"},
                                                     {TransmissionLine, "TransmissionLine"},
                                                     {MicrostripLine, "MicrostripLine"},
                                                     {MicrostripStep, "MicrostripStep"},
                                                     {MicrostripOpen, "MicrostripOpen"},
                                                     {MicrostripVia, "MicrostripVia"},
                                                     {MicrostripCoupledLines, "MicrostripCoupledLines"},
                                                     {OpenStub, "OpenStub"},
                                                     {ShortStub, "ShortStub"},
                                                     {CoupledLines, "CoupledLines"},
                                                     {Coupler, "Coupler"},
                                                     {ComplexImpedance, "ComplexImpedance"},
                                                     {SPAR_Block, "SPAR_Block"}};
 
  return names.value(type, "Unknown");
}
 
enum ResponseType {
  Butterworth,
  Chebyshev,
  Legendre,
  Gaussian,
  Elliptic,
  Blichinkoff,
  Bessel,
  LinearPhaseEqError,
  Gegenbauer
};
 
enum FilterClass { Lowpass, Highpass, Bandpass, Bandstop };
 
enum Coupling {
  CapacitiveCoupledShuntResonators,
  InductiveCoupledShuntResonators,
  CapacitiveCoupledSeriesResonators,
  InductiveCoupledSeriesResonators,
  QWCoupledShuntResonators
};
 
enum SemiLumpedImplementation { ONLY_INDUCTORS, INDUCTORS_AND_SHUNT_CAPS };
 
 
enum TransmissionLineType {
  Ideal,
  MLIN, // Microstrip
  SLIN,  // Stripline
  Lumped
};
 
static const double SPEED_OF_LIGHT = 299792458.0;
 
struct PrototypeTableProperties {
  QString ID;                    
  std::vector<int> N;            
  std::vector<double> Ripple;    
  std::vector<double> RL;        
};
 
struct MS_Substrate {
  double height;             
  double er;                 
  double tand;               
  double MetalConductivity;  
  double MetalThickness;     
 
  MS_Substrate(double h = 0.508e-3, double epsilon_r = 3.55,
               double tand = 0.0027, double MetalConductivity = 58e6,
               double MetalThickness = 32e-6)
      : height(h), er(epsilon_r), tand(tand),
        MetalConductivity(MetalConductivity), MetalThickness(MetalThickness) {}
};
 
 
 
inline bool operator==(const MS_Substrate& a, const MS_Substrate& b) {
  return a.height == b.height &&
         a.er == b.er &&
         a.tand == b.tand &&
         a.MetalConductivity == b.MetalConductivity &&
         a.MetalThickness == b.MetalThickness;
}
 
 
inline QList<MS_Substrate> removeDuplicates(const QList<MS_Substrate>& list) {
  QList<MS_Substrate> uniqueList;
  for (const auto& item : list) {
    if (!uniqueList.contains(item)) {
      uniqueList.append(item);
    }
  }
  return uniqueList;
}
 
 
struct FilterSpecifications {
  FilterClass FilterType;                        
  ResponseType FilterResponse;                   
  QString Implementation;                        
  TransmissionLineType TL_implementation;        
  Coupling DC_Coupling;                          
  bool isCLC;                                    
  unsigned int order;                            
  double Ripple = 0.05;                          
  double fc;                                     
  double bw;                                     
  double ZS;                                     
  double ZL;                                     
  double as;                                     
  QString EllipticType;                          
  bool UseZverevTables;                          
  double minZ;                                   
  double maxZ;                                   
  SemiLumpedImplementation SemiLumpedISettings;  
  double ImpedanceRatio;                         
  MS_Substrate MS_Subs;                          
  ComponentType tunableComponent_DC_Filters;     
  std::vector<double> resonatorValues;           
};
 
struct MatchingNetworkDesignParameters {
  double Z0;                              
  int Topology;                           
  TransmissionLineType TL_implementation; 
  int Solution;                           
  int OpenShort;                          
  int NSections;                          
  QString Weigthing;                      
  double gamma_MAX;                       
  double ZL_freq;                         
  std::complex<double> ZL;                
  QList<double> freq;                     
  QList<std::complex<double>> ZL_data;    
  QString sim_path;                       
  MS_Substrate MS_Subs;                   
};
 
struct MatchingData {
  MatchingNetworkDesignParameters InputNetworkParameters;   
  MatchingNetworkDesignParameters OutputNetworkParameters;  
  std::array<std::complex<double>, 4> sparams;              
  bool twoPortMode;                                         
  double f_match;                                           
};
 
struct NetworkInfo {
  std::vector<std::complex<double>> ZS;  
  std::vector<std::complex<double>> ZL;  
  QStringList topology;                  
  QList<struct ComponentInfo> Ladder;    
};
 
struct PowerCombinerParams {
  QString Type;                           
  TransmissionLineType TL_implementation; 
  int Noutputs;                           
  int Nstages;                            
  std::deque<double> OutputRatio;         
  double alpha;                           
  QString units;                          
  double freq;                            
  double Z0;                              
  MS_Substrate MS_Subs;                   
};
 
struct AttenuatorDesignParameters {
  QString Topology;                       
  TransmissionLineType TL_implementation; 
  double Zin;                             
  double Zout;                            
  double Attenuation;                     
  double Frequency;                       
  double Pin;                             
  MS_Substrate MS_Subs;                   
};
 
#endif // STRUCTURES_H