---

trlines.cc

Go to the documentation of this file.

// trlines.cc
// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.
//
// Change history:
// 5/31/00:  fixed wrong sign in r_waveguide lossy dielectric calculation
// 5/30/00:  changed zchar to zwave in r_waveguide calculations
// 4/7/00:   changed trl_base::calc() for length == 0.0; some mods to
//           microstrip code to improve readability and efficiency.
// 11/16/99: made wavelength() and percent_loss() part of trl_base()
// 11/16/99: changes to support new noise calculations
// 9/29/99:  added conducting backing to cpw code (lossless calculations)
// 8/23/99:  added cpw code (only lossless calculations!)
// 3/22/99:  changed VERYBIG to MSTRIP_H_VERYBIG, 
//           VERYSMALL to MSTRIP_H_VERYSMALL
// 11/11/98: Changed table access to new syntax
// 9/17/98:  changed trl to trl_base; sped up member fcns
// 9/16/98:  changed the names of some members
// 2/10/98:  modified by JZ
//          - added Temp (temperature) parameter to class microstrip 
//            This allows the temperature of a microstrip section to be
//            arbitrary, not necessarily the same as device::T
//          - introduced utility functions wavelength(), percent_loss()
//            to calculate these quantities from the complex propagation
//            constant.
// 12/29/97: modified by FR for new sdata (with znorm)
// 12/19/97: modified by FR for matmath classes
//
#include <math.h>
#include "global.h"
#include "units.h"
#include "SIScmplx.h"
#include "surfaceZ.h"
#include "parameter.h"
#include "nport.h"
#include "mstrip.h"
#include "error.h"
#include "trlines.h"


// ************************************************************************
//
// class trl_base
//
// ************************************************************************

// calc calculates the scattering matrix
void trl_base::calc(complex b, complex z, double length, double znorm)
{
  // Note: propagation factor is taken to be exp(-b*length)
  // so b.real > 0 ensures attenuation of wave
  //
  // the form of the scattering matrix elements used requires only one
  // complex exponential evaluation:
  //
  //       (z*z - 1)*(1 - exp(-k)*exp(-k))           4*z*exp(-k)
  // s11 = -------------------------------  ;  s12 = -----------
  //                 denom                              denom
  //
  // denom = (z+1)*(z+1) - (z-1)*(z-1)*exp(-k)*exp(-k)
  //
  // k = b*length;    z = z/znorm
  //
  // NOTE: if length == 0.0, then s11 = 0 and s12 = 1 will be returned

  complex s11(0.0), s12(1.0);   // the values if length == 0

  if(length != 0.0) {
    z /= znorm ;                // normalize to standard impedance
    b *= -length; b = exp(b);   // now b = exp(-k)
    s12 = 4*z*b;                //   s12 = 4*z*exp(-k)
    b *= b;                     // now b = exp(-2*k)
    s11 = z + 1;                // use s11 as a temporary for now
    z -= 1;
    complex denom = s11*s11 - z*z*b;
    s12 /= denom;
    s11 *= z*(1-b)/denom;
  }

  // fill in S matrix
  data.set_znorm(znorm);        // added 12/29/97
  data.S[1][1] = s11;
  data.S[2][2] = s11;
  data.S[1][2] = s12;
  data.S[2][1] = s12;
}

double trl_base::wavelength(complex prop_constant)
{
   return(2.*Pi/imag(prop_constant)) ;
}

double trl_base::percent_loss(complex prop_constant)
{
   double alpha = real(prop_constant) ;
   double wvlen = wavelength(prop_constant) ;
   return( 100.*(1.-exp(-2.*alpha*wvlen)) ) ;
}

// ************************************************************************
//
// class microstrip:
//
// ************************************************************************

// Default constructor
microstrip::microstrip()
  : trl_base(), length(0.), width(0.), sub_thick(0.), Temp(&device::T),
    sub(0), super(0), top(0), ground(0)
{ }

