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.91 $
40 //
41 // Revision Date : $Date: 2014/07/30 17:36:26 $
42 //
43 // Current Owner : $Author: hkthorn $
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  sensDebugLevel(0),
127  debugLevel (1),
128  debugMinTimestep (0),
129  debugMaxTimestep (Util::MachineDependentParams::IntMax()), // later, this should be MAX_INT
130  debugMinTime (0),
131  debugMaxTime (Util::MachineDependentParams::DoubleMax()),
132  verboseLevel (0),
133  blockAnalysisFlag (false),
134 #ifndef Xyce_NEW_EXCESS_PHASE
135  newExcessPhase (false),
136  defaultNewExcessPhase (false),
137 #else
138  newExcessPhase (true),
139  defaultNewExcessPhase (true),
140 #endif
141  excessPhaseScalar1 (1.0),
142  excessPhaseScalar2 (1.0),
143  randomSeed (0),
144  tryToCompact (false),
145  calculateAllLeadCurrents (false),
146  newMeyerFlag(false)
147 {}
148 
149 //-----------------------------------------------------------------------------
150 // Function : DeviceOptions::~DeviceOptions
151 // Purpose : destructor
152 // Special Notes :
153 // Scope : public
154 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
155 // Creation Date : 4/01/02
156 //-----------------------------------------------------------------------------
158 {}
159 
160 //-----------------------------------------------------------------------------
161 // Function : DeviceOptions::registerOptions
162 // Purpose :
163 // Special Notes :
164 // Scope : public
165 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
166 // Creation Date : 5/24/00
167 //-----------------------------------------------------------------------------
168 bool DeviceOptions::registerOptions(const Util::OptionBlock & OB)
169 {
170  std::list<Util::Param>::const_iterator iter = OB.getParams().begin();
171  std::list<Util::Param>::const_iterator end = OB.getParams().end();
172 
173  for ( ; iter != end; ++iter)
174  {
175  std::string tag(iter->uTag());
176 
177  if (tag == "DEFAD") defad = iter->getImmutableValue<double>();
178  else if (tag == "DEFAS") defas = iter->getImmutableValue<double>();
179  else if (tag == "DEFL") defl = iter->getImmutableValue<double>();
180  else if (tag == "DEFW") defw = iter->getImmutableValue<double>();
181  else if (tag == "ABSTOL") abstol = iter->getImmutableValue<double>();
182  else if (tag == "RELTOL") reltol = iter->getImmutableValue<double>();
183  else if (tag == "CHGTOL") chgtol = iter->getImmutableValue<double>();
184  else if (tag == "GMIN") gmin = iter->getImmutableValue<double>();
185  else if (tag == "GMINSCALAR") gmin_scalar = iter->getImmutableValue<double>();
186  else if (tag == "GMAX") gmax = iter->getImmutableValue<double>();
187  else if (tag == "TJRELTOL") testJac_relTol = iter->getImmutableValue<double>();
188  else if (tag == "TJABSTOL") testJac_absTol = iter->getImmutableValue<double>();
189  else if (tag == "TJSQRTETA") testJac_SqrtEta = iter->getImmutableValue<double>();
190  else if (tag == "SENSDP") deviceSens_dp = iter->getImmutableValue<double>();
191  else if (tag == "TNOM") tnom = iter->getImmutableValue<double>()+CONSTCtoK;
192  else if (tag == "TEMP")
193  {
194  temp = *iter;
195  if ( !iter->isTimeDependent() ) temp.setVal(iter->getImmutableValue<double>()+CONSTCtoK);
196  else { temp.setVal( iter->stringValue() ); temp.setTimeDependent( true ); }
197  }
198  else if (tag == "SCALESRC") scale_src = iter->getImmutableValue<double>();
199  else if (tag == "NUMJAC")
200  numericalJacobianFlag = static_cast<bool>(iter->getImmutableValue<int>());
201  else if (tag == "TESTJAC")
202  testJacobianFlag = static_cast<bool>(iter->getImmutableValue<int>());
203  else if (tag == "TESTJACSTARTSTEP")
204  testJacStartStep = iter->getImmutableValue<int>();
205  else if (tag == "TESTJACSTOPSTEP")
206  testJacStopStep = iter->getImmutableValue<int>();
207  else if (tag == "TESTJACWARN")
208  testJacWarn = static_cast<bool> (iter->getImmutableValue<int>());
209  else if (tag == "TESTJACDEVICENAME")
210  {
211  testJacDeviceName = iter->stringValue();
212  testJacDeviceNameGiven = true;
213  }
214  else if (tag == "VOLTLIM")
215  voltageLimiterFlag = static_cast<bool>(iter->getImmutableValue<int>());
216  else if (tag == "LAMBERTW") lambertWFlag = static_cast<int>(iter->getImmutableValue<int>());
217  else if (tag == "ICFAC" ) icMultiplier = iter->getImmutableValue<double>();
218  else if (tag == "MAXTIMESTEP" ) defaultMaxTimeStep = iter->getImmutableValue<double>();
219 
220  else if (tag == "VDSSCALEMIN" ) vdsScaleMin = iter->getImmutableValue<double>();
221  else if (tag == "VGSTCONST" ) vgstConst = iter->getImmutableValue<double>();
222  else if (tag == "NUMGAINSCALEBLOCKS" )
223  numGainScaleBlocks = static_cast<int>(iter->getImmutableValue<int>());
224  else if (tag == "STAGGERGAINSCALE")
225  staggerGainScale = static_cast<bool>(iter->getImmutableValue<int>());
226  else if (tag == "RANDOMIZEVGSTCONST")
227  randomizeVgstConst = static_cast<bool>(iter->getImmutableValue<int>());
228  else if (tag == "LENGTH0" ) length0 = iter->getImmutableValue<double>();
229  else if (tag == "WIDTH0" ) width0 = iter->getImmutableValue<double>();
230  else if (tag == "TOX0" ) tox0 = iter->getImmutableValue<double>();
231  else if (tag == "MINRES" ) minRes = iter->getImmutableValue<double>();
232  else if (tag == "MINCAP" ) minCap = iter->getImmutableValue<double>();
233  else if (tag == "NEWMEYER" )
234  newMeyerFlag = iter->getImmutableValue<bool>();
235  else if (tag == "SENSDEBUGLEVEL")
236  {
237  sensDebugLevel = (iter->getImmutableValue<int>());
238  }
239  else if (tag == "DEBUGLEVEL")
240  {
241  debugLevel = (iter->getImmutableValue<int>());
242 
243  }
244  else if (tag == "VERBOSELEVEL")
245  {
246  verboseLevel = (iter->getImmutableValue<int>());
247  }
248  else if (tag == "DEBUGMINTIMESTEP")
249  {
250  debugMinTimestep = (iter->getImmutableValue<int>());
251  }
252  else if (tag == "DEBUGMAXTIMESTEP")
253  {
254  debugMaxTimestep = (iter->getImmutableValue<int>());
255  }
256  else if (tag == "DEBUGMINTIME")
257  {
258  debugMinTime = (iter->getImmutableValue<double>());
259  }
260  else if (tag == "DEBUGMAXTIME")
261  {
262  debugMaxTime = (iter->getImmutableValue<double>());
263  }
264  else if (tag == "NEWEXCESSPHASE")
265  {
266  newExcessPhase = static_cast<bool> (iter->getImmutableValue<int>());
267  }
268  else if (tag == "EXCESSPHASESCALAR1")
269  {
270  excessPhaseScalar1 = (iter->getImmutableValue<double>());
271  }
272  else if (tag == "EXCESSPHASESCALAR2")
273  {
274  excessPhaseScalar2 = (iter->getImmutableValue<double>());
275  }
276  else if (tag == "ZERORESISTANCETOL")
277  {
278  zeroResistanceTol = (iter->getImmutableValue<double>());
279  }
280  else if (tag == "CHECKFORZERORESISTANCE")
281  {
282  checkForZeroResistance = (iter->getImmutableValue<bool>());
283  }
284  else if (tag == "RANDOMSEED" )
285  {
286  randomSeed = (iter->getImmutableValue<long>());
287  }
288  else if (tag == "TRYTOCOMPACT")
289  {
290  tryToCompact = static_cast<bool> (iter->getImmutableValue<int>());
291  }
292  else if (tag == "CALCULATEALLLEADCURRENTS")
293  {
294  calculateAllLeadCurrents = (iter->getImmutableValue<bool>());
295  }
296  else
297  {
298  Report::UserError0() << tag << " is not a recognized device package option.";
299  }
300  }
301 
302  gmin_orig = gmin;
303  gmin_init = gmin*gmin_scalar; // by default, 10 orders of magnitude larger.
304 
305  if (DEBUG_DEVICE && debugLevel > 0)
306  dout() << *this << std::endl;
307 
308 // applyCmdLineOptions (commandLine);
309 
310  return true;
311 }
312 
313 //-----------------------------------------------------------------------------
314 // Function : DeviceOptions::setupDefaultOptions
315 // Purpose :
316 // Special Notes :
317 // Scope : public
318 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
319 // Creation Date : 7/13/00
320 //-----------------------------------------------------------------------------
321 bool DeviceOptions::setupDefaultOptions(const IO::CmdParse &cp)
322 {
323  defad = 0.0e+0; // MOS drain diffusion area.
324  defas = 0.0e+0; // MOS source diffusion area.
325  defl = 1.0e-4; // MOS channel length.
326  defw = 1.0e-4; // MOS channel width.
327  abstol= 1.0e-12; // absolute current error tol.
328  reltol = 1.0e-4; // relative current error tol.
329  chgtol= 1.0e-12; // absolute charge error tol.
330  gmin = 1.0e-12; // minimum allowed conductance.
331  gmin_orig = 1.0e-12; // minimum allowed conductance, reference
332  gmin_init = 1.0e-02; // minimum allowed conductance, initial
333  gmin_scalar = 1.0e10;
334  gmax = 1.0e20; // maximum allowed conductance.
335 
336  testJac_relTol = 0.01; // reltol for num. jacobian diagnostic
337  testJac_absTol = 1.0e-8; // abstol for num. jacobian diagnostic.
338  testJac_SqrtEta = 1.0e-8; // dx = numJacSqrtEta * (1.0 + fabs(soln[i]));
339  deviceSens_dp = 1.0e-8; // similar to eta, but for numerical device sensitivities
340 
341  tnom = CONSTREFTEMP; // nominal temp. for device params.
342  temp = Util::Param("TEMP",CONSTREFTEMP); // operating temp. of ckt.
343 
344  scale_src = 0;
345 
346  numericalJacobianFlag = false;
347  testJacobianFlag = false;
348  testJacStartStep = 0;
349  testJacStopStep = Util::MachineDependentParams::IntMax();
350  testJacWarn = false;
351  voltageLimiterFlag = true;
352  lambertWFlag = 0;
353 
354  newMeyerFlag = false;
355 
356  icMultiplier = 10000.0;
357 
358  defaultMaxTimeStep = 1.0e99;
359 
360  sensDebugLevel = 0;
361  debugLevel = 1;
363  debugMaxTimestep=Util::MachineDependentParams::IntMax();
364  debugMinTime=0;
365  debugMaxTime=Util::MachineDependentParams::DoubleMax();
366  verboseLevel = 0;
367 
368  newExcessPhase = defaultNewExcessPhase; // true if MPDE, false otherwise.
369  excessPhaseScalar1 = 1.0;
370  excessPhaseScalar2 = 1.0;
371 
372  if( cp.getArgumentValue( "-dva" ) == "off" )
373  {
374  lout() << "Warning: -dva is no longer a recognized option.\n" << std::endl;
375  }
376 
377  if( cp.getArgumentValue( "-dma" ) == "off" )
378  {
379  lout() << "Warning: -dma is no longer a recognized option.\n" << std::endl;
380  }
381 
382  return true;
383 
384 }
385 
386 //-----------------------------------------------------------------------------
387 // Function : DeviceOptions::applyCmdLineOptions
388 // Purpose :
389 // Special Notes :
390 // Scope : public
391 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
392 // Creation Date : 5/24/05
393 //-----------------------------------------------------------------------------
394 bool DeviceOptions::applyCmdLineOptions(const IO::CmdParse &cp)
395 {
396  if (DEBUG_DEVICE) {
397  // set (or override) debug levels based on command line options
398  if ( cp.argExists( "-sdl" ) )
399  {
400  sensDebugLevel = atoi( cp.getArgumentValue( "-sdl" ).c_str() );
401  }
402 
403  if ( cp.argExists( "-ddl" ) )
404  {
405  debugLevel = atoi( cp.getArgumentValue( "-ddl" ).c_str() );
406  }
407  }
408 
409  if (cp.argExists("-jacobian_test"))
410  {
411  testJacobianFlag = true;
412  }
413 
414  return true;
415 }
416 
417 
418 // //-----------------------------------------------------------------------------
419 // // Function : DeviceOptions::operator=
420 // // Purpose : assignment operator
421 // // Special Notes :
422 // // Scope :
423 // // Creator : Eric Keiter, SNL, Parallel Computational Sciences
424 // // Creation Date : 12/16/05
425 // //-----------------------------------------------------------------------------
426 // DeviceOptions & DeviceOptions::operator=(DeviceOptions const & rhs)
427 // {
428 // commandLine = rhs.commandLine;
429 
430 // defad = rhs.defad;
431 // defas = rhs.defas;
432 // defl = rhs.defl;
433 // defw = rhs.defw;
434 // abstol = rhs.abstol;
435 // reltol = rhs.reltol;
436 // chgtol = rhs.chgtol;
437 // gmin = rhs.gmin;
438 // gmin_orig = rhs.gmin_orig;
439 // gmin_init = rhs.gmin_init;
440 // gmin_scalar = rhs.gmin_scalar;
441 // gmax = rhs.gmax;
442 // testJac_relTol = rhs.testJac_relTol;
443 // testJac_absTol = rhs.testJac_absTol;
444 // testJac_SqrtEta = rhs.testJac_SqrtEta;
445 // deviceSens_dp = rhs.deviceSens_dp;
446 // tnom = rhs.tnom;
447 // temp = rhs.temp;
448 // scale_src = rhs.scale_src;
449 // numericalJacobianFlag = rhs.numericalJacobianFlag;
450 // testJacobianFlag = rhs.testJacobianFlag;
451 // testJacStartStep = rhs.testJacStartStep;
452 // testJacStopStep = rhs.testJacStopStep;
453 // testJacWarn = rhs.testJacWarn;
454 // voltageLimiterFlag = rhs.voltageLimiterFlag;
455 // lambertWFlag = rhs.lambertWFlag;
456 // icMultiplier = rhs.icMultiplier;
457 // defaultMaxTimeStep = rhs.defaultMaxTimeStep;
458 // vdsScaleMin = rhs.vdsScaleMin;
459 // vgstConst = rhs.vgstConst;
460 // numGainScaleBlocks = rhs.numGainScaleBlocks;
461 // staggerGainScale = rhs.staggerGainScale;
462 // randomizeVgstConst = rhs.randomizeVgstConst;
463 // length0 = rhs.length0;
464 // width0 = rhs.width0;
465 // tox0 = rhs.tox0;
466 // minRes = rhs.minRes;
467 // minCap = rhs.minCap;
468 // sensDebugLevel = rhs.sensDebugLevel;
469 // debugLevel = rhs.debugLevel;
470 // debugMinTimestep = rhs.debugMinTimestep;
471 // debugMaxTimestep = rhs.debugMaxTimestep;
472 // debugMinTime = rhs.debugMinTime;
473 // debugMaxTime = rhs.debugMaxTime;
474 // verboseLevel = rhs.verboseLevel;
475 
476 // blockAnalysisFlag = rhs.blockAnalysisFlag;
477 // newExcessPhase = rhs.newExcessPhase;
478 // defaultNewExcessPhase = rhs.defaultNewExcessPhase;
479 // excessPhaseScalar1 = rhs.excessPhaseScalar1;
480 // excessPhaseScalar2 = rhs.excessPhaseScalar2 ;
481 // newMeyerFlag=rhs.newMeyerFlag;
482 // return *this;
483 // }
484 
485 
486 //-----------------------------------------------------------------------------
487 // Function : DeviceOptions::operator<<
488 // Purpose : "<<" operator
489 // Special Notes :
490 // Scope : public
491 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
492 // Creation Date : 5/23/05
493 //-----------------------------------------------------------------------------
494 std::ostream & operator<<(std::ostream & os, const DeviceOptions & devOp)
495 {
496  os << "\n\n-----------------------------------------" << std::endl;
497  os << "\tDevice Options:\n";
498  os << "\t\tdefad = " << devOp.defad <<"\n";
499  os << "\t\tdefas = " << devOp.defas <<"\n";
500  os << "\t\tdefl = " << devOp.defl <<"\n";
501  os << "\t\tdefw = " << devOp.defw <<"\n";
502  os << "\t\tabstol = " << devOp.abstol <<"\n";
503  os << "\t\treltol = " << devOp.reltol <<"\n";
504  os << "\t\tchgtol = " << devOp.chgtol <<"\n";
505  os << "\t\tgmin = " << devOp.gmin <<"\n";
506  os << "\t\tgmin_orig = " << devOp.gmin_orig <<"\n";
507  os << "\t\tgmin_init = " << devOp.gmin_init <<"\n";
508  os << "\t\tgmin_scalar = " << devOp.gmin_scalar <<"\n";
509  os << "\t\tgmax = " << devOp.gmax <<"\n";
510  os << "\t\ttnom = " << devOp.tnom <<"\n";
511  os << "\t\tscale_src = " << devOp.scale_src <<"\n";
512  os << "\t\tnumericalJacobianFlag = " << devOp.numericalJacobianFlag <<"\n";
513  os << "\t\ttestJacobianFlag = " << devOp.testJacobianFlag << "\n";
514  os << "\t\ttestJacStartStep = " << devOp.testJacStartStep << "\n";
515  os << "\t\ttestJacStopStep = " << devOp.testJacStopStep << "\n";
516  os << "\t\ttestJacWarn = " << devOp.testJacWarn << "\n";
517  os << "\t\ttestJacDeviceName = " << devOp.testJacDeviceName << "\n";
518 
519  os << "\t\ttestJac_relTol = " << devOp.testJac_relTol << "\n";
520  os << "\t\ttestJac_absTol = " << devOp.testJac_absTol << "\n";
521  os << "\t\ttestJac_SqrtEta = " << devOp.testJac_SqrtEta << "\n";
522  os << "\t\tdeviceSens_dp = " << devOp.deviceSens_dp << "\n";
523 
524  os << "\t\tvoltageLimiterFlag = " << devOp.voltageLimiterFlag <<"\n";
525  os << "\t\tlambertWFlag = " << devOp.lambertWFlag <<"\n";
526  os << "\t\ticMultiplier = " << devOp.icMultiplier <<"\n";
527  os << "\t\tdefaultMaxTimeStep = " << devOp.defaultMaxTimeStep <<"\n";
528  os << "\t\tvdsScaleMin = " << devOp.vdsScaleMin <<"\n";
529  os << "\t\tvgstConst = " << devOp.vgstConst <<"\n";
530  os << "\t\tnumGainScaleBlocks = " << devOp.numGainScaleBlocks <<"\n";
531  os << "\t\tstaggerGainScale = " << devOp.staggerGainScale <<"\n";
532  os << "\t\trandomizeVgstConst = " << devOp.randomizeVgstConst <<"\n";
533  os << "\t\tlength0 = " << devOp.length0 <<"\n";
534  os << "\t\twidth0 = " << devOp.width0 <<"\n";
535  os << "\t\ttox0 = " << devOp.tox0 <<"\n";
536  os << "\t\tminres = " << devOp.minRes <<"\n";
537  os << "\t\tmincap = " << devOp.minCap <<"\n";
538  os << "\t\tsensDebugLevel = " << devOp.sensDebugLevel <<"\n";
539  os << "\t\tdebugLevel = " << devOp.debugLevel <<"\n";
540  os << "\t\tdebugMinTimestep = " << devOp.debugMinTimestep <<"\n";
541  os << "\t\tdebugMaxTimestep = " << devOp.debugMaxTimestep <<"\n";
542  os << "\t\tdebugMinTime = " << devOp.debugMinTime <<"\n";
543  os << "\t\tdebugMaxTime = " << devOp.debugMaxTime <<"\n";
544  os << "\t\tverboseLevel = " << devOp.verboseLevel <<"\n";
545  os << "\t\tblockAnalysisFlag = " << devOp.blockAnalysisFlag << "\n";
546  os << "\t\tnewExcessPhase = " << devOp.newExcessPhase << "\n";
547  os << "\t\tdefaultNewExcessPhase = " << devOp.defaultNewExcessPhase << "\n";
548  os << "\t\texcessPhaseScalar1 = " << devOp.excessPhaseScalar1 << "\n";
549  os << "\t\texcessPhaseScalar2 = " << devOp.excessPhaseScalar2 << "\n";
550  os << "\t\tnewMeyerFlag = " << devOp.newMeyerFlag << "\n";
551  os << Xyce::section_divider;
552  os << std::endl;
553 
554  return os;
555 }
556 
557 } // namespace Device
558 } // namespace Xyce