Xyce  6.1
N_DEV_Diode.h
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-2015 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_Diode.h,v $
27 //
28 // Purpose :
29 //
30 // Special Notes :
31 //
32 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
33 //
34 // Creation Date : 02/28/00
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.139 $
40 //
41 // Revision Date : $Date: 2015/04/08 19:18:24 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-----------------------------------------------------------------------------
45 
46 #ifndef Xyce_N_DEV_Diode_h
47 #define Xyce_N_DEV_Diode_h
48 
49 #include <Sacado.hpp>
50 
51 // ---------- Xyce Includes ----------
52 #include <N_DEV_Configuration.h>
53 #include <N_DEV_DeviceMaster.h>
54 #include <N_DEV_DeviceBlock.h>
55 #include <N_DEV_DeviceInstance.h>
56 #include <N_DEV_DeviceModel.h>
57 
58 #include <N_DEV_Param.h>
59 
60 namespace Xyce {
61 namespace Device {
62 namespace Diode {
63 
64 class Model;
65 class Instance;
66 
67 typedef Sacado::Fad::SFad<double, 1> fadType;
68 
69 
70 template <typename ScalarT>
71 inline ScalarT Xycemax ( ScalarT f1, ScalarT f2) { return f1 > f2 ? f1 : f2; }
72 
73 template <typename ScalarT>
74 inline ScalarT Xycemin ( ScalarT f1, ScalarT f2) { return f1 < f2 ? f1 : f2; }
75 
76 /// general sensitivity functor for all model params.
78 {
79  public:
81  baseSensitivity() {};
82 
83  virtual ~diodeSensitivity() {};
84 
85  virtual void operator()(
86  const ParameterBase &entity,
87  const std::string &param,
88  std::vector<double> & dfdp,
89  std::vector<double> & dqdp,
90  std::vector<double> & dbdp,
91  std::vector<int> & Findices,
92  std::vector<int> & Qindices,
93  std::vector<int> & Bindices
94  ) const ;
95 };
96 
98 
99 struct Traits : public DeviceTraits<Model, Instance>
100 {
101  static const char *name() {return "Diode";}
102  static const char *deviceTypeName() {return "D level 1,2";}
103  static int numNodes() {return 2;}
104  static bool modelRequired() {return true;}
105  static bool isLinearDevice() {return false;}
106 
107  static Device *factory(const Configuration &configuration, const FactoryBlock &factory_block);
108  static void loadModelParameters(ParametricData<Model> &model_parameters);
109  static void loadInstanceParameters(ParametricData<Instance> &instance_parameters);
110 };
111 
112 
113 template <typename ScalarT>
114 bool processParams (
115  ScalarT & M,
116  ScalarT & EG,
117  ScalarT & FC,
118  const ScalarT & RS,
119  ScalarT & COND,
120  ScalarT & F2,
121  ScalarT & F3
122  );
123 
124 template <typename ScalarT>
125 bool updateTemperature
126 (
127  //const double & temp, Instance & instance, Model & model_,
128  // instance params:
129  ScalarT & Temp,
130  ScalarT & tJctCap,
131  ScalarT & tJctPot,
132  ScalarT & tDepCap,
133  ScalarT & tF1,
134  ScalarT & tSatCur,
135  ScalarT & tSatCurR,
136  ScalarT & tVcrit,
137  ScalarT & tRS,
138  ScalarT & tCOND,
139  ScalarT & tIRF,
140  ScalarT & tIKF,
141  ScalarT & tBrkdwnV,
142 
143  // model variables/params:
144  const ScalarT & TNOM,
145  const ScalarT & VJ,
146  const ScalarT & CJO,
147  const ScalarT & M,
148  const ScalarT & N,
149  const ScalarT & IS,
150  const ScalarT & EG,
151  const ScalarT & XTI,
152  const ScalarT & RS,
153  const ScalarT & COND,
154  const ScalarT & IRF,
155  const ScalarT & NR,
156  const ScalarT & IKF,
157  const ScalarT & TIKF,
158  const ScalarT & ISR,
159  const ScalarT & IBV,
160  const ScalarT & BV,
161  const bool & BVGiven,
162  const ScalarT & TBV1,
163  const ScalarT & TBV2,
164  const ScalarT & TRS1,
165  const ScalarT & TRS2,
166  const ScalarT & FC,
167  const int level
168 
169  );
170 
171 template <typename ScalarT>
173  (
174  // inputs:
175  const ScalarT & Vp,
176  const ScalarT & Vpp,
177  const ScalarT & Vn,
178  const ScalarT & Vd,
179 
180  // instance params:
181  const ScalarT & Temp,
182  const ScalarT & tJctCap,
183  const ScalarT & tJctPot,
184  const ScalarT & tDepCap,
185  const ScalarT & tF1,
186  const ScalarT & tSatCur,
187  const ScalarT & tSatCurR,
188  const ScalarT & tVcrit,
189  const ScalarT & tRS,
190  const ScalarT & tCOND,
191  const ScalarT & tIRF,
192  const ScalarT & tIKF,
193  const ScalarT & tBrkdwnV,
194 
195  // instance variables:
196  const ScalarT & Area,
197  const int & lambertWFlag,
198  const double & gmin,
199 
200  // model params:
201  const ScalarT M , // grading parameter
202  const ScalarT BV , // breakdown voltage
203  const ScalarT IBV , // reverse breakdown current
204  const ScalarT NBV , // reverse breakdown ideality factor
205  const ScalarT IBVL, // low-level reverse breakdown current
206  const ScalarT NBVL, // low-level reverse breakdown ideality factor
207  const ScalarT N , // non-ideality factor.
208  const ScalarT NR , // emission coeff. for ISR.
209  const ScalarT TT , // transit time.
210  const ScalarT F2 , // capacitive polynomial factor
211  const ScalarT F3 , // capacitive polynomial factor
212 
213  const int level,
214 
215  // outputs:
216  ScalarT & Id,
217  ScalarT & Gd,
218  ScalarT & Qd,
219  ScalarT & Cd,
220  ScalarT & Gspr
221  );
222 
223 template <typename ScalarT>
224 bool applyLimiters
225 (
226  DeviceSupport & devSupport,
227 
228  // inputs:
229  const ScalarT & Vp,
230  const ScalarT & Vpp,
231  const ScalarT & Vn,
232 
233  // parameters:
234  const ScalarT & tVcrit,
235 
236  // output
237  ScalarT & Vd,
238  ScalarT & Vd_orig,
239  ScalarT & Vd_old,
240 
241  const ScalarT & currVd_old,
242  const ScalarT & nextVd_old,
243 
244  const double InitCond,
245  const bool InitCondGiven,
246  const bool BVGiven,
247 
248  // instance vars:
249  const int off,
250  bool & origFlag,
251 
252  const bool dotICapplies, // check all the "flagSol". if any == 1, then true
253 
254  // solver state variables:
255  const int & newtonIter,
256  const bool initJctFlag,
257  const bool voltageLimiterFlag,
258  const bool dcopFlag,
259  const bool locaEnabledFlag
260  );
261 
262 //-----------------------------------------------------------------------------
263 // Class : Instance
264 //
265 // Purpose : This class represents a single instance of the diode
266 // device. It mainly contains indices and pointers into
267 // the matrix equation (see the resistor instance class for
268 // more details).
269 //
270 // The diode will have 1 internal node, in addition to the
271 // nodes which are connected to it. This is so that it
272 // can be placed in series with a resistor that represents
273 // the resistance of intrinsic Si.
274 //
275 // Special Notes :
276 // Creator : Eric Keiter, Parallel Computational Sciences
277 // Creation Date : 02/28/00
278 //-----------------------------------------------------------------------------
279 class Instance : public DeviceInstance
280 {
281  friend class ParametricData<Instance>;
282  friend class Model;
283  friend class Traits;friend class Master;
284  friend class diodeSensitivity;
285 
286 public:
287  Instance(
288  const Configuration & configuration,
289  const InstanceBlock & instance_block,
290  Model & model,
291  const FactoryBlock & factory_block);
292 
293  ~Instance();
294 
295 private:
296  Instance(const Instance &);
297  Instance &operator=(const Instance &);
298 
299 public:
300  void registerLIDs( const std::vector<int> & intLIDVecRef,
301  const std::vector<int> & extLIDVecRef );
302  void registerStateLIDs( const std::vector<int> & staLIDVecRef );
303  void registerStoreLIDs( const std::vector<int> & stoLIDVecRef);
304  void registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef);
305  void loadNodeSymbols(Util::SymbolTable &symbol_table) const;
306 
307  const std::vector< std::vector<int> > & jacobianStamp() const;
308  void registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec );
309 
310  bool processParams ();
311  bool updateTemperature ( const double & temp = -999.0 );
312  bool lambertWCurrent (double Isat, double Vte, double RS);
313  bool lambertWBreakdownCurrent (double Isat, double Vte, double RS);
314  bool lambertWLinearReverseBias (double Isat, double Vte, double RS);
315 
316  bool updateIntermediateVars ();
317  bool updatePrimaryState ();
318 
319  int getNumNoiseSources () const;
320  void setupNoiseSources (Xyce::Analysis::NoiseData & noiseData);
321  void getNoiseSources (Xyce::Analysis::NoiseData & noiseData);
322 
323  // load functions, residual:
324  bool loadDAEQVector ();
325  bool loadDAEFVector ();
326 
327  // load functions, Jacobian:
328  bool loadDAEdQdx ();
329  bool loadDAEdFdx ();
330 
331  void setupPointers();
332 
333 public:
334  // iterator reference to the diode model which owns this instance.
335  // Getters and setters
337  {
338  return model_;
339  }
340 
341 private:
342  static std::vector< std::vector<int> > jacStamp_RS;
343  static std::vector< std::vector<int> > jacStamp;
344 
345  static std::vector<int> jacMap_RS;
346  static std::vector<int> jacMap;
347 
348  static std::vector< std::vector<int> > jacMap2_RS;
349  static std::vector< std::vector<int> > jacMap2;
350 
351 
352  Model & model_; //< Owning model
353 
354  int off;
355  double Area;
356  double InitCond;
357  double Temp;
360 
361  double tJctPot;
362  double tJctCap;
363  double tDepCap;
364  double tSatCur;
365  double tVcrit;
366  double tF1;
367  double tBrkdwnV;
368  double tSatCurR;
369  double tIKF;
370  double tRS;
371  double tCOND;
372  double tIRF;
373 
374  double Id; //diode current
375  double Gd; //diode conductivity
376  double Cd; //depletion capacitance
377  double Gcd; //dep cap conductivity
378  double Qd; //capacitor charge
379  double Icd; //capacitor current
380  double Gspr;
381  //double LeadCurrent;
382 
383  double Vpp;
384  double Vp;
385  double Vn;
386  double Vc;
387 
388  double Vd;
389  double Vd_old;
390  double Vd_orig;
391 
392  // end of intermediate variables
393 
394  // state variables:
395  double q0; // charge in the capacitor
396  double i0; // current throught the capacitor
397 
398  //local indices (offsets)
399  // int li_QState;
400 
401  // for voltage limiting
403 
404  // for lead current
406  int li_branch_data; ///< Index for Lead Current and junction voltage (for power calculations)
407 
408  int li_Pos;
409  int li_Neg;
410  int li_Pri;
411 
412  // Matrix equation local offset variables
420 
421 #ifndef Xyce_NONPOINTER_MATRIX_LOAD
422  // Matrix equation local pointer variables
430 
438 #endif
439 
440 
441  // Flags
444 };
445 
446 //-----------------------------------------------------------------------------
447 // Class : Model
448 // Purpose :
449 // Special Notes :
450 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
451 // Creation Date : 02/28/00
452 //-----------------------------------------------------------------------------
453 class Model : public DeviceModel
454 {
455  typedef std::vector<Instance *> InstanceVector;
456 
457  friend class ParametricData<Model>;
458  friend class Instance;
459  friend class Traits;friend class Master;
460  friend class diodeSensitivity;
461 
462 public:
463  Model(
464  const Configuration & configuration,
465  const ModelBlock & MB,
466  const FactoryBlock & factory_block);
467  ~Model();
468 
469 private:
470  Model();
471  Model(const Model &);
472  Model &operator=(const Model &);
473 
474 public:
475  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;
476 
477  virtual std::ostream &printOutInstances(std::ostream &os) const;
478  bool processParams ();
479  bool processInstanceParams ();
480 
481 
482 public:
483  void addInstance(Instance *instance)
484  {
485  instanceContainer.push_back(instance);
486  }
487 
488 private:
489  std::vector<Instance*> instanceContainer;
490 
491 private:
492 
493  double IS; // saturation current (A)
494  double RS; // ohmic resistance (ohms)
495  double COND; // corresponding conductance
496  double N; // emission coefficient
497  double ISR; // recombination saturation current (A)
498  double NR; // emission coefficient for ISR
499  double IKF; // high-injection knee current (A)
500  double TT; // transit time (sec)
501  double CJO; // zero-bias junction capacitance (F)
502  double VJ; // built-in junction potential (V)
503  double M; // grading coefficient
504  double EG; // activation energy (eV).
505  // For Si, EG = 1.11
506  // Ge, EG = 0.67
507  // Sbd, EG = 0.69
508  double XTI; // isaturation-current temp. exp
509  double TIKF; // IKF temperature coeff.
510  double TBV1; // BV linear temperature coeff.
511  double TBV2; // BV quadratic temperature coeff.
512  double TRS1; // RS linear temperature coeff.
513  double TRS2; // RS quadratic temperature coeff.
514  double FC; // coefficient for forward-bias depletion capacitance
515  // formula
516  double BV; // reverse breakdown voltage
517  double IBV; // current at breakdown voltage (A)
518  double IRF; // adjustment for linear portion of reverse current
519  double NBV; // reverse breakdown ideality factor
520  double IBVL; // low-level current at breakdown voltage (A)
521  double NBVL; // low-level reverse breakdown ideality factor
522  double F2;
523  double F3;
524  double TNOM; // parameter measurement temperature (C)
525  double KF; // flicker noise coefficient
526  double AF; // flicker noise exponent
527 
528  bool BVGiven;
529 };
530 
531 //-----------------------------------------------------------------------------
532 // Class : Master
533 // Purpose :
534 // Special Notes :
535 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
536 // Creation Date : 11/26/08
537 //-----------------------------------------------------------------------------
538 class Master : public DeviceMaster<Traits>
539 {
540  friend class Instance;
541  friend class Model;
542 
543 public:
545  const Configuration & configuration,
546  const FactoryBlock & factory_block,
547  const SolverState & ss1,
548  const DeviceOptions & do1)
549  : DeviceMaster<Traits>(configuration, factory_block, ss1, do1)
550  {}
551 
552  virtual bool updateState (double * solVec, double * staVec, double * stoVec);
553 
554  // new DAE stuff:
555  // new DAE load functions, residual:
556  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec, double * storeLeadF, double * storeLeadQ, double * leadF, double * leadQ, double * junctionV);
557 
558  // new DAE load functions, Jacobian:
559  virtual bool loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx);
560 };
561 
562 void registerDevice();
563 
564 } // namespace Diode
565 } // namespace Device
566 } // namespace Xyce
567 
568 #endif
569 
static std::vector< int > jacMap
Definition: N_DEV_Diode.h:346
static std::vector< int > jacMap_RS
Definition: N_DEV_Diode.h:345
bool lambertWBreakdownCurrent(double Isat, double Vte, double RS)
Definition: N_DEV_Diode.C:1773
Model & operator=(const Model &)
std::vector< Instance * > InstanceVector
Definition: N_DEV_Diode.h:455
static std::vector< std::vector< int > > jacStamp_RS
Definition: N_DEV_Diode.h:342
static const char * deviceTypeName()
Definition: N_DEV_Diode.h:102
Pure virtual class to augment a linear system.
void registerLIDs(const std::vector< int > &intLIDVecRef, const std::vector< int > &extLIDVecRef)
Definition: N_DEV_Diode.C:481
Master(const Configuration &configuration, const FactoryBlock &factory_block, const SolverState &ss1, const DeviceOptions &do1)
Definition: N_DEV_Diode.h:544
void registerStateLIDs(const std::vector< int > &staLIDVecRef)
Definition: N_DEV_Diode.C:570
Sacado::Fad::SFad< double, 1 > fadType
Definition: N_DEV_Diode.h:65
Base class for all parameters.
Definition: N_DEV_Pars.h:169
ScalarT Xycemax(ScalarT f1, ScalarT f2)
Definition: N_DEV_Diode.h:71
virtual void operator()(const ParameterBase &entity, const std::string &param, std::vector< double > &dfdp, std::vector< double > &dqdp, std::vector< double > &dbdp, std::vector< int > &Findices, std::vector< int > &Qindices, std::vector< int > &Bindices) const
Definition: N_DEV_Diode.C:2885
bool processParams(ScalarT &M, ScalarT &EG, ScalarT &FC, const ScalarT &RS, ScalarT &COND, ScalarT &F2, ScalarT &F3)
Definition: N_DEV_Diode.C:2235
Instance(const Configuration &configuration, const InstanceBlock &instance_block, Model &model, const FactoryBlock &factory_block)
Definition: N_DEV_Diode.C:346
Instance & operator=(const Instance &)
static void loadModelParameters(ParametricData< Model > &model_parameters)
Definition: N_DEV_Diode.C:94
void registerBranchDataLIDs(const std::vector< int > &branchLIDVecRef)
In addition to state vector, Xyce maintains a separate datastructure called a "branch data" vector...
Definition: N_DEV_Diode.C:622
std::vector< Instance * > instanceContainer
Definition: N_DEV_Diode.h:489
DeviceMaster instantiates a device as described by the device traits T.
static diodeSensitivity diodeSens
Definition: N_DEV_Diode.h:97
The FactoryBlock contains parameters needed by the device, instance and model creation functions...
general sensitivity functor for all model params.
Definition: N_DEV_Diode.h:77
bool updateTemperature(const double &temp=-999.0)
Definition: N_DEV_Diode.C:1418
void getNoiseSources(Xyce::Analysis::NoiseData &noiseData)
Definition: N_DEV_Diode.C:961
bool processInstanceParams()
processInstanceParams
Definition: N_DEV_Diode.C:1878
static std::vector< std::vector< int > > jacStamp
Definition: N_DEV_Diode.h:343
The Device class is an interface for device implementations.
Definition: N_DEV_Device.h:101
void loadNodeSymbols(Util::SymbolTable &symbol_table) const
Populates and returns the store name map.
Definition: N_DEV_Diode.C:548
bool processParams()
processParams
Definition: N_DEV_Diode.C:1847
static const char * name()
Definition: N_DEV_Diode.h:101
const std::vector< std::vector< int > > & jacobianStamp() const
Definition: N_DEV_Diode.C:641
bool lambertWLinearReverseBias(double Isat, double Vte, double RS)
Definition: N_DEV_Diode.C:1720
virtual std::ostream & printOutInstances(std::ostream &os) const
Definition: N_DEV_Diode.C:2021
void setupNoiseSources(Xyce::Analysis::NoiseData &noiseData)
Definition: N_DEV_Diode.C:928
Class Configuration contains device configuration data.
static std::vector< std::vector< int > > jacMap2_RS
Definition: N_DEV_Diode.h:348
bool updateIntermediateVars(const ScalarT &Vp, const ScalarT &Vpp, const ScalarT &Vn, const ScalarT &Vd, const ScalarT &Temp, const ScalarT &tJctCap, const ScalarT &tJctPot, const ScalarT &tDepCap, const ScalarT &tF1, const ScalarT &tSatCur, const ScalarT &tSatCurR, const ScalarT &tVcrit, const ScalarT &tRS, const ScalarT &tCOND, const ScalarT &tIRF, const ScalarT &tIKF, const ScalarT &tBrkdwnV, const ScalarT &Area, const int &lambertWFlag, const double &gmin, const ScalarT M, const ScalarT BV, const ScalarT IBV, const ScalarT NBV, const ScalarT IBVL, const ScalarT NBVL, const ScalarT N, const ScalarT NR, const ScalarT TT, const ScalarT F2, const ScalarT F3, const int level, ScalarT &Id, ScalarT &Gd, ScalarT &Qd, ScalarT &Cd, ScalarT &Gspr)
Definition: N_DEV_Diode.C:2525
#define M
static Device * factory(const Configuration &configuration, const FactoryBlock &factory_block)
Definition: N_DEV_Diode.C:2204
static bool isLinearDevice()
Definition: N_DEV_Diode.h:105
virtual bool loadDAEMatrices(Linear::Matrix &dFdx, Linear::Matrix &dQdx)
Populates the device's Jacobian object with these pointers.
Definition: N_DEV_Diode.C:2163
virtual bool updateState(double *solVec, double *staVec, double *stoVec)
Updates the devices state information.
Definition: N_DEV_Diode.C:2082
#define RS
static void loadInstanceParameters(ParametricData< Instance > &instance_parameters)
Definition: N_DEV_Diode.C:70
static std::vector< std::vector< int > > jacMap2
Definition: N_DEV_Diode.h:349
Base sensitivity functor.
Definition: N_DEV_Pars.h:148
ModelBlock represents a .MODEL line from the netlist.
bool lambertWCurrent(double Isat, double Vte, double RS)
Definition: N_DEV_Diode.C:1644
The DeviceTraits template describes the configuration of a device.
Manages parameter binding for class C.
Definition: N_DEV_Pars.h:214
InstanceBlock represent a device instance line from the netlist.
void registerJacLIDs(const std::vector< std::vector< int > > &jacLIDVec)
Definition: N_DEV_Diode.C:657
bool applyLimiters(DeviceSupport &devSupport, const ScalarT &Vp, const ScalarT &Vpp, const ScalarT &Vn, const ScalarT &tVcrit, ScalarT &Vd, ScalarT &Vd_orig, ScalarT &Vd_old, const ScalarT &currVd_old, const ScalarT &nextVd_old, const double InitCond, const bool InitCondGiven, const bool BVGiven, const int off, bool &origFlag, const bool dotICapplies, const int &newtonIter, const bool initJctFlag, const bool voltageLimiterFlag, const bool dcopFlag, const bool locaEnabledFlag)
virtual void forEachInstance(DeviceInstanceOp &op) const
Apply a device instance "op" to all instances associated with this model.
Definition: N_DEV_Diode.C:2063
void addInstance(Instance *instance)
Definition: N_DEV_Diode.h:483
int li_branch_data
Index for Lead Current and junction voltage (for power calculations)
Definition: N_DEV_Diode.h:406
ScalarT Xycemin(ScalarT f1, ScalarT f2)
Definition: N_DEV_Diode.h:74
virtual bool loadDAEVectors(double *solVec, double *fVec, double *qVec, double *bVec, double *storeLeadF, double *storeLeadQ, double *leadF, double *leadQ, double *junctionV)
Populates the device's ExternData object with these pointers.
Definition: N_DEV_Diode.C:2105
bool updateTemperature( ScalarT &Temp, ScalarT &tJctCap, ScalarT &tJctPot, ScalarT &tDepCap, ScalarT &tF1, ScalarT &tSatCur, ScalarT &tSatCurR, ScalarT &tVcrit, ScalarT &tRS, ScalarT &tCOND, ScalarT &tIRF, ScalarT &tIKF, ScalarT &tBrkdwnV, const ScalarT &TNOM, const ScalarT &VJ, const ScalarT &CJO, const ScalarT &M, const ScalarT &N, const ScalarT &IS, const ScalarT &EG, const ScalarT &XTI, const ScalarT &RS, const ScalarT &COND, const ScalarT &IRF, const ScalarT &NR, const ScalarT &IKF, const ScalarT &TIKF, const ScalarT &ISR, const ScalarT &IBV, const ScalarT &BV, const bool &BVGiven, const ScalarT &TBV1, const ScalarT &TBV2, const ScalarT &TRS1, const ScalarT &TRS2, const ScalarT &FC, const int level)
void registerStoreLIDs(const std::vector< int > &stoLIDVecRef)
Definition: N_DEV_Diode.C:586