void microstrip::update(double freq, double T)
{
   // Make sure we have valid pointers
   if(sub == 0)
     error::fatal("Substrate dielectric not defined for microstrip line !");
   if(super == 0)
     error::fatal("Superstrate dielectric not defined for microstrip line !");
   if(ground == 0)
     error::fatal("Ground plane film not defined for microstrip line !");
   if(top == 0)
     error::fatal("Top strip film not defined for microstrip line !");
   if(length.get() < 0.)
     error::fatal("Microstrip length is negative !") ;
   if(width.get() <= 0.)
     error::fatal("Microstrip width is zero or negative !") ;
   if(sub_thick.get() <= 0.)
     error::fatal("Microstrip substrate thickness is zero or negative !") ;

   // Set up parameters for calling mstrip

   double h = sub_thick.get() ;
   double w = width.get() ;
   double t1 = top->thickness() ;
   double t2 = ground->thickness() ;

   complex esubc = sub->epsilon(freq, T) ;
   double  esub = real(esubc) ;
   double  tdsub = fabs(tan(arg(esubc))) ;

   complex eupc = super->epsilon(freq, T) ;
   double  eup = real(eupc) ;
   double  tdup = fabs(tan(arg(eupc))) ;

   double  Qsub;
   if(tdsub < MSTRIP_H_VERYSMALL)   // These constants are defined in mstrip.h
      Qsub = MSTRIP_H_VERYBIG;
   else
      Qsub = 1./tdsub;   

   double  Qup;
   if(tdup < MSTRIP_H_VERYSMALL)
      Qup = MSTRIP_H_VERYBIG;
   else
      Qup = 1./tdup;   

   // create variables to hold the return values

   double Zms, epeff, tandel, g2 ;

   // call mstrip()

   mstrip(h, w, t1, t2, esub, eup, Qsub, Qup, freq, 
          Zms, epeff, tandel, g2) ;

   // Convert to equivalent series and shunt elements
   //
   double wavelen = cLight/(freq*sqrt(epeff)) ;
   double kimag = fabs(2.*Pi/wavelen) ;  // make sure we know signs
   double kreal = kimag*fabs(tandel) ;
   zchar = fabs(Zms) ;                   // uncorrected characteristic Z
   if(kreal < MSTRIP_H_VERYSMALL*kimag)
      kreal = MSTRIP_H_VERYSMALL*kimag ; // always keep tiny amount of loss 

   // Propagation factor is defined as exp(-beta*length)
   // This is consistent with exp(+j omega t) time dependence
   //
   beta = complex(kreal, kimag) ;       // uncorrected propagation const
   Zs = beta*zchar ;                    // guaranteed that Re(Zs) > 0
   Yp = beta/zchar ;                    // guaranteed that Re(Yp) > 0


   // Calculate corrections due to superconductor
   // Assume the same current distribution in ground plane and top strip
   //
   complex Ztop = top->Zsurf(freq, T) ;
   complex Zground = Ztop ;
   if(ground != top)                        // metal layers are different
     Zground = ground->Zsurf(freq, T) ;     // so do need to calculate
   complex Zsurf = 0.5*(Ztop+Zground) ;
   Zs += g2*Zsurf;           // corrected series impedance per length

   // Note: Re(Zsurf) > 0 should be true since metal films are passive
   // This implies Re(Zs) > 0 still true
   // So corrected propagation constant and characteristic impedance
   // should still satisfy Re(beta) > 0 and Re(zchar) > 0

   beta = sqrt(Zs*Yp) ;
   if(real(beta) < 0.)
     beta *= -1. ;   // choose other branch to make wave attenuate

   zchar = sqrt(Zs/Yp) ;
   if(real(zchar) < 0.)
     zchar *= -1. ;   // choose other branch
}


// ************************************************************************
//
// class cpw
//
// ************************************************************************

double cpw::cefr(double k)
{
  double power = 1;

  if(k < 0.7071067812)
  {
    k = sqrt(1 - k*k);
    power = -1;
  }

  double sqrt_k = sqrt(k);
  double rtval = log(2. * (1.+sqrt_k) / (1 - sqrt_k)) / Pi;     // Natural log.

  if (power == 1) return rtval;

  return 1.0 / rtval;
}


// constructor
cpw::cpw()
  : trl_base(), length(0.), width(0.), space(0.), sub_thick(0.), Temp(&device::T),
    sub(0), top(0), bottom(0)
{ }

