Xyce  6.1
N_DEV_2DPDE.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_2DPDE.h,v $
27 //
28 // Purpose : This file contains the classes neccessary for a 2D PDE
29 // based simulation. MOSFETs, BJTs, Diodes, etc.
30 //
31 // Special Notes :
32 //
33 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
34 //
35 // Creation Date : 11/14/01
36 //
37 // Revision Information:
38 // ---------------------
39 //
40 // Revision Number: $Revision: 1.103 $
41 //
42 // Revision Date : $Date: 2015/04/27 17:50:45 $
43 //
44 // Current Owner : $Author: erkeite $
45 //-----------------------------------------------------------------------------
46 
47 #ifndef Xyce_N_DEV_2DPDE_h
48 #define Xyce_N_DEV_2DPDE_h
49 
50 // ---------- Standard Includes ----------
51 
52 // ---------- Xyce Includes ----------
53 #include <N_DEV_fwd.h>
54 
55 #include <N_DEV_Configuration.h>
56 #include <N_DEV_DeviceBlock.h>
59 #include <N_DEV_DevicePDEModel.h>
60 #include <N_DEV_DiodePDE.h>
61 #include <N_DEV_PDE_2DMesh.h>
62 
63 // Have the "new" boundary conditions turned on by default.
64 #if 1
65 #define Xyce_NEW_BC 1
66 #endif
67 
68 namespace Xyce {
69 namespace Device {
70 namespace TwoDPDE {
71 
72 namespace {
73 typedef unsigned int UINT;
74 }
75 
76 class Model;
77 class Instance;
78 
79 struct Traits : public DeviceTraits<Model, Instance, DiodePDE::Traits>
80 {
81  static const char *name() {return "2D PDE (level 2)";}
82  static const char *deviceTypeName () {return "PDE level 2";}
83  static int numNodes() {return 2;}
84  static int numOptionalNodes() {return 100;}
85  static int numFillNodes() {return 2;}
86  static bool modelRequired() {return true;}
87  static bool isPDEDevice() {return true;}
88  static bool isLinearDevice() {return false;}
89 
90  static Device *factory(const Configuration &configuration, const FactoryBlock &factory_block);
91  static void loadModelParameters(ParametricData<Model> &model_parameters);
92  static void loadInstanceParameters(ParametricData<Instance> &instance_parameters);
93 };
94 
95 //-----------------------------------------------------------------------------
96 // Class : Instance
97 // Purpose : Instance class for .
98 //
99 // Special Notes :
100 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
101 // Creation Date : 11/14/01
102 //-----------------------------------------------------------------------------
104 {
105  friend class ParametricData<Instance>;
106  friend class Model;
107  friend class Traits;
108 
109  // functions
110 public:
111 
112  Instance(
113  const Configuration & configuration,
114  const InstanceBlock & IB,
115  Model & model,
116  const FactoryBlock &factory_block);
117  ~Instance();
118 
119 private:
120  Instance(const Instance &right);
121  Instance &operator=(const Instance &right);
122 
123 public:
124  void registerGIDs (const IndexPairVector & intGIDListRef,
125  const IndexPairVector & extGIDListRef );
126 
127  void setupRowColPairs ();
128 
129  void registerStateGIDs (const IndexPairVector & staGIDListRef);
130 
131  void registerLIDs( const std::vector<int> & intLIDVecRef,
132  const std::vector<int> & extLIDVecRef );
133  void registerStateLIDs( const std::vector<int> & staLIDVecRef );
134 
135  void loadNodeSymbols(Util::SymbolTable &symbol_table) const; // override
136 
137  const std::vector< std::vector<int> > & jacobianStamp() const;
138  void registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec );
139 
140  bool processParams ();
141 
142  bool processOneTimeParams( Param & ndParam );
143 
144  bool processDopingParams (Param & ndParam, std::string param);
145 
146  bool processElectrodeParams (Param & ndParam);
147 
148  bool setupJacStamp ();
149 
150  bool doSensMeshResize ();
151  bool undoSensMeshResize ();
152 
153  bool setupMesh ();
154  bool doAllocations ();
155 
156  bool setupDINodes ();
157  bool setupBCEdgeAreas ();
158 
159  bool setupBoundaryStencil ();
160  bool setupNumVars ();
161 
162  bool checkForElectrodeOverlap ();
163 
164  bool setupLabelIndex ();
165  bool setupMinDXVector ();
166 
167  bool updateIntermediateVars ();
168  bool updatePrimaryState ();
169  bool updateSecondaryState ();
170 
171  // functions that are used by both new-DAE and old-DAE:
172  bool loadVecNLPoisson (double scalar, Linear::Vector * vecPtr);
173  bool loadMatNLPoisson (Linear::Matrix * matPtr);
174  bool loadMatKCLDDForm (Linear::Matrix * matPtr);
175  bool loadMatDDForm (double dndtScalar, Linear::Matrix * matPtr);
176  bool loadVecDDForm (double scalar,double dndtScalar,Linear::Vector *vecPtr);
177  bool loadMatCktTrivial (Linear::Matrix * matPtr);
178  // end of the "both" DAE functions.
179 
180  bool setInitialGuess ();
181  bool loadRHSNonlinPoisson ();
182  bool loadRHSDDFormulation ();
184 
185  bool plotfileFlag () {return true;}
186 
187  // load functions, residual:
188  bool loadDAEQVector ();
189  bool loadDAEQDDFormulation ();
190  bool loadDAEQExtractedConductance () { return true; }
191 
192  bool loadDAEFVector ();
193  bool loadDAEFNonlinPoisson ();
194  bool loadDAEFDDFormulation ();
196 
197  // load functions, Jacobian:
198  bool loadDAEdQdx ();
199 
200  bool loadDAEdQdxDDFormulation ();
201  bool loadDAEdQdxExtractedConductance () { return true; }
202 
203  bool loadDAEdFdx ();
204  bool loadDAEdFdxNonlinPoisson ();
205  bool loadDAEdFdxDDFormulation ();
207 
208  bool calcLifetimes ();
209  bool calcMobilities ();
210  bool updateTemperature(const double & temp_tmp);
211  bool calcVoltDepDensities ();
212 
213  bool calcDopingProfile ();
214  bool calcInitialGuess ();
215  bool obtainSolution ();
216  bool obtainNodeVoltages ();
217  bool applyVoltageLimiting ();
218  bool calcVequBCs ();
219  bool calcDensityBCs ();
220  bool calcBoundaryConditions ();
221 
222  bool setupMiscConstants ();
223  bool setupScalingVars ();
224  bool scaleVariables ();
225  bool unScaleVariables ();
226  bool scaleDopeVariables ();
227  bool unScaleDopeVariables ();
228 
229  bool calcRecombination ();
230 
231  bool sumSources ();
232 
233  bool calcElectronCurrent ();
234  bool calcHoleCurrent ();
235  bool calcEfield ();
236 
237  bool calcTerminalCharges ();
238  bool calcTerminalCurrents ();
239  bool calcConductance (int iElectrode, const Linear::Vector * dxdvPtr);
240  bool calcDXDV ();
241  bool loadDFDV (int ielectrode, Linear::Vector * dfdvPtr);
242 
243  bool pdRecombination ();
244  bool pdElectronCurrent ();
245  bool pdHoleCurrent ();
246  bool pdTerminalCurrents ();
247  bool pdTerminalCharges ();
248  bool allocatePDTerms ();
249 
250  bool outputTecplot ();
251  bool outputTecplotVectors ();
252  bool tecplotGeomOutput (FILE *fp1);
253  bool outputSgplot ();
254  bool outputGnuplot ();
255  bool outputTxtData ();
256 
257  bool enablePDEContinuation(int &max_PDE_continuation_steps);
258  bool disablePDEContinuation ();
259  void setPDEContinuationAlpha (double alpha);
260  void setPDEContinuationBeta (double beta);
261 
262  bool outputPlotFiles(bool force_final_output);
263 
264  CompositeParam *constructComposite (const std::string & compositeName, const std::string & paramName);
265 
266 public:
267  // iterator reference to the resistor model which owns this instance.
268  // Getters and setters
270  {
271  return model_;
272  }
273 
274 private:
275 
276  Model & model_; //< Owning model
277 
278 protected:
279 private:
280 
281  // physical constants:
282  double Is; // saturation current
283  double Id; // diode current, analytic form
284 
285  double Emax; // maximum electric field (V/cm)
286 
287  double VminExp; // maximum potential (V), used in exponential expressions
288  double VmaxExp; // minimum potential (V), used in exponential expressions
289 
290  // device interface node vector:
291  std::vector<DeviceInterfaceNode> dIVec;
292 
293  double LeadCurrent1;
294  double LeadCurrent2;
295  double LeadCurrent3;
296  double LeadCurrent4;
297  double LeadCurrent5;
298  double LeadCurrent6;
299  double LeadCurrent7;
300  double LeadCurrent8;
301 
302  // doping profile constants:
303  double Na; // acceptor concentration on p-side (cm^-3)
304  double Nd; // donor concentration on n-side (cm^-3)
305  double WJ; // linearly graded junction width (cm)
306  double XC; // center of graded junction (cm)
307  double XL; // start of graded junction (cm)
308  double XR; // end of graded junction (cm)
309 
310  // boundary condition variables:
311  double NnMax; // maximum electron concentration
312  double NpMax; // maximum hole concentration.
313  double NnMin; // maximum electron concentration
314  double NpMin; // maximum hole concentration.
315 
316  // option to use the old intrinsic calculation, to maintain backward compatibility.
317  bool useOldNi;
319 
320  std::string meshFileName;
321  std::string deviceType;
326 
327  // meshing variables, if using internally generated mesh.
330  double deviceLength;
331  double deviceWidth;
332 
334 
335  // diode cross sectional area:
336  double area;
337 
338 #ifdef Xyce_OXIDE_ENABLED
339  bool allOxideFlag;
340 #endif
341 
344  int callsOSG;
349 
352 
353  bool calcConductanceFlag; // Set when calcConductance is
354  // called for the 1st time.
355 
357 
362 
367 
369 
371 
374 
375  // mesh container pointer:
378 
379  // array pointers:
380  std::vector<double> xVec; // x locations
381  std::vector<double> yVec; // y locations
382  std::vector<double> CVec; // doping
383  std::vector<double> CdonorVec; // doping
384  std::vector<double> CacceptorVec; // doping
385 
386  std::vector<double> minDXVec; // minimum mesh spacing connected to this node.
387 
388  std::vector<double> areaVec;
389 
390  std::vector<double> VVec; // electrostatic potential
391  std::vector<double> nnVec; // electron density
392  std::vector<double> npVec; // hole density
393 
394  std::vector<double> totSrcVec; // total source term.
395  std::vector<double> RVec; // recombination.
396  std::vector<double> SVec; // radiation source term.
397 
398  std::vector<double> unVec; // spatially dependent mobility, electron
399  std::vector<double> upVec; // spatially dependent mobility, hole
400  std::vector<double> unE_Vec; // mobility along edge, electron
401  std::vector<double> upE_Vec; // mobility along edge, hole
402  std::vector<double> tnVec; // spatially dependent lifetimes, electron
403  std::vector<double> tpVec; // spatially dependent lifetimes, hole
404 
405  std::vector<double> EfieldVec; // electric field along an edge.
406 
407  std::vector<double> JnVec; // electron current density, along an edge
408  std::vector<double> JpVec; // hole current density, along an edge
409 
410  std::vector<double> displPotential; // time derivative of potential at a node,
411  // used in calculating displacement current.
412 
413  std::vector<double> displCurrent; // displacement current along an edge.
414 
415  std::vector<double> outputVec;
416 
417  // derivative arrays:
418 
419  // derivatives of recombination terms:
420  std::vector<double> dRdpVec; // derivative of R w.r.t. np (at a node)
421  std::vector<double> dRdnVec; // derivative of R w.r.t. nn (at a node)
422 
423  // derivatives of current density terms:
424  std::vector<double> dJndn1Vec;
425  std::vector<double> dJndn2Vec;
426  std::vector<double> dJndV1Vec;
427  std::vector<double> dJndV2Vec;
428 
429  std::vector<double> dJpdn1Vec;
430  std::vector<double> dJpdn2Vec;
431  std::vector<double> dJpdV1Vec;
432  std::vector<double> dJpdV2Vec;
433 
434  // matrix index arrays:
435  // external variable information is in the dIVec data structure.
436 
437  // boundary "neighbor" stencil
438  // This array is set to 1 if we are on a mesh node which has a
439  // nearest neighbor node which is a boundary condition node.
440  // 0 if not.
441  std::vector<int> boundarySten;
442  std::vector<int> boundaryStenV;
443  std::vector<int> boundaryStenN;
444  std::vector<int> boundaryStenP;
445 
446  std::vector<int> boundaryTest;
447 
448  // boundary neighbor stencil
449  // This array is set to 1 if we are next to a boundary, but not on
450  // a boundary. 0 if not. A node directly on the boundary
451  // does should return a zero.
452  std::vector<int> boundaryNeighborSten;
453 
454  // internal variable index arrays:
455 
456  // index arrays for poisson's equation:
457  std::vector<int> Vrowarray;
458  std::vector< std::vector<int> > Vcolarray;
459 
460  // index arrays for electron continuity:
461  std::vector<int> Nrowarray;
462  std::vector< std::vector<int> > Ncolarray;
463 
464  // index arrays for hole continuity:
465  std::vector<int> Prowarray;
466  std::vector< std::vector<int> > Pcolarray;
467 
468  // variable ownership arrays.
469  std::vector<int> vOwnVec; // on processor tag, for voltage variables.
470  std::vector<int> nnOwnVec; // on processor tag, for elec. density variables.
471  std::vector<int> npOwnVec; // on processor tag, for hole density variables.
472 
473  //local id's (offsets)
474  std::vector<int> li_Vrowarray;
475  std::vector<int> li_Nrowarray;
476  std::vector<int> li_Prowarray;
477 
478  std::vector< std::vector<int> > li_VoffsetArray;
479  std::vector< std::vector<int> > li_NoffsetArray;
480  std::vector< std::vector<int> > li_PoffsetArray;
481 
482  std::vector<int> MESHtoLID_V;
483  std::vector<int> MESHtoLID_N;
484  std::vector<int> MESHtoLID_P;
485 
486 
487  // minor arrays used in tecplot output:
488  std::vector<UINT> aiEdge;
489  std::vector<UINT> aiEdge_nf;
490  //std::vector<UINT> electrodeEdge;
493 
494  // this map is mostly used for processing the netlist information
495  // regarding boundary conditions.
496  std::map<std::string,std::string> tmpBCmap;
497 
498  // label index array (of numMeshPoints length)
499  std::vector<int> labelIndex;
500  std::vector<std::string> labelNameVector;
501  std::map<std::string,int> labelDIMap;
502 
503  // map between a mesh point index and a list of nearest neighbors
504  // for that mesh point.
505  std::multimap < int, int* > meshNeighborMultiMap;
506 
507  // vector of electrode data:
508  std::map<std::string,PDE_2DElectrode*> electrodeMap;
509 
510  // displacement current state variable information:
511  std::vector<int> stateDispl;
512  std::vector<int> stateDispl_owned; // this is an int array because
513  // bool arrays are problematic,
514  // esp. with some STL implementations.
515 
516  //local id's (offsets)
517  std::vector<int> li_stateDispl;
518 
520  int numInterfaceMeshPoints; // number of mesh points that
521  // are along electrode boundaries
527 
528  // 2d array of conductances, for 2-level "ckt phase" loads.
529  std::vector< std::vector<double> > condVec;
530 
531  // 2d array of capacitances,
532  std::vector< std::vector<double> > capVec;
533 
535 
536  // data related to DMA matrix loads.
537  std::vector<int> meshToLID;
538  std::vector< std::vector<int> > jacStamp;
539 };
540 
541 //-----------------------------------------------------------------------------
542 // Class : Model
543 // Purpose :
544 // Special Notes :
545 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
546 // Creation Date : 11/14/01
547 //-----------------------------------------------------------------------------
548 class Model : public DevicePDEModel
549 {
550  typedef std::vector<Instance *> InstanceVector;
551 
552  friend class ParametricData<Model>;
553  friend class Instance;
554  friend class Traits;
555 
556 public:
557  Model(
558  const Configuration & configuration,
559  const ModelBlock & MB,
560  const FactoryBlock & factory_block);
561 
562  ~Model();
563 
564 private:
565  Model();
566  Model(const Model &);
567  Model &operator=(const Model &);
568 
569 public:
570  virtual void forEachInstance(DeviceInstanceOp &op) const /* override */;
571 
572  virtual std::ostream &printOutInstances(std::ostream &os) const;
573 
574  bool processParams ();
575  bool processInstanceParams ();
576 
577 
578 public:
579  void addInstance(Instance *instance)
580  {
581  instanceContainer.push_back(instance);
582  }
583 
584 private:
585  std::vector<Instance*> instanceContainer;
586 
587 private:
588 };
589 
590 void registerDevice();
591 
592 } // namespace TwoDPDE
593 } // namespace Device
594 } // namespace Xyce
595 
596 #endif
bool processParams()
processParams
bool processElectrodeParams(Param &ndParam)
std::vector< double > RVec
Definition: N_DEV_2DPDE.h:395
std::vector< double > displPotential
Definition: N_DEV_2DPDE.h:410
std::vector< int > li_stateDispl
Definition: N_DEV_2DPDE.h:517
virtual std::ostream & printOutInstances(std::ostream &os) const
std::vector< int > stateDispl_owned
Definition: N_DEV_2DPDE.h:512
std::multimap< int, int * > meshNeighborMultiMap
Definition: N_DEV_2DPDE.h:505
std::vector< int > nnOwnVec
Definition: N_DEV_2DPDE.h:470
bool outputPlotFiles(bool force_final_output)
const std::vector< std::vector< int > > & jacobianStamp() const
std::vector< int > MESHtoLID_P
Definition: N_DEV_2DPDE.h:484
std::vector< double > CVec
Definition: N_DEV_2DPDE.h:382
bool enablePDEContinuation(int &max_PDE_continuation_steps)
std::vector< int > boundaryStenN
Definition: N_DEV_2DPDE.h:443
std::vector< std::vector< int > > li_VoffsetArray
Definition: N_DEV_2DPDE.h:478
std::vector< int > li_Vrowarray
Definition: N_DEV_2DPDE.h:474
std::vector< double > outputVec
Definition: N_DEV_2DPDE.h:415
Pure virtual class to augment a linear system.
std::vector< int > Vrowarray
Definition: N_DEV_2DPDE.h:457
std::vector< double > CdonorVec
Definition: N_DEV_2DPDE.h:383
bool calcConductance(int iElectrode, const Linear::Vector *dxdvPtr)
bool loadMatKCLDDForm(Linear::Matrix *matPtr)
std::vector< double > upE_Vec
Definition: N_DEV_2DPDE.h:401
std::vector< double > dJndn1Vec
Definition: N_DEV_2DPDE.h:424
std::vector< int > npOwnVec
Definition: N_DEV_2DPDE.h:471
std::vector< double > totSrcVec
Definition: N_DEV_2DPDE.h:394
void registerStateGIDs(const IndexPairVector &staGIDListRef)
std::vector< int > Nrowarray
Definition: N_DEV_2DPDE.h:461
std::vector< double > EfieldVec
Definition: N_DEV_2DPDE.h:405
std::vector< int > boundarySten
Definition: N_DEV_2DPDE.h:441
std::vector< double > dJpdn2Vec
Definition: N_DEV_2DPDE.h:430
void registerLIDs(const std::vector< int > &intLIDVecRef, const std::vector< int > &extLIDVecRef)
std::vector< double > minDXVec
Definition: N_DEV_2DPDE.h:386
bool processOneTimeParams(Param &ndParam)
std::map< std::string, int > labelDIMap
Definition: N_DEV_2DPDE.h:501
std::vector< UINT > aiEdge
Definition: N_DEV_2DPDE.h:488
static const char * deviceTypeName()
Definition: N_DEV_2DPDE.h:82
bool loadDFDV(int ielectrode, Linear::Vector *dfdvPtr)
std::vector< std::vector< int > > li_PoffsetArray
Definition: N_DEV_2DPDE.h:480
std::vector< double > dJpdn1Vec
Definition: N_DEV_2DPDE.h:429
CompositeParam * constructComposite(const std::string &compositeName, const std::string &paramName)
std::vector< std::vector< int > > Ncolarray
Definition: N_DEV_2DPDE.h:462
std::vector< std::string > labelNameVector
Definition: N_DEV_2DPDE.h:500
std::vector< std::vector< int > > Vcolarray
Definition: N_DEV_2DPDE.h:458
std::vector< double > xVec
Definition: N_DEV_2DPDE.h:380
The FactoryBlock contains parameters needed by the device, instance and model creation functions...
std::vector< std::vector< int > > jacStamp
Definition: N_DEV_2DPDE.h:538
void registerJacLIDs(const std::vector< std::vector< int > > &jacLIDVec)
std::vector< int > li_Nrowarray
Definition: N_DEV_2DPDE.h:475
std::vector< double > dJndV1Vec
Definition: N_DEV_2DPDE.h:426
Instance(const Configuration &configuration, const InstanceBlock &IB, Model &model, const FactoryBlock &factory_block)
std::vector< double > dJpdV2Vec
Definition: N_DEV_2DPDE.h:432
std::vector< double > nnVec
Definition: N_DEV_2DPDE.h:391
void registerStateLIDs(const std::vector< int > &staLIDVecRef)
std::vector< int > boundaryStenV
Definition: N_DEV_2DPDE.h:442
std::vector< std::vector< double > > condVec
Definition: N_DEV_2DPDE.h:529
std::vector< int > MESHtoLID_V
Definition: N_DEV_2DPDE.h:482
std::vector< double > tnVec
Definition: N_DEV_2DPDE.h:402
bool loadVecNLPoisson(double scalar, Linear::Vector *vecPtr)
std::vector< double > VVec
Definition: N_DEV_2DPDE.h:390
bool updateTemperature(const double &temp_tmp)
std::vector< int > boundaryTest
Definition: N_DEV_2DPDE.h:446
static Device * factory(const Configuration &configuration, const FactoryBlock &factory_block)
std::vector< double > displCurrent
Definition: N_DEV_2DPDE.h:413
std::vector< double > unVec
Definition: N_DEV_2DPDE.h:398
The Device class is an interface for device implementations.
Definition: N_DEV_Device.h:101
std::vector< int > boundaryNeighborSten
Definition: N_DEV_2DPDE.h:452
static void loadModelParameters(ParametricData< Model > &model_parameters)
std::vector< double > dJndn2Vec
Definition: N_DEV_2DPDE.h:425
Instance & operator=(const Instance &right)
void addInstance(Instance *instance)
Definition: N_DEV_2DPDE.h:579
std::vector< double > CacceptorVec
Definition: N_DEV_2DPDE.h:384
std::vector< int > labelIndex
Definition: N_DEV_2DPDE.h:499
std::vector< double > dRdnVec
Definition: N_DEV_2DPDE.h:421
std::map< std::string, PDE_2DElectrode * > electrodeMap
Definition: N_DEV_2DPDE.h:508
std::vector< int > stateDispl
Definition: N_DEV_2DPDE.h:511
std::vector< DeviceInterfaceNode > dIVec
Definition: N_DEV_2DPDE.h:291
Class Configuration contains device configuration data.
static void loadInstanceParameters(ParametricData< Instance > &instance_parameters)
static const char * name()
Definition: N_DEV_2DPDE.h:81
std::vector< double > dJndV2Vec
Definition: N_DEV_2DPDE.h:427
bool loadVecDDForm(double scalar, double dndtScalar, Linear::Vector *vecPtr)
std::vector< double > JpVec
Definition: N_DEV_2DPDE.h:408
std::vector< Instance * > instanceContainer
Definition: N_DEV_2DPDE.h:585
void loadNodeSymbols(Util::SymbolTable &symbol_table) const
Populates and returns the store name map.
std::vector< std::vector< int > > Pcolarray
Definition: N_DEV_2DPDE.h:466
virtual void forEachInstance(DeviceInstanceOp &op) const
Apply a device instance "op" to all instances associated with this model.
std::vector< double > yVec
Definition: N_DEV_2DPDE.h:381
std::vector< UINT > aiEdge_nf
Definition: N_DEV_2DPDE.h:489
std::vector< double > npVec
Definition: N_DEV_2DPDE.h:392
bool loadMatNLPoisson(Linear::Matrix *matPtr)
std::vector< double > unE_Vec
Definition: N_DEV_2DPDE.h:400
bool loadMatCktTrivial(Linear::Matrix *matPtr)
bool processInstanceParams()
processInstanceParams
void registerGIDs(const IndexPairVector &intGIDListRef, const IndexPairVector &extGIDListRef)
std::vector< int > li_Prowarray
Definition: N_DEV_2DPDE.h:476
std::vector< Instance * > InstanceVector
Definition: N_DEV_2DPDE.h:550
std::vector< int > vOwnVec
Definition: N_DEV_2DPDE.h:469
std::vector< double > upVec
Definition: N_DEV_2DPDE.h:399
bool processDopingParams(Param &ndParam, std::string param)
std::vector< int > MESHtoLID_N
Definition: N_DEV_2DPDE.h:483
ModelBlock represents a .MODEL line from the netlist.
The DeviceTraits template describes the configuration of a device.
Manages parameter binding for class C.
Definition: N_DEV_Pars.h:214
std::vector< int > Prowarray
Definition: N_DEV_2DPDE.h:465
bool loadMatDDForm(double dndtScalar, Linear::Matrix *matPtr)
InstanceBlock represent a device instance line from the netlist.
std::map< std::string, std::string > tmpBCmap
Definition: N_DEV_2DPDE.h:496
std::vector< double > dRdpVec
Definition: N_DEV_2DPDE.h:420
std::vector< std::vector< double > > capVec
Definition: N_DEV_2DPDE.h:532
std::vector< int > boundaryStenP
Definition: N_DEV_2DPDE.h:444
std::vector< std::vector< int > > li_NoffsetArray
Definition: N_DEV_2DPDE.h:479
std::vector< double > SVec
Definition: N_DEV_2DPDE.h:396
std::vector< int > meshToLID
Definition: N_DEV_2DPDE.h:537
CompositeParam is the base class for classes that wish to only manage the processing of parameter dat...
std::vector< double > areaVec
Definition: N_DEV_2DPDE.h:388
std::vector< double > JnVec
Definition: N_DEV_2DPDE.h:407
Model & operator=(const Model &)
std::vector< double > tpVec
Definition: N_DEV_2DPDE.h:403
std::vector< double > dJpdV1Vec
Definition: N_DEV_2DPDE.h:431