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.49 $
40 //
41 // Revision Date : $Date: 2015/04/08 19:18:24 $
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  bool isLinearDevice() const { return true; }
154 
155  void registerLIDs( const std::vector<int> & intLIDVecRef,
156  const std::vector<int> & extLIDVecRef );
157  void registerStateLIDs( const std::vector<int> & staLIDVecRef );
158 
159  void loadNodeSymbols(Util::SymbolTable &symbol_table) const; // override
160 
161  const std::vector< std::vector<int> > & jacobianStamp() const;
162  void registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec );
163 
164  bool processParams ();
165  bool updateIntermediateVars ();
166  bool updatePrimaryState ();
167  bool updateSecondaryState ();
168 
169  bool loadDAEQVector () {return true;}
170  bool loadDAEFVector ();
171 
172  bool loadDAEdQdx () {return true;}
173  bool loadDAEdFdx ();
174 
175  void setupPointers();
176 
177  bool getInstanceBreakPoints (std::vector<Util::BreakPoint> &breakPointTimes);
178  void acceptStep();
179 
180  double getMaxTimeStepSize();
181 
183  bool setInternalState( const DeviceState & state );
184  bool setIC();
185 
186 public:
188  {
189  return model_;
190  }
191 
192 private:
193  static std::vector< std::vector<int> > jacStamp;
194 
195  Model & model_; //< Owning model
196 
197  void calculateMaxTimeStep_(void); // Calculate a maximum time step size to minimize errors
198 
199  double input1; // accumulated excitation for port 1
200  double input2; // accumulated excitation for port 2
201 
202  double currp1; // Current at port 1
203  double currp2; // Current at port 2
204 
205  double vpos1; // Voltage at port 1 positive node
206  double vneg1; // Voltage at port 1 negative node
207 
208  double vpos2; // Voltage at port 2 positive node
209  double vneg2; // Voltage at port 2 negative node
210 
211  double initVolt1; // initial condition: voltage on port 1
212  double initVolt2; // initial condition: voltage on port 2
213 
214  double initCur1; // initial condition: current at port 1
215  double initCur2; // initial condition: current at port 2
216 
217  std::vector<double> v1; // past values of voltage at port 1
218  std::vector<double> v2; // past values of voltage at port 2
219 
220  std::vector<double> i1; // past values of current at port 1
221  std::vector<double> i2; // past values of current at port 2
222 
223  size_t listSize; // Size of variables vectors above
224 
227 
230 
231  // local indices (offsets)
232  int li_Pos1;
233  int li_Neg1;
234 
235  int li_Pos2;
236  int li_Neg2;
237 
238  int li_Ibr1;
239  int li_Ibr2;
240 
241  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
242  // Matrix elements
243  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
244 
245  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
246  // Matrix equation offset variables
247  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
248  // Positive Node1
251  // Negative Node1
254  // Positive Node2
257  // Negative Node1
260  // Branch1 equation due to Jajeet LTRA
267  // Branch2 equation due to Jajeet LTRA
274 
275  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
276  // Entries in matrix corresponding to offsets above
277  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
278  double *pos1Pos1Ptr;
279  double *pos1Ibr1Ptr;
280 
281  double *neg1Neg1Ptr;
282  double *neg1Ibr1Ptr;
283 
284  double *pos2Pos2Ptr;
285  double *pos2Ibr2Ptr;
286 
287  double *neg2Neg2Ptr;
288  double *neg2Ibr2Ptr;
289 
290  double *ibr1Pos1Ptr;
291  double *ibr1Neg1Ptr;
292  double *ibr1Pos2Ptr;
293  double *ibr1Neg2Ptr;
294  double *ibr1Ibr1Ptr;
295  double *ibr1Ibr2Ptr;
296 
297  double *ibr2Pos1Ptr;
298  double *ibr2Neg1Ptr;
299  double *ibr2Pos2Ptr;
300  double *ibr2Neg2Ptr;
301  double *ibr2Ibr1Ptr;
302  double *ibr2Ibr2Ptr;
303 
305 
308 };
309 
310 //-----------------------------------------------------------------------------
311 // Class : Model
312 // Purpose :
313 // Special Notes :
314 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
315 // Creation Date : 3/16/00
316 //-----------------------------------------------------------------------------
317 class Model : public DeviceModel
318 {
319  typedef std::vector<Instance *> InstanceVector;
320 
321  friend class ParametricData<Model>;
322  friend class Instance;
323  friend class Traits;friend class Master;
324 
325 public:
326  Model(
327  const Configuration & configuration,
328  const ModelBlock & MB,
329  const FactoryBlock & factory_block);
330  ~Model();
331 
332 private:
333  Model();
334  Model(const Model &);
335  Model &operator=(const Model &);
336 
337 public:
338  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;
339 
340  virtual std::ostream &printOutInstances(std::ostream &os) const;
341  bool processParams ();
342  bool processInstanceParams ();
343 
344 private:
345 
346  int quadInterp_ (double t, double t1, double t2, double t3, double& c1, double& c2, double& c3);
347  int linInterp_ (double t, double t1, double t2, double& c1, double& c2);
348  double intlinfunc_ (double lolimit, double hilimit,
349  double lovalue, double hivalue,
350  double t1, double t2);
351  double twiceintlinfunc_(double lolimit, double hilimit,
352  double otherlolimit, double lovalue,
353  double hivalue, double t1, double t2);
354  double thriceintlinfunc_(double lolimit, double hilimit,
355  double secondlolimit, double thirdlolimit,
356  double lovalue, double hivalue,
357  double t1, double t2);
358 
359  bool modelCalculations_(int& isaved, double& qf1, double& qf2, double& qf3,
360  double& lf2, double& lf3);
361 
362  // from numerical recipies in C:
363  double bessI0_(double x);
364  double bessI1_(double x);
365  double bessI1xOverX_(double x);
366 
367  double rlcH1dashFunc_(double time, double T, double alpha, double beta);
368  double rlcH2Func_(double time, double T, double alpha, double beta);
369  double rlcH3dashFunc_(double time, double T, double alpha, double beta);
370  double rlcH1dashTwiceIntFunc_(double time, double beta);
371  double rlcH3dashIntFunc_(double time, double T, double beta);
372  double rcH1dashTwiceIntFunc_(double time, double cbyr);
373  double rcH2TwiceIntFunc_(double time, double rclsqr);
374 
375  double rcH3dashTwiceIntFunc_(double time, double cbyr, double rclsqr);
376 
377  // coefficient setups:
378  void rcCoeffsSetup_(
379  double & h1dashfirstcoeff,
380  double & h2firstcoeff,
381  double & h3dashfirstcoeff,
382  std::vector<double> & h1dashcoeffs,
383  std::vector<double> & h2coeffs,
384  std::vector<double> & h3dashcoeffs,
385  size_t listsize, double cbyr, double rclsqr, double curtime,
386  const std::vector<double> & timelist, int timeindex, double reltol);
387 
388  void rlcCoeffsSetup_(
389  double & h1dashfirstcoeff, double & h2firstcoeff, double & h3dashfirstcoeff,
390  std::vector<double> & h1dashcoeffs, std::vector<double> & h2coeffs, std::vector<double> & h3dashcoeffs,
391  size_t listsize, double T, double alpha, double beta, double curtime,
392  const std::vector<double> & timelist, int timeindex, double reltol, int *auxindexptr);
393 
394  bool straightLineCheck_(double x1, double y1,
395  double x2, double y2,
396  double x3, double y3,
397  double reltol, double abstol);
398 
399 
400 
401  double lteCalculate_ ( Instance & instance,
402  double curtime );
403 
404  double SECONDDERIV_(int i, double a, double b, double c);
405 
406 
407 public:
408  void addInstance(Instance *instance)
409  {
410  instanceContainer.push_back(instance);
411  }
412 
413 private:
414  std::vector<Instance*> instanceContainer;
415 
416 private:
417 
418 
419  double h1dashFirstVal; // first needed value of h1dasg at current timepoint
420  double h2FirstVal; // first needed value of h2 at current timepoint
421  double h3dashFirstVal; // first needed value of h3dash at current timepoint
422 
423  double h1dashFirstCoeff; // first needed coeff of h1dash for the current timepoint
424  double h2FirstCoeff; // first needed coeff of h2 for the current timepoint
425  double h3dashFirstCoeff; // first needed coeff of h3dash for the current timepoint
426 
427  std::vector<double> h1dashCoeffs; // list of other coefficients for h1dash
428  std::vector<double> h2Coeffs; // list of other coefficients for h2
429  std::vector<double> h3dashCoeffs; // list of other coefficients for h3dash
430 
431  size_t listSize; // size of above lists
432 
433  // input parameters:
434  double resist;
435  double induct;
436  double conduct;
437  double capac;
438  double length;
439  double reltol;
440  double abstol;
441 
442  bool noStepLimit; // Don't limit step size to less than line delay
443  bool stepLimit; // Do limit step size to less than line delay
445  // (These could be combined into a single
446  // bool, but preserving spice3 compatibility)
447 
448  bool linInterp;
451 
452  double stLineReltol;
453  double stLineAbstol;
454 
455  bool lteTimeStepControl; // indicates whether full time step
456  // control using local-truncation
457  // error estimation is performed
458 
459  bool truncNR;
461 
479 
480  // calculated parameters
481  double td; // propagation delay T - calculated
482  double imped; // impedance Z - calculated
483  double admit; // admittance Y - calculated
484  double alpha; // alpha - calculated
485  double beta; // beta - calculated
486  double attenuation; // e^(-beta T) - calculated
487  double cByR; // C/R - for the RC line - calculated
488  double rclsqr; // RCl^2 - for the RC line - calculated
489  double intH1dash; // \int_0^\inf h'_1(\tau) d \tau - calculated
490  double intH2; // \int_0^\inf h_2(\tau) d \tau - calculated
491  double intH3dash; // \int_0^\inf h'_3(\tau) d \tau - calculated
492 
493  double coshlrootGR; // cosh(l*sqrt(G*R)), used for DC analysis
494  double rRsLrGRorG; // sqrt(R)*sinh(l*sqrt(G*R))/sqrt(G)
495  double rGsLrGRorR; // sqrt(G)*sinh(l*sqrt(G*R))/sqrt(R)
496 
497  int auxIndex; // auxiliary index for h2 and h3dash
498  double chopReltol; // separate reltol for truncation of impulse responses
499  double chopAbstol; // separate abstol for truncation of impulse responses
500 
501  double maxSafeStep; // maximum safe step for impulse response calculations
502  double maxTimeStep; // maximum time step to be used
503  int howToInterp; // indicates how to interpolate for delayed timepoint
504  bool printFlag; // flag to indicate whether debugging output should be printed
505 
506  int specialCase; // what kind of model (RC, RLC, RL, ...)
507 
508  bool tdover;
509 
510  bool restartStoredFlag; // flag to indicate if this particular model has
511  // been saved to the restart file already (restart
512  // functions are instance functions, so the potential
513  // exists for storing same model multiple times.)
514 };
515 
516 //-----------------------------------------------------------------------------
517 // Class : Master
518 // Purpose :
519 // Special Notes :
520 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
521 // Creation Date : 11/26/08
522 //-----------------------------------------------------------------------------
523 class Master : public DeviceMaster<Traits>
524 {
525  friend class Instance;
526  friend class Model;
527 
528 public:
530  const Configuration & configuration,
531  const FactoryBlock & factory_block,
532  const SolverState & ss1,
533  const DeviceOptions & do1)
534  : DeviceMaster<Traits>(configuration, factory_block, ss1, do1),
535  vars_initialized(false)
536  {}
537 
538  virtual bool updateState (double * solVec, double * staVec, double * stoVec);
539  virtual bool updateSecondaryState (double * staDeriv, double * stoVec) {return true;}
540 
541  virtual bool loadDAEVectors (double * solVec, double * fVec, double * qVec, double * bVec, double * storeLeadF, double * storeLeadQ, double * leadF, double * leadQ, double * junctionV);
542  virtual bool loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx);
543 
544 private:
546 
547  void initialize_vars_();
548 };
549 
550 void registerDevice();
551 
552 } // namespace LTRA
553 } // namespace Device
554 } // namespace Xyce
555 
556 #endif
bool modelCalculations_(int &isaved, double &qf1, double &qf2, double &qf3, double &lf2, double &lf3)
Definition: N_DEV_LTRA.C:1411
double rlcH3dashFunc_(double time, double T, double alpha, double beta)
Definition: N_DEV_LTRA.C:1998
virtual std::ostream & printOutInstances(std::ostream &os) const
Definition: N_DEV_LTRA.C:1359
double thriceintlinfunc_(double lolimit, double hilimit, double secondlolimit, double thirdlolimit, double lovalue, double hivalue, double t1, double t2)
Definition: N_DEV_LTRA.C:1805
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:2315
bool getInstanceBreakPoints(std::vector< Util::BreakPoint > &breakPointTimes)
Definition: N_DEV_LTRA.C:641
double rcH2TwiceIntFunc_(double time, double rclsqr)
Definition: N_DEV_LTRA.C:2095
static std::vector< std::vector< int > > jacStamp
Definition: N_DEV_LTRA.h:193
bool setInternalState(const DeviceState &state)
Definition: N_DEV_LTRA.C:1115
const std::vector< std::vector< int > > & jacobianStamp() const
Definition: N_DEV_LTRA.C:462
std::vector< double > v1
Definition: N_DEV_LTRA.h:217
DeviceState * getInternalState()
Definition: N_DEV_LTRA.C:1037
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:218
std::vector< double > h1dashCoeffs
Definition: N_DEV_LTRA.h:427
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:2128
bool straightLineCheck_(double x1, double y1, double x2, double y2, double x3, double y3, double reltol, double abstol)
Definition: N_DEV_LTRA.C:2558
Instance & operator=(const Instance &)
double rlcH3dashIntFunc_(double time, double T, double beta)
Definition: N_DEV_LTRA.C:2061
double bessI1_(double x)
Definition: N_DEV_LTRA.C:1877
DeviceMaster instantiates a device as described by the device traits T.
double rcH1dashTwiceIntFunc_(double time, double cbyr)
Definition: N_DEV_LTRA.C:2082
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:1768
virtual bool loadDAEMatrices(Linear::Matrix &dFdx, Linear::Matrix &dQdx)
Populates the device's Jacobian object with these pointers.
Definition: N_DEV_LTRA.C:3696
static bool modelRequired()
Definition: N_DEV_LTRA.h:118
double bessI0_(double x)
Definition: N_DEV_LTRA.C:1845
std::vector< double > i2
Definition: N_DEV_LTRA.h:221
Master(const Configuration &configuration, const FactoryBlock &factory_block, const SolverState &ss1, const DeviceOptions &do1)
Definition: N_DEV_LTRA.h:529
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:1909
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:2629
Class Configuration contains device configuration data.
std::vector< Instance * > InstanceVector
Definition: N_DEV_LTRA.h:319
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:1621
virtual bool updateSecondaryState(double *staDeriv, double *stoVec)
Updates the devices secondary state information.
Definition: N_DEV_LTRA.h:539
bool processInstanceParams()
processInstanceParams
Definition: N_DEV_LTRA.C:1206
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:2159
virtual void forEachInstance(DeviceInstanceOp &op) const
Apply a device instance "op" to all instances associated with this model.
Definition: N_DEV_LTRA.C:1396
double rlcH1dashTwiceIntFunc_(double time, double beta)
Definition: N_DEV_LTRA.C:2034
static Device * factory(const Configuration &configuration, const FactoryBlock &factory_block)
Definition: N_DEV_LTRA.C:3855
double SECONDDERIV_(int i, double a, double b, double c)
Definition: N_DEV_LTRA.C:2611
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:3163
std::vector< double > h2Coeffs
Definition: N_DEV_LTRA.h:428
double intlinfunc_(double lolimit, double hilimit, double lovalue, double hivalue, double t1, double t2)
Definition: N_DEV_LTRA.C:1739
bool isLinearDevice() const
Definition: N_DEV_LTRA.h:153
std::vector< double > h3dashCoeffs
Definition: N_DEV_LTRA.h:429
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:1966
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:414
bool processParams()
processParams
Definition: N_DEV_LTRA.C:1192
std::vector< double > i1
Definition: N_DEV_LTRA.h:220
int linInterp_(double t, double t1, double t2, double &c1, double &c2)
Definition: N_DEV_LTRA.C:1698
double rlcH1dashFunc_(double time, double T, double alpha, double beta)
Definition: N_DEV_LTRA.C:1940
virtual bool updateState(double *solVec, double *staVec, double *stoVec)
Updates the devices state information.
Definition: N_DEV_LTRA.C:2929
void addInstance(Instance *instance)
Definition: N_DEV_LTRA.h:408
static bool isLinearDevice()
Definition: N_DEV_LTRA.h:119