Qucs-core  0.0.19
msline.cpp
Go to the documentation of this file.
00001 /*
00002  * msline.cpp - microstrip transmission line class implementation
00003  *
00004  * Copyright (C) 2004, 2005, 2006, 2008 Stefan Jahn <stefan@lkcc.org>
00005  *
00006  * This is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2, or (at your option)
00009  * any later version.
00010  *
00011  * This software is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this package; see the file COPYING.  If not, write to
00018  * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
00019  * Boston, MA 02110-1301, USA.
00020  *
00021  * $Id$
00022  *
00023  */
00024 
00025 #if HAVE_CONFIG_H
00026 # include <config.h>
00027 #endif
00028 
00029 #include "component.h"
00030 #include "substrate.h"
00031 #include "msline.h"
00032 
00033 using namespace qucs;
00034 
00035 msline::msline () : circuit (2) {
00036   alpha = beta = zl = ereff = 0;
00037   type = CIR_MSLINE;
00038 }
00039 
00040 void msline::calcNoiseSP (nr_double_t) {
00041   nr_double_t l = getPropertyDouble ("L");
00042   if (l < 0) return;
00043   // calculate noise using Bosma's theorem
00044   nr_double_t T = getPropertyDouble ("Temp");
00045   matrix s = getMatrixS ();
00046   matrix e = eye (getSize ());
00047   setMatrixN (celsius2kelvin (T) / T0 * (e - s * transpose (conj (s))));
00048 }
00049 
00050 void msline::calcPropagation (nr_double_t frequency) {
00051 
00052   /* how to get properties of this component, e.g. L, W */
00053   nr_double_t W = getPropertyDouble ("W");
00054   const char * SModel = getPropertyString ("Model");
00055   const char * DModel = getPropertyString ("DispModel");
00056 
00057   /* how to get properties of the substrate, e.g. Er, H */
00058   substrate * subst = getSubstrate ();
00059   nr_double_t er    = subst->getPropertyDouble ("er");
00060   nr_double_t h     = subst->getPropertyDouble ("h");
00061   nr_double_t t     = subst->getPropertyDouble ("t");
00062   nr_double_t tand  = subst->getPropertyDouble ("tand");
00063   nr_double_t rho   = subst->getPropertyDouble ("rho");
00064   nr_double_t D     = subst->getPropertyDouble ("D");
00065 
00066   /* local variables */
00067   nr_double_t ac, ad;
00068   nr_double_t ZlEff, ErEff, WEff, ZlEffFreq, ErEffFreq;
00069 
00070   // quasi-static effective dielectric constant of substrate + line and
00071   // the impedance of the microstrip line
00072   analyseQuasiStatic (W, h, t, er, SModel, ZlEff, ErEff, WEff);
00073 
00074   // analyse dispersion of Zl and Er (use WEff here?)
00075   analyseDispersion (W, h, er, ZlEff, ErEff, frequency, DModel,
00076                      ZlEffFreq, ErEffFreq);
00077 
00078   // analyse losses of line
00079   analyseLoss (W, t, er, rho, D, tand, ZlEff, ZlEff, ErEff,
00080                frequency, "Hammerstad", ac, ad);
00081 
00082   // calculate propagation constants and reference impedance
00083   zl    = ZlEffFreq;
00084   ereff = ErEffFreq;
00085   alpha = ac + ad;
00086   beta  = qucs::sqrt (ErEffFreq) * 2 * pi * frequency / C0;
00087 }
00088 
00089 void msline::calcSP (nr_double_t frequency) {
00090   nr_double_t l = getPropertyDouble ("L");
00091 
00092   // calculate propagation constants
00093   calcPropagation (frequency);
00094 
00095   // calculate S-parameters
00096   nr_double_t z = zl / z0;
00097   nr_double_t y = 1 / z;
00098   nr_complex_t g = nr_complex_t (alpha, beta);
00099   nr_complex_t n = 2.0 * cosh (g * l) + (z + y) * qucs::sinh (g * l);
00100   nr_complex_t s11 = (z - y) * qucs::sinh (g * l) / n;
00101   nr_complex_t s21 = 2.0 / n;
00102   setS (NODE_1, NODE_1, s11); setS (NODE_2, NODE_2, s11);
00103   setS (NODE_1, NODE_2, s21); setS (NODE_2, NODE_1, s21);
00104 }
00105 
00106 void msline::saveCharacteristics (nr_double_t) {
00107   setCharacteristic ("Zl", zl);
00108   setCharacteristic ("Er", ereff);
00109 }
00110 
00111 /* This function calculates the quasi-static impedance of a microstrip
00112    line, the value of the effective dielectric constant and the
00113    effective width due to the finite conductor thickness for the given
00114    microstrip line and substrate properties. */
00115 void msline::analyseQuasiStatic (nr_double_t W, nr_double_t h, nr_double_t t,
00116                                  nr_double_t er, const char * const Model,
00117                                  nr_double_t& ZlEff, nr_double_t& ErEff,
00118                                  nr_double_t& WEff) {
00119 
00120   nr_double_t z, e;
00121 
00122   // default values
00123   e = er;
00124   z = z0;
00125   WEff = W;
00126 
00127   // WHEELER
00128   if (!strcmp (Model, "Wheeler")) {
00129     nr_double_t a, b, c, d, x, dW1, dWr, Wr;
00130 
00131     // compute strip thickness effect
00132     if (t != 0) {
00133       dW1 = t / pi * qucs::log (4 * euler / qucs::sqrt (sqr (t / h) +
00134                                             sqr (one_over_pi / (W / t + 1.10))));
00135     }
00136     else dW1 = 0;
00137     dWr = (1 + 1 / er) / 2 * dW1;
00138     Wr  = WEff = W + dWr;
00139 
00140     // compute characteristic impedance
00141     if (W / h < 3.3) {
00142       c = qucs::log (4 * h / Wr + qucs::sqrt (sqr (4 * h / Wr) + 2));
00143       b = (er - 1) / (er + 1) / 2 * (qucs::log (pi_over_2) + qucs::log (2 * two_over_pi) / er);
00144       z = (c - b) * Z0 / pi / qucs::sqrt (2 * (er + 1));
00145     }
00146     else {
00147       c = 1 + qucs::log (pi_over_2) + qucs::log (Wr / h / 2 + 0.94);
00148       d = one_over_pi / 2 * (1 + qucs::log (sqr (pi) / 16)) * (er - 1) / sqr (er);
00149       x = 2 * ln2 / pi + Wr / h / 2 + (er + 1) / 2 / pi / er * c + d;
00150       z = Z0 / 2 / x / qucs::sqrt (er);
00151     }
00152 
00153     // compute effective dielectric constant
00154     if (W / h < 1.3) {
00155       a = qucs::log (8 * h / Wr) + sqr (Wr / h) / 32;
00156       b = (er - 1) / (er + 1) / 2 * (qucs::log (pi_over_2) + qucs::log (2 * two_over_pi) / er);
00157       e = (er + 1) / 2 * sqr (a / (a - b));
00158     }
00159     else {
00160       a = (er - 1) / 2 / pi / er * (qucs::log (2.1349 * Wr / h + 4.0137) -
00161                                       0.5169 / er);
00162       b = Wr / h / 2 + one_over_pi * qucs::log (8.5397 * Wr / h + 16.0547);
00163       e = er * sqr ((b - a) / b);
00164     }
00165   }
00166   // SCHNEIDER
00167   else if (!strcmp (Model, "Schneider")) {
00168 
00169     nr_double_t dW = 0, u = W / h;
00170 
00171     // consider strip thickness equations
00172     if (t != 0 && t < W / 2) {
00173       nr_double_t arg = (u < one_over_pi / 2) ? 2 * pi * W / t : h / t;
00174       dW = t / pi * (1 + qucs::log (2 * arg));
00175       if (t / dW >= 0.75) dW = 0;
00176     }
00177     WEff = W + dW; u = WEff / h;
00178 
00179     // effective dielectric constant
00180     e = (er + 1) / 2 + (er - 1) / 2 / qucs::sqrt (1 + 10 / u);
00181 
00182     // characteristic impedance
00183     if (u < 1.0) {
00184       z = one_over_pi / 2 * qucs::log (8 / u + u / 4);
00185     }
00186     else {
00187       z = 1 / (u + 2.42 - 0.44 / u + qucs::pow ((1. - 1. / u), 6.));
00188     }
00189     z = Z0 * z / qucs::sqrt (e);
00190   }
00191   // HAMMERSTAD and JENSEN
00192   else if (!strcmp (Model, "Hammerstad")) {
00193     nr_double_t a, b, du1, du, u, ur, u1, zr, z1;
00194 
00195     u = W / h; // normalized width
00196     t = t / h; // normalized thickness
00197 
00198     // compute strip thickness effect
00199     if (t != 0) {
00200       du1 = t / pi * qucs::log (1 + 4 * euler / t / sqr (coth (qucs::sqrt (6.517 * u))));
00201     }
00202     else du1 = 0;
00203     du = du1 * (1 + sech (qucs::sqrt (er - 1))) / 2;
00204     u1 = u + du1;
00205     ur = u + du;
00206     WEff = ur * h;
00207 
00208     // compute impedances for homogeneous medium
00209     Hammerstad_zl (ur, zr);
00210     Hammerstad_zl (u1, z1);
00211 
00212     // compute effective dielectric constant
00213     Hammerstad_ab (ur, er, a, b);
00214     Hammerstad_er (ur, er, a, b, e);
00215 
00216     // compute final characteristic impedance and dielectric constant
00217     // including strip thickness effects
00218     z = zr / qucs::sqrt (e);
00219     e = e * sqr (z1 / zr);
00220   }
00221 
00222   ZlEff = z;
00223   ErEff = e;
00224 }
00225 
00226 /* This function calculates the frequency dependent value of the
00227    effective dielectric constant and the microstrip line impedance for
00228    the given frequency. */
00229 void msline::analyseDispersion (nr_double_t W, nr_double_t h, nr_double_t er,
00230                                 nr_double_t ZlEff, nr_double_t ErEff,
00231                                 nr_double_t frequency, const char * const Model,
00232                                 nr_double_t& ZlEffFreq,
00233                                 nr_double_t& ErEffFreq) {
00234 
00235   nr_double_t e, z;
00236 
00237   // default values
00238   z = ZlEffFreq = ZlEff;
00239   e = ErEffFreq = ErEff;
00240 
00241   // GETSINGER
00242   if (!strcmp (Model, "Getsinger")) {
00243     Getsinger_disp (h, er, ErEff, ZlEff, frequency, e, z);
00244   }
00245   // SCHNEIDER
00246   else if (!strcmp (Model, "Schneider")) {
00247     nr_double_t k, f;
00248     k = qucs::sqrt (ErEff / er);
00249     f = 4 * h * frequency / C0 * qucs::sqrt (er - 1);
00250     f = sqr (f);
00251     e = ErEff * sqr ((1 + f) / (1 + k * f));
00252     z = ZlEff * qucs::sqrt (ErEff / e);
00253   }
00254   // YAMASHITA
00255   else if (!strcmp (Model, "Yamashita")) {
00256     nr_double_t k, f;
00257     k = qucs::sqrt (er / ErEff);
00258     f = 4 * h * frequency / C0 * qucs::sqrt (er - 1) *
00259       (0.5 + sqr (1 + 2 * qucs::log10 (1 + W / h)));
00260     e = ErEff * sqr ((1 + k * qucs::pow (f, 1.5) / 4) / (1 + qucs::pow (f, 1.5) / 4));
00261   }
00262   // KOBAYASHI
00263   else if (!strcmp (Model, "Kobayashi")) {
00264     nr_double_t n, no, nc, fh, fk;
00265     fk = C0 * qucs::atan (er * qucs::sqrt ((ErEff - 1) / (er - ErEff))) /
00266       (2 * pi * h * qucs::sqrt (er - ErEff));
00267     fh = fk / (0.75 + (0.75 - 0.332 / qucs::pow (er, 1.73)) * W / h);
00268     no = 1 + 1 / (1 + qucs::sqrt (W / h)) + 0.32 * cubic (1 / (1 + qucs::sqrt (W / h)));
00269     if (W / h < 0.7) {
00270       nc = 1 + 1.4 / (1 + W / h) * (0.15 - 0.235 *
00271                                     qucs::exp (-0.45 * frequency / fh));
00272     }
00273     else nc = 1;
00274     n = no * nc < 2.32 ? no * nc : 2.32;
00275     e = er - (er - ErEff) / (1 + qucs::pow (frequency / fh, n));
00276   }
00277   // PRAMANICK and BHARTIA
00278   else if (!strcmp (Model, "Pramanick")) {
00279     nr_double_t Weff, We, f;
00280     f = 2 * MU0 * h * frequency * qucs::sqrt (ErEff / er) / ZlEff;
00281     e = er - (er - ErEff) / (1 + sqr (f));
00282     Weff = Z0 * h / ZlEff / qucs::sqrt (ErEff);
00283     We = W + (Weff - W) / (1 + sqr (f));
00284     z = Z0 * h / We / qucs::sqrt (e);
00285   }
00286   // HAMMERSTAD and JENSEN
00287   else if (!strcmp (Model, "Hammerstad")) {
00288     nr_double_t f, g;
00289     g = sqr (pi) / 12 * (er - 1) / ErEff * qucs::sqrt (2 * pi * ZlEff / Z0);
00290     f = 2 * MU0 * h * frequency / ZlEff;
00291     e = er - (er - ErEff) / (1 + g * sqr (f));
00292     z = ZlEff * qucs::sqrt (ErEff / e) * (e - 1) / (ErEff - 1);
00293   }
00294   // KIRSCHNING and JANSEN
00295   else if (!strcmp (Model, "Kirschning")) {
00296     nr_double_t r17, u  = W / h, fn = frequency * h / 1e6;
00297 
00298     // dispersion of dielectric constant
00299     Kirschning_er (u, fn, er, ErEff, e);
00300 
00301     // dispersion of characteristic impedance
00302     Kirschning_zl (u, fn, er, ErEff, e, ZlEff, r17, z);
00303   }
00304 
00305   ZlEffFreq = z;
00306   ErEffFreq = e;
00307 }
00308 
00309 /* Computes the exponent factors a(u) and b(er) used within the
00310    effective relative dielectric constant calculations for single and
00311    coupled microstrip lines by Hammerstad and Jensen. */
00312 void msline::Hammerstad_ab (nr_double_t u, nr_double_t er, nr_double_t& a,
00313                             nr_double_t& b) {
00314   a = 1 + qucs::log ((quadr (u) + sqr (u / 52)) / (quadr (u) + 0.432)) / 49 +
00315     qucs::log (1 + cubic (u / 18.1)) / 18.7;
00316   b = 0.564 * qucs::pow ((er - 0.9) / (er + 3), 0.053);
00317 }
00318 
00319 /* The function computes the effective dielectric constant of a single
00320    microstrip.  The equation is used in single and coupled microstrip
00321    calculations. */
00322 void msline::Hammerstad_er (nr_double_t u, nr_double_t er, nr_double_t a,
00323                             nr_double_t b, nr_double_t& e) {
00324   e = (er + 1) / 2 + (er - 1) / 2 * qucs::pow (1 + 10 / u, -a * b);
00325 }
00326 
00327 /* This function computes the characteristic impedance of single
00328    microstrip line based upon the given width-height ratio.  The
00329    equation is used in single and coupled microstrip calculations as
00330    well. */
00331 void msline::Hammerstad_zl (nr_double_t u, nr_double_t& zl) {
00332   nr_double_t fu = 6 + (2 * pi - 6) * qucs::exp (- qucs::pow (30.666 / u, 0.7528));
00333   zl = Z0 / 2 / pi * qucs::log (fu / u + qucs::sqrt (1 + sqr (2 / u)));
00334 }
00335 
00336 /* Calculates dispersion effects for effective dielectric constant and
00337    characteristic impedance as defined by Getsinger (for single and
00338    coupled microstrips). */
00339 void msline::Getsinger_disp (nr_double_t h, nr_double_t er, nr_double_t ErEff,
00340                              nr_double_t ZlEff, nr_double_t frequency,
00341                              nr_double_t& e, nr_double_t& z) {
00342   nr_double_t g, f, d;
00343   g = 0.6 + 0.009 * ZlEff;
00344   f = frequency * 2 * MU0 * h / ZlEff;
00345   e = er - (er - ErEff) / (1 + g * sqr (f));
00346   d = (er - e) * (e - ErEff) / e / (er - ErEff);
00347   z = ZlEff * qucs::sqrt (e / ErEff) / (1 + d);  // group delay model
00348 }
00349 
00350 /* This function computes the dispersion of the effective dielectric
00351    constant of a single microstrip line.  It is defined in a separate
00352    function because it is used within the coupled microstrip lines as
00353    well. */
00354 void msline::Kirschning_er (nr_double_t u, nr_double_t fn, nr_double_t er,
00355                             nr_double_t ErEff, nr_double_t& ErEffFreq) {
00356   nr_double_t p, p1, p2, p3, p4;
00357   p1 = 0.27488 + (0.6315 + 0.525 / qucs::pow (1. + 0.0157 * fn, 20.)) * u -
00358     0.065683 * qucs::exp (-8.7513 * u);
00359   p2 = 0.33622 * (1 - qucs::exp (-0.03442 * er));
00360   p3 = 0.0363 * qucs::exp (-4.6 * u) * (1 - qucs::exp (- qucs::pow (fn / 38.7, 4.97)));
00361   p4 = 1 + 2.751 * (1 - qucs::exp (- qucs::pow (er / 15.916, 8.)));
00362   p  = p1 * p2 * qucs::pow ((0.1844 + p3 * p4) * fn, 1.5763);
00363   ErEffFreq  = er - (er - ErEff) / (1 + p);
00364 }
00365 
00366 /* Computes dispersion effects of characteristic impedance of a single
00367    microstrip line according to Kirschning and Jansen.  Also used in
00368    coupled microstrip lines calculations. */
00369 void msline::Kirschning_zl (nr_double_t u, nr_double_t fn, nr_double_t er,
00370                             nr_double_t ErEff, nr_double_t ErEffFreq,
00371                             nr_double_t ZlEff, nr_double_t& r17,
00372                             nr_double_t& ZlEffFreq) {
00373   nr_double_t r1, r2, r3, r4, r5, r6, r7, r8, r9, r10;
00374   nr_double_t r11, r12, r13, r14, r15, r16;
00375   r1 = 0.03891 * qucs::pow (er, 1.4);
00376   r2 = 0.267 * qucs::pow (u, 7.);
00377   r3 = 4.766 * qucs::exp (-3.228 * qucs::pow (u, 0.641));
00378   r4 = 0.016 + qucs::pow (0.0514 * er, 4.524);
00379   r5 = qucs::pow (fn / 28.843, 12.);
00380   r6 = 22.20 * qucs::pow (u, 1.92);
00381   r7 = 1.206 - 0.3144 * qucs::exp (-r1) * (1 - qucs::exp (-r2));
00382   r8 = 1 + 1.275 * (1 - qucs::exp (-0.004625 * r3 *
00383                              qucs::pow (er, 1.674) * qucs::pow (fn / 18.365, 2.745)));
00384   r9 = 5.086 * r4 * r5 / (0.3838 + 0.386 * r4) *
00385     qucs::exp (-r6) / (1 + 1.2992 * r5) *
00386     qucs::pow (er - 1., 6.) / (1 + 10 * qucs::pow (er - 1., 6.));
00387   r10 = 0.00044 * qucs::pow (er, 2.136) + 0.0184;
00388   r11 = qucs::pow (fn / 19.47, 6.) / (1 + 0.0962 * qucs::pow (fn / 19.47, 6.));
00389   r12 = 1 / (1 + 0.00245 * sqr (u));
00390   r13 = 0.9408 * qucs::pow (ErEffFreq, r8) - 0.9603;
00391   r14 = (0.9408 - r9) * qucs::pow (ErEff, r8) - 0.9603;
00392   r15 = 0.707 * r10 * qucs::pow (fn / 12.3, 1.097);
00393   r16 = 1 + 0.0503 * sqr (er) * r11 * (1 - qucs::exp (- qucs::pow (u / 15., 6.)));
00394   r17 = r7 * (1 - 1.1241 * r12 / r16 *
00395               qucs::exp (-0.026 * qucs::pow (fn, 1.15656) - r15));
00396   ZlEffFreq = ZlEff * qucs::pow (r13 / r14, r17);
00397 }
00398 
00399 /* The function calculates the conductor and dielectric losses of a
00400    single microstrip line. */
00401 void msline::analyseLoss (nr_double_t W, nr_double_t t, nr_double_t er,
00402                           nr_double_t rho, nr_double_t D, nr_double_t tand,
00403                           nr_double_t ZlEff1, nr_double_t ZlEff2,
00404                           nr_double_t ErEff,
00405                           nr_double_t frequency, const char * Model,
00406                           nr_double_t& ac, nr_double_t& ad) {
00407   ac = ad = 0;
00408 
00409   // HAMMERSTAD and JENSEN
00410   if (!strcmp (Model, "Hammerstad")) {
00411     nr_double_t Rs, ds, l0, Kr, Ki;
00412 
00413     // conductor losses
00414     if (t != 0.0) {
00415       Rs = qucs::sqrt (pi * frequency * MU0 * rho); // skin resistance
00416       ds = rho / Rs;                            // skin depth
00417       // valid for t > 3 * ds
00418       if (t < 3 * ds) {
00419         logprint (LOG_ERROR,
00420                   "WARNING: conductor loss calculation invalid for line "
00421                   "height t (%g) < 3 * skin depth (%g)\n", t, 3 * ds);
00422       }
00423       // current distribution factor
00424       Ki = qucs::exp (-1.2 * qucs::pow ((ZlEff1 + ZlEff2) / 2 / Z0, 0.7));
00425       // D is RMS surface roughness
00426       Kr = 1 + two_over_pi * qucs::atan (1.4 * sqr (D / ds));
00427       ac = Rs / (ZlEff1 * W) * Ki * Kr;
00428     }
00429 
00430     // dielectric losses
00431     l0 = C0 / frequency;
00432     ad = pi * er / (er - 1) * (ErEff - 1) / qucs::sqrt (ErEff) * tand / l0;
00433   }
00434 }
00435 
00436 void msline::initDC (void) {
00437   nr_double_t l     = getPropertyDouble ("L");
00438   nr_double_t W     = getPropertyDouble ("W");
00439   substrate * subst = getSubstrate ();
00440   nr_double_t t     = subst->getPropertyDouble ("t");
00441   nr_double_t rho   = subst->getPropertyDouble ("rho");
00442 
00443   if (t != 0.0 && rho != 0.0 && l != 0.0) {
00444     // tiny resistance
00445     nr_double_t g = t * W / rho / l;
00446     setVoltageSources (0);
00447     allocMatrixMNA ();
00448     setY (NODE_1, NODE_1, +g); setY (NODE_2, NODE_2, +g);
00449     setY (NODE_1, NODE_2, -g); setY (NODE_2, NODE_1, -g);
00450   }
00451   else {
00452     // a DC short (voltage source V = 0 volts)
00453     setVoltageSources (1);
00454     setInternalVoltageSource (1);
00455     allocMatrixMNA ();
00456     clearY ();
00457     voltageSource (VSRC_1, NODE_1, NODE_2);
00458   }
00459 }
00460 
00461 void msline::initAC (void) {
00462   setVoltageSources (0);
00463   allocMatrixMNA ();
00464 }
00465 
00466 void msline::calcAC (nr_double_t frequency) {
00467   nr_double_t l = getPropertyDouble ("L");
00468 
00469   // calculate propagation constants
00470   calcPropagation (frequency);
00471 
00472   // calculate Y-parameters
00473   nr_complex_t g = nr_complex_t (alpha, beta);
00474   nr_complex_t y11 = coth (g * l) / zl;
00475   nr_complex_t y21 = -cosech (g * l) / zl;
00476   setY (NODE_1, NODE_1, y11); setY (NODE_2, NODE_2, y11);
00477   setY (NODE_1, NODE_2, y21); setY (NODE_2, NODE_1, y21);
00478 }
00479 
00480 void msline::calcNoiseAC (nr_double_t) {
00481   nr_double_t l = getPropertyDouble ("L");
00482   if (l < 0) return;
00483   // calculate noise using Bosma's theorem
00484   nr_double_t T = getPropertyDouble ("Temp");
00485   setMatrixN (4 * celsius2kelvin (T) / T0 * real (getMatrixY ()));
00486 }
00487 
00488 // properties
00489 PROP_REQ [] = {
00490   { "W", PROP_REAL, { 1e-3, PROP_NO_STR }, PROP_POS_RANGE },
00491   { "L", PROP_REAL, { 10e-3, PROP_NO_STR }, PROP_POS_RANGE },
00492   { "Subst", PROP_STR, { PROP_NO_VAL, "Subst1" }, PROP_NO_RANGE },
00493   { "DispModel", PROP_STR, { PROP_NO_VAL, "Kirschning" }, PROP_RNG_DIS },
00494   { "Model", PROP_STR, { PROP_NO_VAL, "Hammerstad" }, PROP_RNG_MOD },
00495   PROP_NO_PROP };
00496 PROP_OPT [] = {
00497   { "Temp", PROP_REAL, { 26.85, PROP_NO_STR }, PROP_MIN_VAL (K) },
00498   PROP_NO_PROP };
00499 struct define_t msline::cirdef =
00500   { "MLIN", 2, PROP_COMPONENT, PROP_NO_SUBSTRATE, PROP_LINEAR, PROP_DEF };