Xyce  6.1
N_DEV_Vsrc.C
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-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_Vsrc.C,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.250 $
40 //
41 // Revision Date : $Date: 2015/04/20 20:43:55 $
42 //
43 // Current Owner : $Author: dgbaur $
44 //-------------------------------------------------------------------------
45 #include <Xyce_config.h>
46 
47 // ---------- Standard Includes ----------
48 
49 // ---------- Xyce Includes ----------
50 #include <N_DEV_DeviceMgr.h>
51 #include <N_DEV_DeviceOptions.h>
52 #include <N_DEV_ExternData.h>
53 #include <N_DEV_MatrixLoadData.h>
54 #include <N_DEV_SolverState.h>
55 #include <N_DEV_SourceData.h>
56 #include <N_DEV_Vsrc.h>
57 #include <N_DEV_Message.h>
58 #include <N_ERH_ErrorMgr.h>
59 
60 #include <N_LAS_Vector.h>
61 #include <N_LAS_Matrix.h>
62 #include <N_UTL_BreakPoint.h>
63 #include <N_UTL_FeatureTest.h>
64 
65 namespace Xyce {
66 namespace Device {
67 
68 namespace Vsrc {
69 
71 {
72  p.addPar ("DCV0", 0.0, &Vsrc::Instance::DCV0)
73  .setOriginalValueStored(true)
74  .setUnit(U_VOLT)
75  .setDescription("DC Voltage")
76  .setAnalyticSensitivityAvailable(true)
77  .setSensitivityFunctor(&dcv0Sens);
78 
79  // Pulse parameters
80  p.addPar ("V0", 0.0, &Vsrc::Instance::par0)
81  .setUnit(U_VOLT)
82  .setCategory(CAT_NONE)
83  .setDescription("Offset Voltage");
84 
85  p.addPar ("V1", 0.0, &Vsrc::Instance::par0)
86  .setUnit(U_VOLT)
87  .setCategory(CAT_NONE)
88  .setDescription("Initial Voltage");
89 
90  p.addPar ("V2", 0.0, &Vsrc::Instance::par1)
91  .setUnit(U_VOLT)
92  .setCategory(CAT_NONE)
93  .setDescription("Pulsed Voltage");
94 
95  p.addPar ("TD", 0.0, &Vsrc::Instance::par2)
96  .setUnit(U_SECOND)
97  .setCategory(CAT_NONE)
98  .setDescription("Delay");
99 
100  p.addPar ("TR", 0.0, &Vsrc::Instance::par3)
101  .setUnit(U_SECOND)
102  .setCategory(CAT_NONE)
103  .setDescription("Rise Time");
104 
105  p.addPar ("TF", 0.0, &Vsrc::Instance::par4)
106  .setUnit(U_SECOND)
107  .setCategory(CAT_NONE)
108  .setDescription("Fall Time");
109 
110  p.addPar ("PW", 0.0, &Vsrc::Instance::par5)
111  .setUnit(U_SECOND)
112  .setCategory(CAT_NONE)
113  .setDescription("Pulse Width");
114 
115  p.addPar ("PER", 0.0, &Vsrc::Instance::par6)
116  .setUnit(U_SECOND)
117  .setCategory(CAT_NONE)
118  .setDescription("Period");
119 
120  p.addPar ("SF", 0.0, &Vsrc::Instance::par7)
121  .setUnit(U_NONE)
122  .setCategory(CAT_NONE)
123  .setDescription("Scale Factor -- smooth pulse only");
124 
125  // Sin parameters
126  p.addPar ("VA", 0.0, &Vsrc::Instance::par1)
127  .setUnit(U_VOLT)
128  .setCategory(CAT_NONE)
129  .setDescription("Amplitude");
130 
131  p.addPar ("FREQ", 0.0, &Vsrc::Instance::par3)
132  .setUnit(U_SECM1)
133  .setCategory(CAT_NONE)
134  .setDescription("Frequency");
135 
136  p.addPar ("THETA", 0.0, &Vsrc::Instance::par4)
137  .setUnit(U_NONE)
138  .setCategory(CAT_NONE)
139  .setDescription("Theta");
140 
141  p.addPar ("PHASE", 0.0, &Vsrc::Instance::par5)
142  .setUnit(U_NONE)
143  .setCategory(CAT_NONE)
144  .setDescription("Phase");
145 
146  // Exp parameters
147  p.addPar ("TD1", 0.0, &Vsrc::Instance::par2)
148  .setUnit(U_SECOND)
149  .setCategory(CAT_NONE)
150  .setDescription("Rise Delay Time");
151 
152  p.addPar ("TAU1", 0.0, &Vsrc::Instance::par3)
153  .setUnit(U_SECOND)
154  .setCategory(CAT_NONE)
155  .setDescription("Rise Time Constant");
156 
157  p.addPar ("TD2", 0.0, &Vsrc::Instance::par4)
158  .setUnit(U_SECOND)
159  .setCategory(CAT_NONE)
160  .setDescription("Fall Delay Time");
161 
162  p.addPar ("TAU2", 0.0, &Vsrc::Instance::par5)
163  .setUnit(U_SECOND)
164  .setCategory(CAT_NONE)
165  .setDescription("Fall Time Constant");
166 
167  // AC parameters
168  p.addPar ("ACMAG", 0.0, &Vsrc::Instance::ACMAG)
169  .setUnit(U_VOLT)
170  .setCategory(CAT_NONE)
171  .setDescription("Amplitude");
172 
173  p.addPar ("ACPHASE", 0.0, &Vsrc::Instance::ACPHASE)
174  .setUnit(U_NONE)
175  .setCategory(CAT_NONE)
176  .setDescription("Phase");
177 
178  // SFFM parameters
179  p.addPar ("FC", 0.0, &Vsrc::Instance::par2)
180  .setUnit(U_SECM1)
181  .setCategory(CAT_NONE)
182  .setDescription("Carrier Frequency");
183 
184  p.addPar ("FS", 0.0, &Vsrc::Instance::par4)
185  .setUnit(U_SECM1)
186  .setCategory(CAT_NONE)
187  .setDescription("Signal Frequency");
188 
189  p.addPar ("MDI", 0.0, &Vsrc::Instance::par3)
190  .setUnit(U_NONE)
191  .setCategory(CAT_NONE)
192  .setDescription("Modulation Index");
193 
194  // PWL params
195  p.addPar ("R", 0.0, &Vsrc::Instance::REPEATTIME)
196  .setUnit(U_SECOND)
197  .setCategory(CAT_NONE)
198  .setDescription("Repeat Time");
199 
200  p.addPar ("T", 0.0, &Vsrc::Instance::T)
201  .setUnit(U_SECOND)
202  .setCategory(CAT_NONE)
203  .setDescription("Time"); // time-voltage pairs
204 
205  p.addPar ("V", 0.0, &Vsrc::Instance::V)
206  .setUnit(U_VOLT)
207  .setCategory(CAT_NONE)
208  .setDescription("Voltage"); // time-voltage pairs
209 
210  // Set up exceptions (ie variables that are not doubles):
211  p.addPar ("TRANSIENTSOURCETYPE", (int) _DC_DATA, &Vsrc::Instance::TRANSIENTSOURCETYPE)
213  .setUnit(U_NONE)
214  .setCategory(CAT_NONE)
215  .setDescription("" );
216 
217  p.addPar ("ACSOURCETYPE", (int) _AC_DATA, &Vsrc::Instance::ACSOURCETYPE)
218  .setGivenMember(&Vsrc::Instance::ACSOURCETYPEgiven)
219  .setUnit(U_NONE)
220  .setCategory(CAT_NONE)
221  .setDescription("" );
222 
223  p.addPar ("DCSOURCETYPE", (int) _DC_DATA, &Vsrc::Instance::DCSOURCETYPE)
224  .setGivenMember(&Vsrc::Instance::DCSOURCETYPEgiven)
225  .setUnit(U_NONE)
226  .setCategory(CAT_NONE)
227  .setDescription("" );
228 
229  p.addPar ("NUM", 0, &Vsrc::Instance::NUM)
230  .setUnit(U_NONE)
231  .setCategory(CAT_NONE)
232  .setDescription("" );
233 }
234 
236 {
237 }
238 
239 
240 std::vector< std::vector<int> > Instance::jacStamp;
241 std::vector< std::vector<int> > Instance::jacStampPDE;
242 
243 // Class Instance
244 //-----------------------------------------------------------------------------
245 // Function : Instance::Instance
246 // Purpose : "instance block" constructor
247 // Special Notes :
248 // Scope : public
249 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
250 // Creation Date : 04/06/00
251 //-----------------------------------------------------------------------------
253  const Configuration & configuration,
254  const InstanceBlock & IB,
255  Model & Viter,
256  const FactoryBlock & factory_block)
257  : SourceInstance(IB, configuration.getInstanceParameters(), factory_block),
258  model_(Viter),
259  srcCurrent(0.0),
260  srcVoltage(0.0),
261  srcDrop(0.0),
262  srcBC(0.0),
263 
264  scale(1.0),
265  nlstep(-1),
266  ACSpecified_(factory_block.deviceManager_.getACSpecified()),
267  HBSpecified_(factory_block.deviceManager_.getHBSpecified()),
268  DCV0(0.0),
269  par0(0.0),
270  par1(0.0),
271  par2(0.0),
272  par3(0.0),
273  par4(0.0),
274  par5(0.0),
275  par6(0.0),
276  par7(0.0),
277  REPEATTIME(),
278  T(0.0),
279  V(0.0),
280  ACMAG(1.0),
281  ACPHASE(0.0),
282  NUM(0),
283  REPEAT(false),
284  TRANSIENTSOURCETYPE(_DC_DATA),
285  TRANSIENTSOURCETYPEgiven(false),
286  ACSOURCETYPE(_AC_DATA),
287  ACSOURCETYPEgiven(false),
288  DCSOURCETYPE(_AC_DATA),
289  DCSOURCETYPEgiven(false),
290 
291  li_Pos(-1),
292  li_Neg(-1),
293  li_Bra(-1),
294 
295  gotParams(false),
296 
297  ABraEquPosNodeOffset(-1),
298  ABraEquNegNodeOffset(-1),
299  APosEquBraVarOffset(-1),
300  ANegEquBraVarOffset(-1),
301  ABraEquBraVarOffset(-1),
302  APosEquPosNodeOffset(-1),
303  ANegEquNegNodeOffset(-1),
304 
306  fBraEquPosNodePtr(0),
307  fBraEquNegNodePtr(0),
308  fPosEquBraVarPtr(0),
309  fNegEquBraVarPtr(0),
310  fPosEquPosNodePtr(0),
311  fNegEquNegNodePtr(0),
312  fBraEquBraVarPtr(0),
313 #endif
314 
315  source(0.0),
316  v_pos(0.0),
317  v_neg(0.0),
318  i_bra(0.0),
319  li_branch_data(0)
320 {
321  numIntVars = 1;
322  numExtVars = 2;
323  numStateVars = 0;
324  setNumBranchDataVars(0); // by default don't allocate space in branch vectors
325  numBranchDataVarsIfAllocated = 1; // this is the space to allocate if lead current or power is needed.
326 
327  if( jacStamp.empty() )
328  {
329  jacStamp.resize(3);
330  jacStamp[0].resize(1);
331  jacStamp[0][0] = 2;
332  jacStamp[1].resize(1);
333  jacStamp[1][0] = 2;
334  jacStamp[2].resize(2);
335  jacStamp[2][0] = 0;
336  jacStamp[2][1] = 1;
337 
338  // PDE supporting stamp. This includes diagonal elements, needed by the
339  // 2-level Newton.
340  jacStampPDE.resize(3);
341  jacStampPDE[0].resize(2);
342  jacStampPDE[0][0] = 0;
343  jacStampPDE[0][1] = 2;
344  jacStampPDE[1].resize(2);
345  jacStampPDE[1][0] = 1;
346  jacStampPDE[1][1] = 2;
347  jacStampPDE[2].resize(3);
348  jacStampPDE[2][0] = 0;
349  jacStampPDE[2][1] = 1;
350  jacStampPDE[2][2] = 2;
351  }
352 
353  // Set params to constant default values:
354  setDefaultParams ();
355 
356  // Set params according to instance line and constant defaults from metadata:
357  setParams (IB.params);
358 
359  const SolverState &solver_state = factory_block.solverState_;
360  const DeviceOptions &device_options = factory_block.deviceOptions_;
361 
362  // Set any non-constant parameter defaults:
364  {
365  acSourceData_ = new ACData(*this, IB.params, solver_state, device_options);
366  }
367 
368  if (DCSOURCETYPEgiven) // this will always be given, if the source spec was valid.
369  {
370  dcSourceData_ = new ConstData(*this, IB.params, solver_state, device_options);
371  }
372 
374  {
375  switch (TRANSIENTSOURCETYPE)
376  {
377  case _SIN_DATA:
378  tranSourceData_ = new SinData(*this, IB.params, solver_state, device_options);
379  break;
380 
381  case _EXP_DATA:
382  tranSourceData_ = new ExpData(*this, IB.params, solver_state, device_options);
383  break;
384 
385  case _PULSE_DATA:
386  tranSourceData_ = new PulseData(*this, IB.params, solver_state, device_options);
387  break;
388 
389  case _PWL_DATA:
390  tranSourceData_ = new PWLinData(*this, IB.params, solver_state, device_options);
391  break;
392 
393  case _SFFM_DATA:
394  tranSourceData_ = new SFFMData(*this, IB.params, solver_state, device_options);
395  break;
396 
397  case _DC_DATA:
398  tranSourceData_ = 0; // this forces us to use the dcSourceData_ object instead
399  break;
400 
401  case _SMOOTH_PULSE_DATA:
402  tranSourceData_ = new SmoothPulseData(*this, IB.params, solver_state, device_options);
403  break;
404 
405  default:
406  UserFatal0(*this) << "Cannot identify source data type for " << getName();
407  break;
408  }
409  }
410 
411  processParams();
412 
413  // Calculate any parameters specified as expressions:
415  processParams();
416 
417  // calculate dependent (ie computed) params and check for errors:
418 
419 }
420 
421 //-----------------------------------------------------------------------------
422 // Function : Instance::processParams
423 // Purpose :
424 // Special Notes :
425 // Scope : public
426 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
427 // Creation Date : 07/26/03
428 //-----------------------------------------------------------------------------
430 {
431  if (gotParams)
432  {
433  if (dcSourceData_ != 0)
434  {
436  }
437  if (acSourceData_ != 0)
438  {
440  }
441  if (tranSourceData_ != 0)
442  {
444  }
445  }
446  else
447  {
448  if (dcSourceData_ != 0)
449  {
451  }
452  if (acSourceData_ != 0)
453  {
455  }
456  if (tranSourceData_ != 0)
457  {
459  }
460  gotParams = true;
461  }
462 
463  return true;
464 }
465 
466 //-----------------------------------------------------------------------------
467 // Function : Instance::~Instance
468 // Purpose : destructor
469 // Special Notes :
470 // Scope : public
471 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
472 // Creation Date : 04/06/00
473 //-----------------------------------------------------------------------------
475 {
476  delete tranSourceData_;
477  delete acSourceData_;
478  delete dcSourceData_;
479 }
480 
481 // Additional Declarations
482 
483 //-----------------------------------------------------------------------------
484 // Function : Instance::registerLIDs
485 // Purpose :
486 // Special Notes :
487 // Scope : public
488 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
489 // Creation Date : 6/20/02
490 //-----------------------------------------------------------------------------
491 void Instance::registerLIDs ( const std::vector<int> & intLIDVecRef,
492  const std::vector<int> & extLIDVecRef)
493 {
494  std::string msg;
495 
496  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
497  {
498  Xyce::dout() << std::endl << section_divider << std::endl;
499  Xyce::dout() << " VsrcInstance::registerLIDs" << std::endl;
500  Xyce::dout() << " name = " << getName() << std::endl;
501  }
502 
503  // Check if the size of the ID lists corresponds to the
504  // proper number of internal and external variables.
505  int numInt = intLIDVecRef.size();
506  int numExt = extLIDVecRef.size();
507 
508  if (numInt != numIntVars)
509  {
510  DevelFatal0(*this).in("Instance::registerLIDs") << "numInt != numIntVars";
511  }
512 
513  if (numExt != numExtVars)
514  {
515  DevelFatal0(*this).in("Instance::registerLIDs") << "numExt != numExtVars";
516  }
517 
518  // copy over the global ID lists.
519  intLIDVec = intLIDVecRef;
520  extLIDVec = extLIDVecRef;
521 
522  // Now use these lists to obtain the indices into the
523  // linear algebra entities. This assumes an order.
524  // For the matrix indices, first do the rows.
525 
526  li_Pos = extLIDVec[0];
527  li_Neg = extLIDVec[1];
528  li_Bra = intLIDVec[0];
529 
530  if (DEBUG_DEVICE && isActive(Diag::DEVICE_PARAMETERS) )
531  {
532  Xyce::dout() << " li_Pos = " << li_Pos << std::endl;
533  Xyce::dout() << " li_Neg = " << li_Neg << std::endl;
534  Xyce::dout() << " li_Bra = " << li_Bra << std::endl;
535  Xyce::dout() << section_divider << std::endl;
536  }
537 }
538 
539 //-----------------------------------------------------------------------------
540 // Function : Xyce::Device::Resistor::Instance::registerBranchDataLIDs
541 // Purpose :
542 // Special Notes :
543 // Scope : public
544 // Creator : Richard Schiek, Electrical Systems Modeling
545 // Creation Date : 12/18/2012
546 //-----------------------------------------------------------------------------
547 /// Register the local store IDs
548 ///
549 /// In addition to state vector, Xyce maintains a separate datastructure
550 /// called a "branch data" vector. As with other such vectors, the device
551 /// declares at construction time how many branch vector entries it needs,
552 /// and later Topology assigns locations for devices, returning LIDs.
553 ///
554 /// These LIDs are stored in this method for later use.
555 ///
556 /// The Voltage Source device uses exactly one "branch data vector" element, where
557 /// it keeps the "lead current" that may be used on .PRINT lines as
558 /// "I(V1)" for the current through resistor V1. and a junction voltage.
559 ///
560 ///
561 /// @param stoLIDVecRef Store variable local IDs
562 ///
563 /// @author Richard Schiek, Electrical Systems Modeling
564 /// @date 12/18/2012
565 void Instance::registerBranchDataLIDs(const std::vector<int> & branchLIDVecRef)
566 {
567  AssertLIDs(branchLIDVecRef.size() == getNumBranchDataVars());
568 
569  if (loadLeadCurrent)
570  {
571  li_branch_data= branchLIDVecRef[0];
572  }
573 }
574 
575 //-----------------------------------------------------------------------------
576 // Function : Instance::loadNodeSymbols
577 // Purpose :
578 // Special Notes :
579 // Scope : public
580 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
581 // Creation Date : 05/13/05
582 //-----------------------------------------------------------------------------
583 void Instance::loadNodeSymbols(Util::SymbolTable &symbol_table) const
584 {
585  addInternalNode(symbol_table, li_Bra, getName(), "branch");
586  if (loadLeadCurrent)
587  {
588  addBranchDataNode( symbol_table, li_branch_data, getName(), "BRANCH_D");
589  }
590 }
591 
592 //-----------------------------------------------------------------------------
593 // Function : Instance::registerStateLIDs
594 // Purpose :
595 // Special Notes :
596 // Scope : public
597 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
598 // Creation Date : 6/20/02
599 //-----------------------------------------------------------------------------
600 void Instance::registerStateLIDs( const std::vector<int> & staLIDVecRef )
601 {
602  AssertLIDs(staLIDVecRef.size() == numStateVars);
603 }
604 
605 //-----------------------------------------------------------------------------
606 // Function : Instance::jacobianStamp
607 // Purpose :
608 // Special Notes :
609 // Scope : public
610 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
611 // Creation Date : 8/21/02
612 //-----------------------------------------------------------------------------
613 const std::vector< std::vector<int> > & Instance::jacobianStamp() const
614 {
615  if (getSolverState().isPDESystem_)
616  return jacStampPDE;
617 
618  return jacStamp;
619 }
620 
621 //-----------------------------------------------------------------------------
622 // Function : Instance::registerJacLIDs
623 // Purpose :
624 // Special Notes :
625 // Scope : public
626 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
627 // Creation Date : 8/27/02
628 //-----------------------------------------------------------------------------
629 void Instance::registerJacLIDs( const std::vector< std::vector<int> > & jacLIDVec )
630 {
631  DeviceInstance::registerJacLIDs( jacLIDVec );
632  if (getSolverState().isPDESystem_)
633  {
634  APosEquBraVarOffset = jacLIDVec[0][1];
635  ANegEquBraVarOffset = jacLIDVec[1][1];
636  ABraEquPosNodeOffset = jacLIDVec[2][0];
637  ABraEquNegNodeOffset = jacLIDVec[2][1];
638  }
639  else
640  {
641  APosEquBraVarOffset = jacLIDVec[0][0];
642  ANegEquBraVarOffset = jacLIDVec[1][0];
643  ABraEquPosNodeOffset = jacLIDVec[2][0];
644  ABraEquNegNodeOffset = jacLIDVec[2][1];
645  }
646 
647 }
648 
649 //-----------------------------------------------------------------------------
650 // Function : Instance::setupPointers
651 // Purpose :
652 // Special Notes :
653 // Scope : public
654 // Creator : Eric Keiter, SNL
655 // Creation Date : 11/30/08
656 //-----------------------------------------------------------------------------
658 {
659 #ifndef Xyce_NONPOINTER_MATRIX_LOAD
660  Linear::Matrix & dFdx = *(extData.dFdxMatrixPtr);
661 
666 #endif
667 }
668 
669 //-----------------------------------------------------------------------------
670 // Function : Instance::updateIntermediateVars
671 // Purpose :
672 // Special Notes :
673 // Scope : public
674 // Creator : Eric Keiter, 9233, Computational Sciences
675 // Creation Date : 03/05/04
676 //-----------------------------------------------------------------------------
678 {
679  double * solVec = extData.nextSolVectorRawPtr;
680 
681  // Get the value for the source.
682  SourceData *dataPtr = dcSourceData_; // by default assume the DC value.
683  if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag) && tranSourceData_ != 0 )
684  {
685  dataPtr = tranSourceData_;
686  }
687 
688  if (dataPtr != 0)
689  {
690  source = dataPtr->returnSource();
691  }
692  else
693  {
694  source = 0.0;
695  }
696 
697  // get the value for v_pos, v_neg, i_bra
698  v_pos = solVec[li_Pos];
699  v_neg = solVec[li_Neg];
700  i_bra = solVec[li_Bra];
701 
702  srcCurrent = i_bra;
703  srcDrop = (v_pos-v_neg);
704  srcBC = source;
706 
707  if( getDeviceOptions().scale_src != 0.0 )
708  {
709  srcCurrent *= scale;
710 
711  // first newton step, generate new scaling
712  //if( nlsMgrPtr->getNonLinearIter() != nlstep )
713  if( getSolverState().newtonIter != nlstep )
714  {
715  //nlstep = nlsMgrPtr->getNonLinearIter();
717  double new_scale = fabs(i_bra) * scale;
718 
719  scale = std::max( new_scale, getDeviceOptions().scale_src );
720  }
721 
722  srcVoltage *= scale;
723  srcDrop *= scale;
724  srcBC *= scale;
725  }
726 
727  return true;
728 }
729 
730 //-----------------------------------------------------------------------------
731 // Function : Instance::updatePrimaryState
732 // Purpose :
733 // Special Notes :
734 // Scope : public
735 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
736 // Creation Date : 01/29/01
737 //-----------------------------------------------------------------------------
739 {
740  bool bsuccess = updateIntermediateVars ();
741  return bsuccess;
742 }
743 
744 //-----------------------------------------------------------------------------
745 // Function : Instance::loadDAEFVector
746 // Purpose : Loads the F-vector contributions for a single vsrc instance.
747 // Special Notes :
748 // Scope : public
749 // Creator : Eric Keiter, SNL
750 // Creation Date :
751 //-----------------------------------------------------------------------------
753 {
754  double * fVec = extData.daeFVectorRawPtr;
755 
756  fVec[li_Pos] += srcCurrent;
757  fVec[li_Neg] += -srcCurrent;
758  fVec[li_Bra] += srcDrop;
759 
760  if( loadLeadCurrent )
761  {
762  double * leadF = extData.nextLeadCurrFCompRawPtr;
763  double * junctionV = extData.nextJunctionVCompRawPtr;
764  leadF[li_branch_data] = srcCurrent;
765  junctionV[li_branch_data] = srcDrop;
766  }
767 
768  return true;
769 }
770 
771 //-----------------------------------------------------------------------------
772 // Function : Instance::loadDAEBVector
773 //
774 // Purpose : Loads the B-vector contributions for a single
775 // vsrc instance.
776 //
777 // Special Notes :
778 //
779 // Scope : public
780 // Creator : Eric Keiter, SNL
781 // Creation Date :
782 //-----------------------------------------------------------------------------
784 {
785  double * bVec = extData.daeBVectorRawPtr;
786  bVec[li_Bra] += srcBC;
787 
788  return true;
789 }
790 
791 //-----------------------------------------------------------------------------
792 // Function : Instance::loadBVectorsforAC
793 //
794 // Purpose : Loads the B-vector contributions for a single
795 // vsrc instance.
796 //
797 // Special Notes :
798 //
799 // Scope : public
800 // Creator : Ting Mei, SNL
801 // Creation Date : 5/11
802 //-----------------------------------------------------------------------------
803 bool Instance::loadBVectorsforAC(double * bVecReal, double * bVecImag )
804 {
805  if (acSourceData_ != 0)
806  {
807  bool flag = true;
808  acSourceData_->setRealFlag(flag);
809 
812  srcBC = source;
813 
814  if( getDeviceOptions().scale_src != 0.0 )
815  {
816  srcBC *= scale;
817  }
818 
819  bVecReal[li_Bra] += srcBC;
820 
821  flag = false;
822  acSourceData_->setRealFlag(flag);
823 
826  srcBC = source;
827 
828  if( getDeviceOptions().scale_src != 0.0 )
829  {
830  srcBC *= scale;
831  }
832 
833  bVecImag[li_Bra] += srcBC;
834  }
835 
836  return true;
837 }
838 
839 //-----------------------------------------------------------------------------
840 // Function : Instance::loadDAEdFdx ()
841 //
842 // Purpose : Loads the F-vector contributions for a single
843 // vsrc instance.
844 //
845 // Special Notes :
846 //
847 // Scope : public
848 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
849 // Creation Date : 03/05/04
850 //-----------------------------------------------------------------------------
852 {
853  Linear::Matrix & dFdx = *(extData.dFdxMatrixPtr);
854 
855  dFdx[li_Pos][APosEquBraVarOffset] += 1.0;
856  dFdx[li_Neg][ANegEquBraVarOffset] -= 1.0;
857  dFdx[li_Bra][ABraEquPosNodeOffset] += 1.0;
858  dFdx[li_Bra][ABraEquNegNodeOffset] -= 1.0;
859 
860  return true;
861 }
862 
863 // end of new-DAE functions
864 
865 //-----------------------------------------------------------------------------
866 // Function : Instance::getMaxTimeStepSize
867 // Purpose :
868 // Special Notes :
869 // Scope : public
870 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
871 // Creation Date : 07/23/03
872 //-----------------------------------------------------------------------------
874 {
875  double maxStep = 1.0e+100;
876  if (tranSourceData_ != 0)
877  {
878  maxStep = tranSourceData_->getMaxTimeStepSize ();
879  }
880  return maxStep;
881 }
882 
883 //-----------------------------------------------------------------------------
884 // Function : Instance::varTypes
885 // Purpose :
886 // Special Notes :
887 // Scope : public
888 // Creator : Rob Hoekstra, SNL, Parallel Computational Sciences
889 // Creation Date : 02/17/04
890 //-----------------------------------------------------------------------------
891 void Instance::varTypes( std::vector<char> & varTypeVec )
892 {
893  varTypeVec.resize(1);
894  varTypeVec[0] = 'I';
895 }
896 
897 // Class Model
898 
899 //-----------------------------------------------------------------------------
900 // Function : Model::Model
901 // Purpose : copy constructor
902 // Special Notes :
903 // Scope : public
904 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
905 // Creation Date : 04/06/00
906 //-----------------------------------------------------------------------------
908  const Configuration & configuration,
909  const ModelBlock & MB,
910  const FactoryBlock & factory_block)
911  : DeviceModel(MB, configuration.getModelParameters(), factory_block),
912  DC_TRAN (0)
913 {
914 }
915 
916 //-----------------------------------------------------------------------------
917 // Function : Model::~Model
918 // Purpose : destructor
919 // Special Notes :
920 // Scope : public
921 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
922 // Creation Date : 04/06/00
923 //-----------------------------------------------------------------------------
925 {
926  std::vector<Instance*>::iterator iter;
927  std::vector<Instance*>::iterator first = instanceContainer.begin();
928  std::vector<Instance*>::iterator last = instanceContainer.end();
929 
930  for (iter=first; iter!=last; ++iter)
931  {
932  delete (*iter);
933  }
934 }
935 
936 // Additional Declarations
937 
938 //-----------------------------------------------------------------------------
939 // Function : Model::printOutInstances
940 // Purpose : debugging tool.
941 // Special Notes :
942 // Scope : public
943 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
944 // Creation Date : 4/03/00
945 //-----------------------------------------------------------------------------
946 std::ostream &Model::printOutInstances(std::ostream &os) const
947 {
948  std::vector<Instance*>::const_iterator iter;
949  std::vector<Instance*>::const_iterator first = instanceContainer.begin();
950  std::vector<Instance*>::const_iterator last = instanceContainer.end();
951 
952  int i;
953  os << std::endl;
954  os << " name model name Parameters" << std::endl;
955  for (i=0, iter=first; iter!=last; ++iter, ++i)
956  {
957  os << " " << i << ": " << (*iter)->getName() << " ";
958  os << getName();
959  os << std::endl;
960  }
961 
962  os << std::endl;
963 
964  return os;
965 }
966 
967 //-----------------------------------------------------------------------------
968 // Function : Model::forEachInstance
969 // Purpose :
970 // Special Notes :
971 // Scope : public
972 // Creator : David Baur
973 // Creation Date : 2/4/2014
974 //-----------------------------------------------------------------------------
975 /// Apply a device instance "op" to all instances associated with this
976 /// model
977 ///
978 /// @param[in] op Operator to apply to all instances.
979 ///
980 ///
981 void Model::forEachInstance(DeviceInstanceOp &op) const /* override */
982 {
983  for (std::vector<Instance *>::const_iterator it = instanceContainer.begin(); it != instanceContainer.end(); ++it)
984  op(*it);
985 }
986 
987 
988 
989 //-----------------------------------------------------------------------------
990 // Vsrc Master functions:
991 //-----------------------------------------------------------------------------
992 
994  const Configuration & configuration,
995  const FactoryBlock & factory_block,
996  const SolverState & solver_state,
997  const DeviceOptions & device_options)
998  : DeviceMaster<Traits>(configuration, factory_block, solver_state, device_options),
999  HBSpecified_(factory_block.deviceManager_.getHBSpecified())
1000  {}
1001 
1002 //-----------------------------------------------------------------------------
1003 // Function : Master::updateState
1004 // Purpose :
1005 // Special Notes :
1006 // Scope : public
1007 // Creator : Eric Keiter, SNL
1008 // Creation Date : 11/26/08
1009 //-----------------------------------------------------------------------------
1010 bool Master::updateState (double * solVec, double * staVec, double * stoVec)
1011 {
1012  for (InstanceVector::const_iterator it = getInstanceBegin(); it != getInstanceEnd(); ++it)
1013  {
1014  Instance & vi = *(*it);
1015  // Get the value for the source.
1016  SourceData *dataPtr = vi.dcSourceData_; // by default assume the DC value.
1017  if ((HBSpecified_ || getSolverState().tranopFlag || getSolverState().transientFlag) && vi.tranSourceData_ != 0 )
1018  {
1019  dataPtr = vi.tranSourceData_;
1020  }
1021 
1022  if (dataPtr != 0)
1023  {
1024  vi.source = dataPtr->returnSource();
1025  }
1026  else
1027  {
1028  vi.source = 0.0;
1029  }
1030 
1031  // get the value for v_pos, v_neg, i_bra
1032  vi.v_pos = solVec[vi.li_Pos];
1033  vi.v_neg = solVec[vi.li_Neg];
1034  vi.i_bra = solVec[vi.li_Bra];
1035 
1036  vi.srcCurrent = vi.i_bra;
1037  vi.srcDrop = (vi.v_pos-vi.v_neg);
1038  vi.srcBC = vi.source;
1039  vi.srcVoltage = vi.srcDrop-vi.srcBC;
1040 
1041  if( getDeviceOptions().scale_src != 0.0 )
1042  {
1043  vi.srcCurrent *= vi.scale;
1044 
1045  // first newton step, generate new scaling
1046  if( getSolverState().newtonIter != vi.nlstep )
1047  {
1049  double new_scale = fabs(vi.i_bra) * vi.scale;
1050 
1051  vi.scale = std::max( new_scale, getDeviceOptions().scale_src );
1052  }
1053 
1054  vi.srcVoltage *= vi.scale;
1055  vi.srcDrop *= vi.scale;
1056  vi.srcBC *= vi.scale;
1057  }
1058  }
1059 
1060  return true;
1061 }
1062 
1063 //-----------------------------------------------------------------------------
1064 // Function : Master::loadDAEVectors
1065 // Purpose :
1066 // Special Notes :
1067 // Scope : public
1068 // Creator : Eric Keiter, SNL
1069 // Creation Date : 11/26/08
1070 //-----------------------------------------------------------------------------
1071 bool Master::loadDAEVectors (double * solVec, double * fVec, double *qVec, double * bVec, double * storeLeadF, double * storeLeadQ, double * leadF, double * leadQ, double * junctionV)
1072 {
1073  for (InstanceVector::const_iterator it = getInstanceBegin(); it != getInstanceEnd(); ++it)
1074  {
1075  Instance & vi = *(*it);
1076  fVec[vi.li_Pos] += vi.srcCurrent;
1077  fVec[vi.li_Neg] += -vi.srcCurrent;
1078  fVec[vi.li_Bra] += vi.srcDrop;
1079 
1080  bVec[vi.li_Bra] += vi.srcBC;
1081 
1082  if( vi.loadLeadCurrent )
1083  {
1084  leadF[vi.li_branch_data] = vi.srcCurrent;
1085  junctionV[vi.li_branch_data] = vi.srcDrop;
1086  }
1087 
1088  }
1089  return true;
1090 }
1091 
1092 //-----------------------------------------------------------------------------
1093 // Function : Master::loadDAEMatrices
1094 // Purpose :
1095 // Special Notes :
1096 // Scope : public
1097 // Creator : Eric Keiter, SNL
1098 // Creation Date : 11/26/08
1099 //-----------------------------------------------------------------------------
1100 bool Master::loadDAEMatrices (Linear::Matrix & dFdx, Linear::Matrix & dQdx)
1101 {
1102  for (InstanceVector::const_iterator it = getInstanceBegin(); it != getInstanceEnd(); ++it)
1103  {
1104  Instance & vi = *(*it);
1105 
1106 #ifndef Xyce_NONPOINTER_MATRIX_LOAD
1107  *(vi.fPosEquBraVarPtr) += 1.0;
1108  *(vi.fNegEquBraVarPtr) -= 1.0;
1109  *(vi.fBraEquPosNodePtr) += 1.0;
1110  *(vi.fBraEquNegNodePtr) -= 1.0;
1111 #else
1112  dFdx[vi.li_Pos][vi.APosEquBraVarOffset] += 1.0;
1113  dFdx[vi.li_Neg][vi.ANegEquBraVarOffset] -= 1.0;
1114  dFdx[vi.li_Bra][vi.ABraEquPosNodeOffset] += 1.0;
1115  dFdx[vi.li_Bra][vi.ABraEquNegNodeOffset] -= 1.0;
1116 #endif
1117  }
1118  return true;
1119 }
1120 
1121 Device *
1122 Traits::factory(const Configuration &configuration, const FactoryBlock &factory_block)
1123 {
1124  return new Master(configuration, factory_block, factory_block.solverState_, factory_block.deviceOptions_);
1125 }
1126 
1128 {
1130  .registerDevice("v", 1);
1131 }
1132 
1133 
1134 //-----------------------------------------------------------------------------
1135 // Function : dcVsrcSensitivity::operator
1136 // Purpose : produces df/dp and dq/dp, where p=DCV0.
1137 // Special Notes :
1138 // Scope : public
1139 // Creator : Eric Keiter, SNL
1140 // Creation Date : 7/18/2014
1141 //-----------------------------------------------------------------------------
1143  const ParameterBase &entity,
1144  const std::string & name,
1145  std::vector<double> & dfdp,
1146  std::vector<double> & dqdp,
1147  std::vector<double> & dbdp,
1148  std::vector<int> & Findices,
1149  std::vector<int> & Qindices,
1150  std::vector<int> & Bindices
1151  ) const
1152 {
1153  const ParameterBase * e1 = &entity;
1154  const Instance * in = dynamic_cast<const Instance *> (e1);
1155 
1156  dbdp.resize(1);
1157  dbdp[0] += 1.0;
1158  Bindices.resize(1);
1159  Bindices[0] = in->li_Bra;
1160 }
1161 
1162 } // namespace Vsrc
1163 } // namespace Device
1164 } // namespace Xyce
const InstanceName & getName() const
Master(const Configuration &configuration, const FactoryBlock &factory_block, const SolverState &solver_state, const DeviceOptions &device_options)
Definition: N_DEV_Vsrc.C:993
const DeviceOptions & deviceOptions_
Descriptor & addPar(const char *parName, T default_value, T U::*varPtr)
Adds the parameter description to the parameter map.
Definition: N_DEV_Pars.h:1429
void registerLIDs(const std::vector< int > &intLIDVecRef, const std::vector< int > &extLIDVecRef)
Definition: N_DEV_Vsrc.C:491
void registerJacLIDs(const std::vector< std::vector< int > > &jacLIDVec)
Definition: N_DEV_Vsrc.C:629
virtual std::ostream & printOutInstances(std::ostream &os) const
Definition: N_DEV_Vsrc.C:946
Pure virtual class to augment a linear system.
void addInternalNode(Util::SymbolTable &symbol_table, int index, const InstanceName &instance_name, const std::string &lead_name)
void addBranchDataNode(Util::SymbolTable &symbol_table, int index, const InstanceName &instance_name, const std::string &lead_name)
InstanceVector::const_iterator getInstanceEnd() const
Returns an iterator to the ending of the vector of all instances created for this device...
Base class for all parameters.
Definition: N_DEV_Pars.h:169
#define AssertLIDs(cmp)
virtual void registerJacLIDs(const JacobianStamp &jacLIDVec)
bool loadBVectorsforAC(double *bVecReal, double *bVecImag)
Definition: N_DEV_Vsrc.C:803
InstanceVector::const_iterator getInstanceBegin() const
Returns an iterator to the beginning of the vector of all instances created for this device...
virtual void operator()(const ParameterBase &entity, const std::string &name, 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_Vsrc.C:1142
void setParams(const std::vector< Param > &params)
DeviceMaster instantiates a device as described by the device traits T.
const std::string & getName() const
The FactoryBlock contains parameters needed by the device, instance and model creation functions...
Device::DeviceMgr & deviceManager_
Definition: N_ANP_HB.C:2199
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_Vsrc.C:1071
const DeviceOptions & getDeviceOptions() const
virtual double getMaxTimeStepSize()
virtual void getParams(double *)
static Config< T > & addConfiguration()
Adds the device to the Xyce device configuration.
void varTypes(std::vector< char > &varTypeVec)
Definition: N_DEV_Vsrc.C:891
Linear::Matrix * dFdxMatrixPtr
const DeviceOptions & getDeviceOptions() const
Returns the device options given during device construction.
The Device class is an interface for device implementations.
Definition: N_DEV_Device.h:101
static Device * factory(const Configuration &configuration, const FactoryBlock &factory_block)
Definition: N_DEV_Vsrc.C:1122
virtual bool updateState(double *solVec, double *staVec, double *stoVec)
Updates the devices state information.
Definition: N_DEV_Vsrc.C:1010
virtual bool loadDAEMatrices(Linear::Matrix &dFdx, Linear::Matrix &dQdx)
Populates the device's Jacobian object with these pointers.
Definition: N_DEV_Vsrc.C:1100
virtual void forEachInstance(DeviceInstanceOp &op) const
Apply a device instance "op" to all instances associated with this model.
Definition: N_DEV_Vsrc.C:981
void registerBranchDataLIDs(const std::vector< int > &branchLIDVecRef)
Register the local store IDs.
Definition: N_DEV_Vsrc.C:565
static std::vector< std::vector< int > > jacStampPDE
Definition: N_DEV_Vsrc.h:269
const SolverState & solverState_
Class Configuration contains device configuration data.
virtual void setRealFlag(bool flag)
std::vector< Instance * > instanceContainer
Definition: N_DEV_Vsrc.h:323
static void loadInstanceParameters(ParametricData< Instance > &instance_parameters)
Definition: N_DEV_Vsrc.C:70
const SolverState & getSolverState() const
static std::vector< std::vector< int > > jacStamp
Definition: N_DEV_Vsrc.h:268
void setNumBranchDataVars(int num_branch_data_vars)
#define Xyce_NONPOINTER_MATRIX_LOAD
Definition: N_DEV_Bsrc.C:97
virtual bool updateSource()=0
int li_branch_data
Index for Lead Current and junction voltage (for power calculations)
Definition: N_DEV_Vsrc.h:228
double scale_src
scaling for source loads
static void loadModelParameters(ParametricData< Model > &model_parameters)
Definition: N_DEV_Vsrc.C:235
ModelBlock represents a .MODEL line from the netlist.
Manages parameter binding for class C.
Definition: N_DEV_Pars.h:214
InstanceBlock represent a device instance line from the netlist.
std::vector< Param > params
void loadNodeSymbols(Util::SymbolTable &symbol_table) const
Populates and returns the store name map.
Definition: N_DEV_Vsrc.C:583
virtual void setParams(double *)
static dcVsrcSensitivity dcv0Sens
Definition: N_DEV_Vsrc.h:85
const std::vector< std::vector< int > > & jacobianStamp() const
Definition: N_DEV_Vsrc.C:613
Instance(const Configuration &configuration, const InstanceBlock &IB, Model &Viter, const FactoryBlock &factory_block)
Definition: N_DEV_Vsrc.C:252
const SolverState & getSolverState() const
Returns the solver state given during device construction.
void registerStateLIDs(const std::vector< int > &staLIDVecRef)
Definition: N_DEV_Vsrc.C:600