Xyce  6.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
N_DEV_DeviceOptions.C
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-2014 Sandia Corporation
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //-----------------------------------------------------------------------------
24 
25 //-----------------------------------------------------------------------------
26 // Filename : $RCSfile: N_DEV_DeviceOptions.C,v $
27 //
28 // Purpose :
29 //
30 // Special Notes :
31 //
32 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
33 //
34 // Creation Date : 07/06/01
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.90 $
40 //
41 // Revision Date : $Date: 2014/02/24 23:49:15 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-----------------------------------------------------------------------------
45 
46 #include <Xyce_config.h>
47 
48 #include <iostream>
49 
50 #ifdef HAVE_CLIMITS
51 #include <climits>
52 #else
53 #include <limits.h>
54 #endif
55 
56 
57 #include <N_DEV_Const.h>
58 #include <N_DEV_DeviceOptions.h>
59 #include <N_ERH_ErrorMgr.h>
60 #include <N_IO_CmdParse.h>
61 #include <N_UTL_Misc.h>
62 #include <N_UTL_OptionBlock.h>
63 
64 namespace Xyce {
65 namespace Device {
66 
67 //-----------------------------------------------------------------------------
68 // Function : DeviceOptions::DeviceOptions
69 // Purpose : constructor
70 //
71 // Special Notes : The are initialized to default values, but are reset
72 // in the setupDefaultOptions function. Confusing I know,
73 // but I had a reason for doing this, I think.
74 //
75 // Consider setupDefaultOptions function to be the
76 // ultimate authority.
77 //
78 // Scope : public
79 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
80 // Creation Date : 4/01/02
81 //-----------------------------------------------------------------------------
83  : defad (0.0e+0), // MOS drain diffusion area.
84  defas (0.0e+0), // MOS source diffusion area.
85  defl (1.0e-4), // MOS channel length.
86  defw (1.0e-4), // MOS channel width.
87  abstol(1.0e-12), // absolute current error tol.
88  reltol(1.0e-4), // relative current error tol.
89  chgtol(1.0e-12), // absolute charge error tol.
90  gmin (1.0e-12), // minimum allowed conductance.
91  gmin_orig (1.0e-12), // minimum allowed conductance, final
92  gmin_init (1.0e-02), // minimum allowed conductance, initial
93  gmin_scalar(1.0e10),
94  gmax (1.0e20), // maximum allowed conductance.
95  testJac_relTol(0.01), // reltol for num. jacobian diagnostic
96  testJac_absTol(1.0e-8), // abstol for num. jacobian diagnostic.
97  testJac_SqrtEta(1.0e-8), // dx = numJacSqrtEta * (1.0 + fabs(soln[i]));
98  deviceSens_dp(1.0e-8), // similar to eta, but for numerical device sensitivities
99  tnom (CONSTREFTEMP),
100  temp(Util::Param("TEMP", CONSTREFTEMP)),
101  scale_src (0.0),
102  numericalJacobianFlag (false),
103  testJacobianFlag (false),
104  testJacStartStep(0),
105  testJacStopStep(Util::MachineDependentParams::IntMax()),
106  testJacWarn (false),
107  testJacDeviceName(""),
108  testJacDeviceNameGiven( false ),
109  voltageLimiterFlag (true),
110  lambertWFlag (0),
111  icMultiplier (10000.0),
112  defaultMaxTimeStep (1.0e99),
113  vdsScaleMin(0.3),
114  vgstConst(4.5),
115  numGainScaleBlocks(1),
116  staggerGainScale(false),
117  randomizeVgstConst(false),
118  length0(5.0e-6), // used in mosfet "size" homotopy
119  width0(200.0e-6), // used in mosfet "size" homotopy
120  tox0(6.0e-8), // used in mosfet "size" homotopy
121  minRes(0.0),
122  minCap(0.0),
123  exp_order(100.0),
124  zeroResistanceTol(1.0e-100),
125  checkForZeroResistance(true),
126  detailedDeviceCounts(false),
127  sensDebugLevel(0),
128  debugLevel (1),
129  debugMinTimestep (0),
130  debugMaxTimestep (Util::MachineDependentParams::IntMax()), // later, this should be MAX_INT
131  debugMinTime (0),
132  debugMaxTime (Util::MachineDependentParams::DoubleMax()),
133  verboseLevel (0),
134  blockAnalysisFlag (false),
135 #ifndef Xyce_NEW_EXCESS_PHASE
136  newExcessPhase (false),
137  defaultNewExcessPhase (false),
138 #else
139  newExcessPhase (true),
140  defaultNewExcessPhase (true),
141 #endif
142  excessPhaseScalar1 (1.0),
143  excessPhaseScalar2 (1.0),
144  randomSeed (0),
145  tryToCompact (false),
146  calculateAllLeadCurrents (false),
147  newMeyerFlag(false)
148 {}
149 
150 //-----------------------------------------------------------------------------
151 // Function : DeviceOptions::~DeviceOptions
152 // Purpose : destructor
153 // Special Notes :
154 // Scope : public
155 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
156 // Creation Date : 4/01/02
157 //-----------------------------------------------------------------------------
159 {}
160 
161 //-----------------------------------------------------------------------------
162 // Function : DeviceOptions::registerOptions
163 // Purpose :
164 // Special Notes :
165 // Scope : public
166 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
167 // Creation Date : 5/24/00
168 //-----------------------------------------------------------------------------
169 bool DeviceOptions::registerOptions(const Util::OptionBlock & OB)
170 {
171  std::list<Util::Param>::const_iterator iter = OB.getParams().begin();
172  std::list<Util::Param>::const_iterator end = OB.getParams().end();
173 
174  for ( ; iter != end; ++iter)
175  {
176  std::string tag(iter->uTag());
177 
178  if (tag == "DEFAD") defad = iter->getImmutableValue<double>();
179  else if (tag == "DEFAS") defas = iter->getImmutableValue<double>();
180  else if (tag == "DEFL") defl = iter->getImmutableValue<double>();
181  else if (tag == "DEFW") defw = iter->getImmutableValue<double>();
182  else if (tag == "ABSTOL") abstol = iter->getImmutableValue<double>();
183  else if (tag == "RELTOL") reltol = iter->getImmutableValue<double>();
184  else if (tag == "CHGTOL") chgtol = iter->getImmutableValue<double>();
185  else if (tag == "GMIN") gmin = iter->getImmutableValue<double>();
186  else if (tag == "GMINSCALAR") gmin_scalar = iter->getImmutableValue<double>();
187  else if (tag == "GMAX") gmax = iter->getImmutableValue<double>();
188  else if (tag == "TJRELTOL") testJac_relTol = iter->getImmutableValue<double>();
189  else if (tag == "TJABSTOL") testJac_absTol = iter->getImmutableValue<double>();
190  else if (tag == "TJSQRTETA") testJac_SqrtEta = iter->getImmutableValue<double>();
191  else if (tag == "SENSDP") deviceSens_dp = iter->getImmutableValue<double>();
192  else if (tag == "TNOM") tnom = iter->getImmutableValue<double>()+CONSTCtoK;
193  else if (tag == "TEMP")
194  {
195  temp = *iter;
196  if ( !iter->isTimeDependent() ) temp.setVal(iter->getImmutableValue<double>()+CONSTCtoK);
197  else { temp.setVal( iter->stringValue() ); temp.setTimeDependent( true ); }
198  }
199  else if (tag == "SCALESRC") scale_src = iter->getImmutableValue<double>();
200  else if (tag == "NUMJAC")
201  numericalJacobianFlag = static_cast<bool>(iter->getImmutableValue<int>());
202  else if (tag == "TESTJAC")
203  testJacobianFlag = static_cast<bool>(iter->getImmutableValue<int>());
204  else if (tag == "TESTJACSTARTSTEP")
205  testJacStartStep = iter->getImmutableValue<int>();
206  else if (tag == "TESTJACSTOPSTEP")
207  testJacStopStep = iter->getImmutableValue<int>();
208  else if (tag == "TESTJACWARN")
209  testJacWarn = static_cast<bool> (iter->getImmutableValue<int>());
210  else if (tag == "TESTJACDEVICENAME")
211  {
212  testJacDeviceName = iter->stringValue();
213  testJacDeviceNameGiven = true;
214  }
215  else if (tag == "VOLTLIM")
216  voltageLimiterFlag = static_cast<bool>(iter->getImmutableValue<int>());
217  else if (tag == "LAMBERTW") lambertWFlag = static_cast<int>(iter->getImmutableValue<int>());
218  else if (tag == "ICFAC" ) icMultiplier = iter->getImmutableValue<double>();
219  else if (tag == "MAXTIMESTEP" ) defaultMaxTimeStep = iter->getImmutableValue<double>();
220 
221  else if (tag == "VDSSCALEMIN" ) vdsScaleMin = iter->getImmutableValue<double>();
222  else if (tag == "VGSTCONST" ) vgstConst = iter->getImmutableValue<double>();
223  else if (tag == "NUMGAINSCALEBLOCKS" )
224  numGainScaleBlocks = static_cast<int>(iter->getImmutableValue<int>());
225  else if (tag == "STAGGERGAINSCALE")
226  staggerGainScale = static_cast<bool>(iter->getImmutableValue<int>());
227  else if (tag == "RANDOMIZEVGSTCONST")
228  randomizeVgstConst = static_cast<bool>(iter->getImmutableValue<int>());
229  else if (tag == "LENGTH0" ) length0 = iter->getImmutableValue<double>();
230  else if (tag == "WIDTH0" ) width0 = iter->getImmutableValue<double>();
231  else if (tag == "TOX0" ) tox0 = iter->getImmutableValue<double>();
232  else if (tag == "MINRES" ) minRes = iter->getImmutableValue<double>();
233  else if (tag == "MINCAP" ) minCap = iter->getImmutableValue<double>();
234  else if (tag == "NEWMEYER" )
235  newMeyerFlag = iter->getImmutableValue<bool>();
236  else if (tag == "SENSDEBUGLEVEL")
237  {
238  sensDebugLevel = (iter->getImmutableValue<int>());
239  }
240  else if (tag == "DEBUGLEVEL")
241  {
242  debugLevel = (iter->getImmutableValue<int>());
243 
244  }
245  else if (tag == "VERBOSELEVEL")
246  {
247  verboseLevel = (iter->getImmutableValue<int>());
248  }
249  else if (tag == "DEBUGMINTIMESTEP")
250  {
251  debugMinTimestep = (iter->getImmutableValue<int>());
252  }
253  else if (tag == "DEBUGMAXTIMESTEP")
254  {
255  debugMaxTimestep = (iter->getImmutableValue<int>());
256  }
257  else if (tag == "DEBUGMINTIME")
258  {
259  debugMinTime = (iter->getImmutableValue<double>());
260  }
261  else if (tag == "DEBUGMAXTIME")
262  {
263  debugMaxTime = (iter->getImmutableValue<double>());
264  }
265  else if (tag == "NEWEXCESSPHASE")
266  {
267  newExcessPhase = static_cast<bool> (iter->getImmutableValue<int>());
268  }
269  else if (tag == "EXCESSPHASESCALAR1")
270  {
271  excessPhaseScalar1 = (iter->getImmutableValue<double>());
272  }
273  else if (tag == "EXCESSPHASESCALAR2")
274  {
275  excessPhaseScalar2 = (iter->getImmutableValue<double>());
276  }
277  else if (tag == "ZERORESISTANCETOL")
278  {
279  zeroResistanceTol = (iter->getImmutableValue<double>());
280  }
281  else if (tag == "CHECKFORZERORESISTANCE")
282  {
283  checkForZeroResistance = (iter->getImmutableValue<bool>());
284  }
285  else if (tag == "DETAILED_device_counts" )
286  {
287  detailedDeviceCounts = (iter->getImmutableValue<bool>());
288  }
289  else if (tag == "RANDOMSEED" )
290  {
291  randomSeed = (iter->getImmutableValue<long>());
292  }
293  else if (tag == "TRYTOCOMPACT")
294  {
295  tryToCompact = static_cast<bool> (iter->getImmutableValue<int>());
296  }
297  else if (tag == "CALCULATEALLLEADCURRENTS")
298  {
299  calculateAllLeadCurrents = (iter->getImmutableValue<bool>());
300  }
301  else
302  {
303  Report::UserError0() << tag << " is not a recognized device package option.";
304  }
305  }
306 
307  gmin_orig = gmin;
308  gmin_init = gmin*gmin_scalar; // by default, 10 orders of magnitude larger.
309 
310  if (DEBUG_DEVICE && debugLevel > 0)
311  dout() << *this << std::endl;
312 
313 // applyCmdLineOptions (commandLine);
314 
315  return true;
316 }
317 
318 //-----------------------------------------------------------------------------
319 // Function : DeviceOptions::setupDefaultOptions
320 // Purpose :
321 // Special Notes :
322 // Scope : public
323 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
324 // Creation Date : 7/13/00
325 //-----------------------------------------------------------------------------
326 bool DeviceOptions::setupDefaultOptions(const IO::CmdParse &cp)
327 {
328  defad = 0.0e+0; // MOS drain diffusion area.
329  defas = 0.0e+0; // MOS source diffusion area.
330  defl = 1.0e-4; // MOS channel length.
331  defw = 1.0e-4; // MOS channel width.
332  abstol= 1.0e-12; // absolute current error tol.
333  reltol = 1.0e-4; // relative current error tol.
334  chgtol= 1.0e-12; // absolute charge error tol.
335  gmin = 1.0e-12; // minimum allowed conductance.
336  gmin_orig = 1.0e-12; // minimum allowed conductance, reference
337  gmin_init = 1.0e-02; // minimum allowed conductance, initial
338  gmin_scalar = 1.0e10;
339  gmax = 1.0e20; // maximum allowed conductance.
340 
341  testJac_relTol = 0.01; // reltol for num. jacobian diagnostic
342  testJac_absTol = 1.0e-8; // abstol for num. jacobian diagnostic.
343  testJac_SqrtEta = 1.0e-8; // dx = numJacSqrtEta * (1.0 + fabs(soln[i]));
344  deviceSens_dp = 1.0e-8; // similar to eta, but for numerical device sensitivities
345 
346  tnom = CONSTREFTEMP; // nominal temp. for device params.
347  temp = Util::Param("TEMP",CONSTREFTEMP); // operating temp. of ckt.
348 
349  scale_src = 0;
350 
351  numericalJacobianFlag = false;
352  testJacobianFlag = false;
353  testJacStartStep = 0;
354  testJacStopStep = Util::MachineDependentParams::IntMax();
355  testJacWarn = false;
356  voltageLimiterFlag = true;
357  lambertWFlag = 0;
358 
359  newMeyerFlag = false;
360 
361  icMultiplier = 10000.0;
362 
363  defaultMaxTimeStep = 1.0e99;
364 
365  sensDebugLevel = 0;
366  debugLevel = 1;
368  debugMaxTimestep=Util::MachineDependentParams::IntMax();
369  debugMinTime=0;
370  debugMaxTime=Util::MachineDependentParams::DoubleMax();
371  verboseLevel = 0;
372 
373  newExcessPhase = defaultNewExcessPhase; // true if MPDE, false otherwise.
374  excessPhaseScalar1 = 1.0;
375  excessPhaseScalar2 = 1.0;
376 
377  if( cp.getArgumentValue( "-dva" ) == "off" )
378  {
379  lout() << "Warning: -dva is no longer a recognized option.\n" << std::endl;
380  }
381 
382  if( cp.getArgumentValue( "-dma" ) == "off" )
383  {
384  lout() << "Warning: -dma is no longer a recognized option.\n" << std::endl;
385  }
386 
387  return true;
388 
389 }
390 
391 //-----------------------------------------------------------------------------
392 // Function : DeviceOptions::applyCmdLineOptions
393 // Purpose :
394 // Special Notes :
395 // Scope : public
396 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
397 // Creation Date : 5/24/05
398 //-----------------------------------------------------------------------------
399 bool DeviceOptions::applyCmdLineOptions(const IO::CmdParse &cp)
400 {
401  if (DEBUG_DEVICE) {
402  // set (or override) debug levels based on command line options
403  if ( cp.argExists( "-sdl" ) )
404  {
405  sensDebugLevel = atoi( cp.getArgumentValue( "-sdl" ).c_str() );
406  }
407 
408  if ( cp.argExists( "-ddl" ) )
409  {
410  debugLevel = atoi( cp.getArgumentValue( "-ddl" ).c_str() );
411  }
412  }
413 
414  if (cp.argExists("-jacobian_test"))
415  {
416  testJacobianFlag = true;
417  }
418 
419  return true;
420 }
421 
422 
423 // //-----------------------------------------------------------------------------
424 // // Function : DeviceOptions::operator=
425 // // Purpose : assignment operator
426 // // Special Notes :
427 // // Scope :
428 // // Creator : Eric Keiter, SNL, Parallel Computational Sciences
429 // // Creation Date : 12/16/05
430 // //-----------------------------------------------------------------------------
431 // DeviceOptions & DeviceOptions::operator=(DeviceOptions const & rhs)
432 // {
433 // commandLine = rhs.commandLine;
434 
435 // defad = rhs.defad;
436 // defas = rhs.defas;
437 // defl = rhs.defl;
438 // defw = rhs.defw;
439 // abstol = rhs.abstol;
440 // reltol = rhs.reltol;
441 // chgtol = rhs.chgtol;
442 // gmin = rhs.gmin;
443 // gmin_orig = rhs.gmin_orig;
444 // gmin_init = rhs.gmin_init;
445 // gmin_scalar = rhs.gmin_scalar;
446 // gmax = rhs.gmax;
447 // testJac_relTol = rhs.testJac_relTol;
448 // testJac_absTol = rhs.testJac_absTol;
449 // testJac_SqrtEta = rhs.testJac_SqrtEta;
450 // deviceSens_dp = rhs.deviceSens_dp;
451 // tnom = rhs.tnom;
452 // temp = rhs.temp;
453 // scale_src = rhs.scale_src;
454 // numericalJacobianFlag = rhs.numericalJacobianFlag;
455 // testJacobianFlag = rhs.testJacobianFlag;
456 // testJacStartStep = rhs.testJacStartStep;
457 // testJacStopStep = rhs.testJacStopStep;
458 // testJacWarn = rhs.testJacWarn;
459 // voltageLimiterFlag = rhs.voltageLimiterFlag;
460 // lambertWFlag = rhs.lambertWFlag;
461 // icMultiplier = rhs.icMultiplier;
462 // defaultMaxTimeStep = rhs.defaultMaxTimeStep;
463 // vdsScaleMin = rhs.vdsScaleMin;
464 // vgstConst = rhs.vgstConst;
465 // numGainScaleBlocks = rhs.numGainScaleBlocks;
466 // staggerGainScale = rhs.staggerGainScale;
467 // randomizeVgstConst = rhs.randomizeVgstConst;
468 // length0 = rhs.length0;
469 // width0 = rhs.width0;
470 // tox0 = rhs.tox0;
471 // minRes = rhs.minRes;
472 // minCap = rhs.minCap;
473 // sensDebugLevel = rhs.sensDebugLevel;
474 // debugLevel = rhs.debugLevel;
475 // debugMinTimestep = rhs.debugMinTimestep;
476 // debugMaxTimestep = rhs.debugMaxTimestep;
477 // debugMinTime = rhs.debugMinTime;
478 // debugMaxTime = rhs.debugMaxTime;
479 // verboseLevel = rhs.verboseLevel;
480 
481 // blockAnalysisFlag = rhs.blockAnalysisFlag;
482 // newExcessPhase = rhs.newExcessPhase;
483 // defaultNewExcessPhase = rhs.defaultNewExcessPhase;
484 // excessPhaseScalar1 = rhs.excessPhaseScalar1;
485 // excessPhaseScalar2 = rhs.excessPhaseScalar2 ;
486 // newMeyerFlag=rhs.newMeyerFlag;
487 // return *this;
488 // }
489 
490 
491 //-----------------------------------------------------------------------------
492 // Function : DeviceOptions::operator<<
493 // Purpose : "<<" operator
494 // Special Notes :
495 // Scope : public
496 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
497 // Creation Date : 5/23/05
498 //-----------------------------------------------------------------------------
499 std::ostream & operator<<(std::ostream & os, const DeviceOptions & devOp)
500 {
501  os << "\n\n-----------------------------------------" << std::endl;
502  os << "\tDevice Options:\n";
503  os << "\t\tdefad = " << devOp.defad <<"\n";
504  os << "\t\tdefas = " << devOp.defas <<"\n";
505  os << "\t\tdefl = " << devOp.defl <<"\n";
506  os << "\t\tdefw = " << devOp.defw <<"\n";
507  os << "\t\tabstol = " << devOp.abstol <<"\n";
508  os << "\t\treltol = " << devOp.reltol <<"\n";
509  os << "\t\tchgtol = " << devOp.chgtol <<"\n";
510  os << "\t\tgmin = " << devOp.gmin <<"\n";
511  os << "\t\tgmin_orig = " << devOp.gmin_orig <<"\n";
512  os << "\t\tgmin_init = " << devOp.gmin_init <<"\n";
513  os << "\t\tgmin_scalar = " << devOp.gmin_scalar <<"\n";
514  os << "\t\tgmax = " << devOp.gmax <<"\n";
515  os << "\t\ttnom = " << devOp.tnom <<"\n";
516  os << "\t\tscale_src = " << devOp.scale_src <<"\n";
517  os << "\t\tnumericalJacobianFlag = " << devOp.numericalJacobianFlag <<"\n";
518  os << "\t\ttestJacobianFlag = " << devOp.testJacobianFlag << "\n";
519  os << "\t\ttestJacStartStep = " << devOp.testJacStartStep << "\n";
520  os << "\t\ttestJacStopStep = " << devOp.testJacStopStep << "\n";
521  os << "\t\ttestJacWarn = " << devOp.testJacWarn << "\n";
522  os << "\t\ttestJacDeviceName = " << devOp.testJacDeviceName << "\n";
523 
524  os << "\t\ttestJac_relTol = " << devOp.testJac_relTol << "\n";
525  os << "\t\ttestJac_absTol = " << devOp.testJac_absTol << "\n";
526  os << "\t\ttestJac_SqrtEta = " << devOp.testJac_SqrtEta << "\n";
527  os << "\t\tdeviceSens_dp = " << devOp.deviceSens_dp << "\n";
528 
529  os << "\t\tvoltageLimiterFlag = " << devOp.voltageLimiterFlag <<"\n";
530  os << "\t\tlambertWFlag = " << devOp.lambertWFlag <<"\n";
531  os << "\t\ticMultiplier = " << devOp.icMultiplier <<"\n";
532  os << "\t\tdefaultMaxTimeStep = " << devOp.defaultMaxTimeStep <<"\n";
533  os << "\t\tvdsScaleMin = " << devOp.vdsScaleMin <<"\n";
534  os << "\t\tvgstConst = " << devOp.vgstConst <<"\n";
535  os << "\t\tnumGainScaleBlocks = " << devOp.numGainScaleBlocks <<"\n";
536  os << "\t\tstaggerGainScale = " << devOp.staggerGainScale <<"\n";
537  os << "\t\trandomizeVgstConst = " << devOp.randomizeVgstConst <<"\n";
538  os << "\t\tlength0 = " << devOp.length0 <<"\n";
539  os << "\t\twidth0 = " << devOp.width0 <<"\n";
540  os << "\t\ttox0 = " << devOp.tox0 <<"\n";
541  os << "\t\tminres = " << devOp.minRes <<"\n";
542  os << "\t\tmincap = " << devOp.minCap <<"\n";
543  os << "\t\tsensDebugLevel = " << devOp.sensDebugLevel <<"\n";
544  os << "\t\tdebugLevel = " << devOp.debugLevel <<"\n";
545  os << "\t\tdebugMinTimestep = " << devOp.debugMinTimestep <<"\n";
546  os << "\t\tdebugMaxTimestep = " << devOp.debugMaxTimestep <<"\n";
547  os << "\t\tdebugMinTime = " << devOp.debugMinTime <<"\n";
548  os << "\t\tdebugMaxTime = " << devOp.debugMaxTime <<"\n";
549  os << "\t\tverboseLevel = " << devOp.verboseLevel <<"\n";
550  os << "\t\tblockAnalysisFlag = " << devOp.blockAnalysisFlag << "\n";
551  os << "\t\tnewExcessPhase = " << devOp.newExcessPhase << "\n";
552  os << "\t\tdefaultNewExcessPhase = " << devOp.defaultNewExcessPhase << "\n";
553  os << "\t\texcessPhaseScalar1 = " << devOp.excessPhaseScalar1 << "\n";
554  os << "\t\texcessPhaseScalar2 = " << devOp.excessPhaseScalar2 << "\n";
555  os << "\t\tnewMeyerFlag = " << devOp.newMeyerFlag << "\n";
556  os << Xyce::section_divider;
557  os << std::endl;
558 
559  return os;
560 }
561 
562 } // namespace Device
563 } // namespace Xyce