Xyce  6.1
N_DEV_LTRA.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_LTRA.h,v $
27 //
28 // Purpose : Transmission line.
29 //
30 // Special Notes :
31 //
32 // Creator : Eric R. Keiter, SNL
33 //
34 // Creation Date : 06/16/10
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.47.2.1 $
40 //
41 // Revision Date : $Date: 2015/04/02 18:20:11 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-----------------------------------------------------------------------------
45 
46 #ifndef Xyce_N_DEV_LTRA_h
47 #define Xyce_N_DEV_LTRA_h
48 
49 // ---------- Xyce Includes ----------
50 #include <N_UTL_fwd.h>
51 
52 #include <N_DEV_Configuration.h>
53 #include <N_DEV_DeviceMaster.h>
54 #include <N_DEV_DeviceInstance.h>
55 #include <N_DEV_DeviceModel.h>
56 
57 // device parameters
58 #define LTRA_MOD_LTRA 0
59 #define LTRA_MOD_R 1
60 #define LTRA_MOD_L 2
61 #define LTRA_MOD_G 3
62 #define LTRA_MOD_C 4
63 #define LTRA_MOD_LEN 5
64 #define LTRA_V1 6
65 #define LTRA_I1 7
66 #define LTRA_V2 8
67 #define LTRA_I2 9
68 #define LTRA_IC 10
69 #define LTRA_MOD_RELTOL 11
70 #define LTRA_MOD_ABSTOL 12
71 #define LTRA_POS_NODE1 13
72 #define LTRA_NEG_NODE1 14
73 #define LTRA_POS_NODE2 15
74 #define LTRA_NEG_NODE2 16
75 #define LTRA_INPUT1 17
76 #define LTRA_INPUT2 18
77 #define LTRA_DELAY 19
78 #define LTRA_BR_EQ1 20
79 #define LTRA_BR_EQ2 21
80 #define LTRA_MOD_NL 22
81 #define LTRA_MOD_FREQ 23
82 
83 #define LTRA_MOD_FULLCONTROL 26
84 #define LTRA_MOD_HALFCONTROL 27
85 #define LTRA_MOD_NOCONTROL 28
86 #define LTRA_MOD_PRINT 29
87 #define LTRA_MOD_NOPRINT 30
88 
89 #define LTRA_MOD_STEPLIMIT 32
90 #define LTRA_MOD_NOSTEPLIMIT 33
91 #define LTRA_MOD_LININTERP 34
92 #define LTRA_MOD_QUADINTERP 35
93 #define LTRA_MOD_MIXEDINTERP 36
94 #define LTRA_MOD_RLC 37
95 #define LTRA_MOD_RC 38
96 #define LTRA_MOD_RG 39
97 #define LTRA_MOD_LC 40
98 #define LTRA_MOD_RL 41
99 #define LTRA_MOD_STLINEREL 42
100 #define LTRA_MOD_STLINEABS 43
101 #define LTRA_MOD_CHOPREL 44
102 #define LTRA_MOD_CHOPABS 45
103 #define LTRA_MOD_TRUNCNR 46
104 #define LTRA_MOD_TRUNCDONTCUT 47
105 
106 namespace Xyce {
107 namespace Device {
108 namespace LTRA {
109 
110 class Model;
111 class Instance;
112 
113 struct Traits : public DeviceTraits<Model, Instance>
114 {
115  static const char *name() {return "Lossy Transmission Line";}
116  static const char *deviceTypeName() {return "O level 1";}
117  static int numNodes() {return 4;}
118  static bool modelRequired() {return true;}
119  static bool isLinearDevice() {return true;}
120 
121  static Device *factory(const Configuration &configuration, const FactoryBlock &factory_block);
122  static void loadModelParameters(ParametricData<Model> &model_parameters);
123  static void loadInstanceParameters(ParametricData<Instance> &instance_parameters);
124 };
125 
126 //-----------------------------------------------------------------------------
127 // Class : Instance
128 // Purpose :
129 // Special Notes :
130 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
131 // Creation Date : 3/16/00
132 //-----------------------------------------------------------------------------
133 class Instance : public DeviceInstance
134 {
135  friend class ParametricData<Instance>;
136  friend class Model;
137  friend class Traits;friend class Master;
138 
139 public:
140  Instance(
141  const Configuration & configuration,
142  const InstanceBlock & instance_block,
143  Model & model,
144  const FactoryBlock & factory_block);
145 
146  ~Instance();
147 
148 private:
149  Instance(const Instance &);
150  Instance &operator=(const Instance &);
151 
152 public:
153  void registerLIDs( const std::vector<int> & intLIDVecRef,
154  const std::vector<int> & extLIDVecRef );
155  void registerStateLIDs( const std::vector<int> & staLIDVecRef );
156 
157  void loadNodeSymbols(Util::SymbolTable &symbol_table) const; // override
158 
159  const std::vector< std::vector<int> > & jacobianStamp() const;
160  void registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec );
161 
162  bool processParams ();
163  bool updateIntermediateVars ();
164  bool updatePrimaryState ();
165  bool updateSecondaryState ();
166 
167  bool loadDAEQVector () {return true;}
168  bool loadDAEFVector ();
169 
170  bool loadDAEdQdx () {return true;}
171  bool loadDAEdFdx ();
172 
173  void setupPointers();
174 
175  bool getInstanceBreakPoints (std::vector<Util::BreakPoint> &breakPointTimes);
176  void acceptStep();
177 
178  double getMaxTimeStepSize();
179 
181  bool setInternalState( const DeviceState & state );
182  bool setIC();
183 
184 public:
186  {
187  return model_;
188  }
189 
190 private:
191  static std::vector< std::vector<int> > jacStamp;
192 
193  Model & model_; //< Owning model
194 
195  void calculateMaxTimeStep_(void); // Calculate a maximum time step size to minimize errors
196 
197  double input1; // accumulated excitation for port 1
198  double input2; // accumulated excitation for port 2
199 
200  double currp1; // Current at port 1
201  double currp2; // Current at port 2
202 
203  double vpos1; // Voltage at port 1 positive node
204  double vneg1; // Voltage at port 1 negative node
205 
206  double vpos2; // Voltage at port 2 positive node
207  double vneg2; // Voltage at port 2 negative node
208 
209  double initVolt1; // initial condition: voltage on port 1
210  double initVolt2; // initial condition: voltage on port 2
211 
212  double initCur1; // initial condition: current at port 1
213  double initCur2; // initial condition: current at port 2
214 
215  std::vector<double> v1; // past values of voltage at port 1
216  std::vector<double> v2; // past values of voltage at port 2
217 
218  std::vector<double> i1; // past values of current at port 1
219  std::vector<double> i2; // past values of current at port 2
220 
221  size_t listSize; // Size of variables vectors above
222 
225 
228 
229  // local indices (offsets)
230  int li_Pos1;
231  int li_Neg1;
232 
233  int li_Pos2;
234  int li_Neg2;
235 
236  int li_Ibr1;
237  int li_Ibr2;
238 
239  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
240  // Matrix elements
241  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
242 
243  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
244  // Matrix equation offset variables
245  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
246  // Positive Node1
249  // Negative Node1
252  // Positive Node2
255  // Negative Node1
258  // Branch1 equation due to Jajeet LTRA
265  // Branch2 equation due to Jajeet LTRA
272 
273  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
274  // Entries in matrix corresponding to offsets above
275  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
276  double *pos1Pos1Ptr;
277  double *pos1Ibr1Ptr;
278 
279  double *neg1Neg1Ptr;
280  double *neg1Ibr1Ptr;
281 
282  double *pos2Pos2Ptr;
283  double *pos2Ibr2Ptr;
284 
285  double *neg2Neg2Ptr;
286  double *neg2Ibr2Ptr;
287 
288  double *ibr1Pos1Ptr;
289  double *ibr1Neg1Ptr;
290  double *ibr1Pos2Ptr;
291  double *ibr1Neg2Ptr;
292  double *ibr1Ibr1Ptr;
293  double *ibr1Ibr2Ptr;
294 
295  double *ibr2Pos1Ptr;
296  double *ibr2Neg1Ptr;
297  double *ibr2Pos2Ptr;
298  double *ibr2Neg2Ptr;
299  double *ibr2Ibr1Ptr;
300  double *ibr2Ibr2Ptr;
301 
303 
306 };
307 
308 //-----------------------------------------------------------------------------
309 // Class : Model
310 // Purpose :
311 // Special Notes :
312 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
313 // Creation Date : 3/16/00
314 //-----------------------------------------------------------------------------
315 class Model : public DeviceModel
316 {
317  typedef std::vector<Instance *> InstanceVector;
318 
319  friend class ParametricData<Model>;
320  friend class Instance;
321  friend class Traits;friend class Master;
322 
323 public:
324  Model(
325  const Configuration & configuration,
326  const ModelBlock & MB,
327  const FactoryBlock & factory_block);
328  ~Model();
329 
330 private:
331  Model();
332  Model(const Model &);
333  Model &operator=(const Model &);
334 
335 public:
336  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;
337 
338  virtual std::ostream &printOutInstances(std::ostream &os) const;
339  bool processParams ();
340  bool processInstanceParams ();
341 
342 private:
343 
344  int quadInterp_ (double t, double t1, double t2, double t3, double& c1, double& c2, double& c3);
345  int linInterp_ (double t, double t1, double t2, double& c1, double& c2);
346  double intlinfunc_ (double lolimit, double hilimit,
347  double lovalue, double hivalue,
348  double t1, double t2);
349  double twiceintlinfunc_(double lolimit, double hilimit,
350  double otherlolimit, double lovalue,
351  double hivalue, double t1, double t2);
352  double thriceintlinfunc_(double lolimit, double hilimit,
353  double secondlolimit, double thirdlolimit,
354  double lovalue, double hivalue,
355  double t1, double t2);
356 
357  bool modelCalculations_(int& isaved, double& qf1, double& qf2, double& qf3,
358  double& lf2, double& lf3);
359 
360  // from numerical recipies in C:
361  double bessI0_(double x);
362  double bessI1_(double x);
363  double bessI1xOverX_(double x);
364 
365  double rlcH1dashFunc_(double time, double T, double alpha, double beta);
366  double rlcH2Func_(double time, double T, double alpha, double beta);
367  double rlcH3dashFunc_(double time, double T, double alpha, double beta);
368  double rlcH1dashTwiceIntFunc_(double time, double beta);
369  double rlcH3dashIntFunc_(double time, double T, double beta);
370  double rcH1dashTwiceIntFunc_(double time, double cbyr);
371  double rcH2TwiceIntFunc_(double time, double rclsqr);
372 
373  double rcH3dashTwiceIntFunc_(double time, double cbyr, double rclsqr);
374 
375  // coefficient setups:
376  void rcCoeffsSetup_(
377  double & h1dashfirstcoeff,
378  double & h2firstcoeff,
379  double & h3dashfirstcoeff,
380  std::vector<double> & h1dashcoeffs,
381  std::vector<double> & h2coeffs,
382  std::vector<double> & h3dashcoeffs,
383  size_t listsize, double cbyr, double rclsqr, double curtime,
384  const std::vector<double> & timelist, int timeindex, double reltol);
385 
386  void rlcCoeffsSetup_(
387  double & h1dashfirstcoeff, double & h2firstcoeff, double & h3dashfirstcoeff,
388  std::vector<double> & h1dashcoeffs, std::vector<double> & h2coeffs, std::vector<double> & h3dashcoeffs,
389  size_t listsize, double T, double alpha, double beta, double curtime,
390  const std::vector<double> & timelist, int timeindex, double reltol, int *auxindexptr);
391 
392  bool straightLineCheck_(double x1, double y1,
393  double x2, double y2,
394  double x3, double y3,
395  double reltol, double abstol);
396 
397 
398 
399  double lteCalculate_ ( Instance & instance,
400  double curtime );
401 
402  double SECONDDERIV_(int i, double a, double b, double c);
403 
404 
405 public:
406  void addInstance(Instance *instance)
407  {
408  instanceContainer.push_back(instance);
409  }
410 
411 private:
412  std::vector<Instance*> instanceContainer;
413 
414 private:
415 
416 
417  double h1dashFirstVal; // first needed value of h1dasg at current timepoint
418  double h2FirstVal; // first needed value of h2 at current timepoint
419  double h3dashFirstVal; // first needed value of h3dash at current timepoint
420 
421  double h1dashFirstCoeff; // first needed coeff of h1dash for the current timepoint
422  double h2FirstCoeff; // first needed coeff of h2 for the current timepoint
423  double h3dashFirstCoeff; // first needed coeff of h3dash for the current timepoint
424 
425  std::vector<double> h1dashCoeffs; // list of other coefficients for h1dash
426  std::vector<double> h2Coeffs; // list of other coefficients for h2
427  std::vector<double> h3dashCoeffs; // list of other coefficients for h3dash
428 
429  size_t listSize; // size of above lists
430 
431  // input parameters:
432  double resist;
433  double induct;
434  double conduct;
435  double capac;
436  double length;
437  double reltol;
438  double abstol;
439 
440  bool noStepLimit; // Don't limit step size to less than line delay
441  bool stepLimit; // Do limit step size to less than line delay
443  // (These could be combined into a single
444  // bool, but preserving spice3 compatibility)
445 
446  bool linInterp;
449 
450  double stLineReltol;
451  double stLineAbstol;
452 
453  bool lteTimeStepControl; // indicates whether full time step
454  // control using local-truncation
455  // error estimation is performed
456 
457  bool truncNR;
459 
477 
478  // calculated parameters
479  double td; // propagation delay T - calculated
480  double imped; // impedance Z - calculated
481  double admit; // admittance Y - calculated
482  double alpha; // alpha - calculated
483  double beta; // beta - calculated
484  double attenuation; // e^(-beta T) - calculated
485  double cByR; // C/R - for the RC line - calculated
486  double rclsqr; // RCl^2 - for the RC line - calculated
487  double intH1dash; // \int_0^\inf h'_1(\tau) d \tau - calculated
488  double intH2; // \int_0^\inf h_2(\tau) d \tau - calculated
489  double intH3dash; // \int_0^\inf h'_3(\tau) d \tau - calculated
490 
491  double coshlrootGR; // cosh(l*sqrt(G*R)), used for DC analysis
492  double rRsLrGRorG; // sqrt(R)*sinh(l*sqrt(G*R))/sqrt(G)
493  double rGsLrGRorR; // sqrt(G)*sinh(l*sqrt(G*R))/sqrt(R)
494 
495  int auxIndex; // auxiliary index for h2 and h3dash
496  double chopReltol; // separate reltol for truncation of impulse responses
497  double chopAbstol; // separate abstol for truncation of impulse responses
498 
499  double maxSafeStep; // maximum safe step for impulse response calculations
500  double maxTimeStep; // maximum time step to be used
501  int howToInterp; // indicates how to interpolate for delayed timepoint
502  bool printFlag; // flag to indicate whether debugging output should be printed
503 
504  int specialCase; // what kind of model (RC, RLC, RL, ...)
505 
506  bool tdover;
507 
508  bool restartStoredFlag; // flag to indicate if this particular model has
509  // been saved to the restart file already (restart
510  // functions are instance functions, so the potential
511  // exists for storing same model multiple times.)
512 };
513 
514 //-----------------------------------------------------------------------------
515 // Class : Master
516 // Purpose :
517 // Special Notes :
518 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
519 // Creation Date : 11/26/08
520 //-----------------------------------------------------------------------------
521 class Master : public DeviceMaster<Traits>
522 {
523  friend class Instance;
524  friend class Model;
525 
526 public:
528  const Configuration & configuration,
529  const FactoryBlock & factory_block,
530  const SolverState & ss1,
531  const DeviceOptions & do1)
532  : DeviceMaster<Traits>(configuration, factory_block, ss1, do1),
533  vars_initialized(false)
534  {}
535 
536  virtual bool updateState (double * solVec, double * staVec, double * stoVec);
537  virtual bool updateSecondaryState (double * staDeriv, double * stoVec) {return true;}
538 
539  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec, double * storeLeadF, double * storeLeadQ, double * leadF, double * leadQ, double * junctionV);
540  virtual bool loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx);
541 
542 private:
544 
545  void initialize_vars_();
546 };
547 
548 void registerDevice();
549 
550 } // namespace LTRA
551 } // namespace Device
552 } // namespace Xyce
553 
554 #endif
bool modelCalculations_(int &isaved, double &qf1, double &qf2, double &qf3, double &lf2, double &lf3)
Definition: N_DEV_LTRA.C:1415
double rlcH3dashFunc_(double time, double T, double alpha, double beta)
Definition: N_DEV_LTRA.C:2002
virtual std::ostream & printOutInstances(std::ostream &os) const
Definition: N_DEV_LTRA.C:1363
double thriceintlinfunc_(double lolimit, double hilimit, double secondlolimit, double thirdlolimit, double lovalue, double hivalue, double t1, double t2)
Definition: N_DEV_LTRA.C:1809
static void loadModelParameters(ParametricData< Model > &model_parameters)
Definition: N_DEV_LTRA.C:94
void rlcCoeffsSetup_(double &h1dashfirstcoeff, double &h2firstcoeff, double &h3dashfirstcoeff, std::vector< double > &h1dashcoeffs, std::vector< double > &h2coeffs, std::vector< double > &h3dashcoeffs, size_t listsize, double T, double alpha, double beta, double curtime, const std::vector< double > &timelist, int timeindex, double reltol, int *auxindexptr)
Definition: N_DEV_LTRA.C:2319
bool getInstanceBreakPoints(std::vector< Util::BreakPoint > &breakPointTimes)
Definition: N_DEV_LTRA.C:641
double rcH2TwiceIntFunc_(double time, double rclsqr)
Definition: N_DEV_LTRA.C:2099
static std::vector< std::vector< int > > jacStamp
Definition: N_DEV_LTRA.h:191
bool setInternalState(const DeviceState &state)
Definition: N_DEV_LTRA.C:1119
const std::vector< std::vector< int > > & jacobianStamp() const
Definition: N_DEV_LTRA.C:462
std::vector< double > v1
Definition: N_DEV_LTRA.h:215
DeviceState * getInternalState()
Definition: N_DEV_LTRA.C:1041
Pure virtual class to augment a linear system.
static const char * deviceTypeName()
Definition: N_DEV_LTRA.h:116
void registerLIDs(const std::vector< int > &intLIDVecRef, const std::vector< int > &extLIDVecRef)
Definition: N_DEV_LTRA.C:379
void registerStateLIDs(const std::vector< int > &staLIDVecRef)
Definition: N_DEV_LTRA.C:449
static const char * name()
Definition: N_DEV_LTRA.h:115
std::vector< double > v2
Definition: N_DEV_LTRA.h:216
std::vector< double > h1dashCoeffs
Definition: N_DEV_LTRA.h:425
static void loadInstanceParameters(ParametricData< Instance > &instance_parameters)
Definition: N_DEV_LTRA.C:71
Model & operator=(const Model &)
double rcH3dashTwiceIntFunc_(double time, double cbyr, double rclsqr)
Definition: N_DEV_LTRA.C:2132
bool straightLineCheck_(double x1, double y1, double x2, double y2, double x3, double y3, double reltol, double abstol)
Definition: N_DEV_LTRA.C:2562
Instance & operator=(const Instance &)
double rlcH3dashIntFunc_(double time, double T, double beta)
Definition: N_DEV_LTRA.C:2065
double bessI1_(double x)
Definition: N_DEV_LTRA.C:1881
DeviceMaster instantiates a device as described by the device traits T.
double rcH1dashTwiceIntFunc_(double time, double cbyr)
Definition: N_DEV_LTRA.C:2086
The FactoryBlock contains parameters needed by the device, instance and model creation functions...
double twiceintlinfunc_(double lolimit, double hilimit, double otherlolimit, double lovalue, double hivalue, double t1, double t2)
Definition: N_DEV_LTRA.C:1772
virtual bool loadDAEMatrices(Linear::Matrix &dFdx, Linear::Matrix &dQdx)
Populates the device's Jacobian object with these pointers.
Definition: N_DEV_LTRA.C:3700
static bool modelRequired()
Definition: N_DEV_LTRA.h:118
double bessI0_(double x)
Definition: N_DEV_LTRA.C:1849
std::vector< double > i2
Definition: N_DEV_LTRA.h:219
Master(const Configuration &configuration, const FactoryBlock &factory_block, const SolverState &ss1, const DeviceOptions &do1)
Definition: N_DEV_LTRA.h:527
Instance(const Configuration &configuration, const InstanceBlock &instance_block, Model &model, const FactoryBlock &factory_block)
Definition: N_DEV_LTRA.C:193
The Device class is an interface for device implementations.
Definition: N_DEV_Device.h:101
double bessI1xOverX_(double x)
Definition: N_DEV_LTRA.C:1913
void registerJacLIDs(const std::vector< std::vector< int > > &jacLIDVec)
Definition: N_DEV_LTRA.C:475
double lteCalculate_(Instance &instance, double curtime)
Definition: N_DEV_LTRA.C:2633
Class Configuration contains device configuration data.
std::vector< Instance * > InstanceVector
Definition: N_DEV_LTRA.h:317
void loadNodeSymbols(Util::SymbolTable &symbol_table) const
Populates and returns the store name map.
Definition: N_DEV_LTRA.C:435
int quadInterp_(double t, double t1, double t2, double t3, double &c1, double &c2, double &c3)
Definition: N_DEV_LTRA.C:1625
virtual bool updateSecondaryState(double *staDeriv, double *stoVec)
Updates the devices secondary state information.
Definition: N_DEV_LTRA.h:537
bool processInstanceParams()
processInstanceParams
Definition: N_DEV_LTRA.C:1210
void rcCoeffsSetup_(double &h1dashfirstcoeff, double &h2firstcoeff, double &h3dashfirstcoeff, std::vector< double > &h1dashcoeffs, std::vector< double > &h2coeffs, std::vector< double > &h3dashcoeffs, size_t listsize, double cbyr, double rclsqr, double curtime, const std::vector< double > &timelist, int timeindex, double reltol)
Definition: N_DEV_LTRA.C:2163
virtual void forEachInstance(DeviceInstanceOp &op) const
Apply a device instance "op" to all instances associated with this model.
Definition: N_DEV_LTRA.C:1400
double rlcH1dashTwiceIntFunc_(double time, double beta)
Definition: N_DEV_LTRA.C:2038
static Device * factory(const Configuration &configuration, const FactoryBlock &factory_block)
Definition: N_DEV_LTRA.C:3859
double SECONDDERIV_(int i, double a, double b, double c)
Definition: N_DEV_LTRA.C:2615
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_LTRA.C:3167
std::vector< double > h2Coeffs
Definition: N_DEV_LTRA.h:426
double intlinfunc_(double lolimit, double hilimit, double lovalue, double hivalue, double t1, double t2)
Definition: N_DEV_LTRA.C:1743
std::vector< double > h3dashCoeffs
Definition: N_DEV_LTRA.h:427
ModelBlock represents a .MODEL line from the netlist.
The DeviceTraits template describes the configuration of a device.
double rlcH2Func_(double time, double T, double alpha, double beta)
Definition: N_DEV_LTRA.C:1970
Manages parameter binding for class C.
Definition: N_DEV_Pars.h:214
InstanceBlock represent a device instance line from the netlist.
std::vector< Instance * > instanceContainer
Definition: N_DEV_LTRA.h:412
bool processParams()
processParams
Definition: N_DEV_LTRA.C:1196
std::vector< double > i1
Definition: N_DEV_LTRA.h:218
int linInterp_(double t, double t1, double t2, double &c1, double &c2)
Definition: N_DEV_LTRA.C:1702
double rlcH1dashFunc_(double time, double T, double alpha, double beta)
Definition: N_DEV_LTRA.C:1944
virtual bool updateState(double *solVec, double *staVec, double *stoVec)
Updates the devices state information.
Definition: N_DEV_LTRA.C:2933
void addInstance(Instance *instance)
Definition: N_DEV_LTRA.h:406
static bool isLinearDevice()
Definition: N_DEV_LTRA.h:119