void cpw::update(double freq, double /* T */ )  // lossless, so T isn't needed yet
{
  // Make sure we have valid pointers
   if(sub == 0)
     error::fatal("Substrate dielectric not defined for cpw line !");
   if(top == 0)
     error::fatal("Top strip film not defined for cpw line !");
   if(length.get() < 0.)
     error::fatal("cpw length is negative !") ;
   if(width.get() <= 0.)
     error::fatal("cpw width is zero or negative !") ;
   if(space.get() <= 0.)
     error::fatal("cpw space is zero or negative !") ;
   if(sub_thick.get() <= 0.)
     error::fatal("cpw substrate thickness is zero or negative !") ;

  // The following variables are used to make the math simpler.
  // See "Microwave Solid State Circuit Design" by Bahl and Bhartia, page 24.
  double a, b, k, k1;

  a = width /2.;
  b = space + a;
  k = a / b;

  double epsilon_effective;

  if(bottom == 0)  // No ground plane under substrate
  {
    k1 = sinh(0.5 * Pi * a / sub_thick) / sinh(0.5 * Pi * b / sub_thick);

    epsilon_effective = 1. + (0.5 * (sub->epsilon(freq, Temp).real - 1.)
                * cefr(k1) / cefr(k));
    zchar = 30. * Pi / (sqrt(epsilon_effective) * cefr(k));
  }
  else  // There is a ground plane under substrate
  {
    k1 = tanh(0.5 * Pi * a / sub_thick) / tanh(0.5 * Pi * b / sub_thick);

    epsilon_effective = (1. + sub->epsilon(freq, Temp).real * cefr(k1)/cefr(k))
                    / (1. + cefr(k1) / cefr(k));

    zchar = 60. * Pi / (sqrt(epsilon_effective) * (cefr(k) + cefr(k1)));
  }

  //
  // Convert to equivalent series and shunt elements
  //
  double wavelen = cLight/(freq*sqrt(epsilon_effective)) ;
  double kimag = fabs(2.*Pi/wavelen) ;  // make sure we know signs

  beta = complex(0., kimag);   // lossless
  Zs = beta*zchar ;            // guaranteed that Re(Zs) > 0
  Yp = beta/zchar ;            // guaranteed that Re(Yp) > 0

/* This is the lossy microstrip code... needs to be checked for cpw
// WHAT IS ALPHA?  (attenuation factor)
// WHAT IS g2?  (geometrical factor for loss calculations)

   double kreal = fabs(alpha);

   if(kreal < MSTRIP_H_VERYSMALL*kimag)
      kreal = MSTRIP_H_VERYSMALL*kimag ; // always keep tiny amount of loss
   // 
   // Propagation factor is defined as exp(-beta*length)
   // This is consistent with exp(+j omega t) time dependence
   //
   beta = complex(kreal, kimag) ;       // uncorrected propagation const
   Zs = beta*zchar ;                    // guaranteed that Re(Zs) > 0
   Yp = beta/zchar ;                    // guaranteed that Re(Yp) > 0

   //
   // Calculate corrections due to superconductor

   complex Zsurf = top->Zsurf(freq, T) ;
   Zs += g2*Zsurf;           // corrected series impedance per length

   // Note: Re(Zsurf) > 0 should be true since metal films are passive
   // This implies Re(Zs) > 0 still true
   // So corrected propagation constant and characteristic impedance
   // should still satisfy Re(beta) > 0 and Re(zchar) > 0

   beta = sqrt(Zs*Yp) ;
   if(real(beta) < 0.)
     beta *= -1. ;   // choose other branch to make wave attenuate

   zchar = sqrt(Zs/Yp) ;
   if(real(zchar) < 0.)
     zchar *= -1. ;   // choose other branch
*/
}

// ************************************************************************
//
// class r_waveguide
//
// ************************************************************************

void r_waveguide::update(double freq, double T)
{
  // Make sure we have valid parameters
  if(length.get() < 0.)
    error::fatal("r_waveguide length is negative !") ;
  if(a.get() <= 0.)
    error::fatal("r_waveguide \"a\" dimension is zero or negative !") ;
  if(b.get() <= 0.)
    error::fatal("r_waveguide \"b\" dimension is zero or negative !") ;

  // the material characteristics:
  complex eps   = (fill_) ? fill_->epsilon(freq,T) : 1.0;    // vacuum is default
  double  Rs    = (wall_) ? wall_->Zsurf(freq,T).real : 0.0; // perfect is default
  double  n     = sqrt(eps.real);                            // index of refraction
  
  // wave propagation characteristics:
  double  Zfree = ZVacuum/n;                // dielectric wave impedance
  double  k   = 2*Pi*freq*n/cLight;         // dielectric wave number
  double  kc  = Pi/a;                       // cutoff wave number
  bool imaginary_beta = (k <= kc);          // are we at or below cutoff?
  double beta = (imaginary_beta) ?          // wavenumber in guide
    sqrt(kc*kc - k*k) : sqrt(k*k - kc*kc);  // gamma = alpha + I*beta

  // handle above cutoff case first:
  if(!imaginary_beta) {
    // these loss calculations are only accurate if small compared to beta
    double alpha_c = (wall_) ?
      Rs*(2*b*Pi*Pi/(a*a*a) + k*k)/(b*k*Zfree*beta) : 0.0;
    double alpha_d = (fill_) ?
      -k*k*eps.imaginary/(2*eps.real*beta) : 0.0; // eps.imaginary <= 0

    gamma = complex(alpha_c+alpha_d, beta);
    zwave = (k*Zfree/beta)*complex(1.0, (alpha_d - alpha_c*k/beta)/beta);
  }
  else {
    // don't include loss calulations below cutoff; too hard to figure out
    gamma = beta;
    zwave = complex(0.0, -k*Zfree/beta);
  }
}

double r_waveguide::fc(double freq, double T)
{
  if ( a <= 0.0)
    error::fatal("r_waveguide \"a\" dimension is zero or negative !");

  double f = cLight/(2.0*a);
  if(fill_) f /= sqrt((fill_->epsilon(f,T)).real);
  return f;
}

const nport::data_info & r_waveguide::get_data_info()
{
  info.noise  = (fill_ || wall_); // a real material gives noise
  info.active = (info.noise && Temp != device::T);
  return info;
}

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7