Xyce  6.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
N_DEV_ISRC.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-2014 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_ISRC.C,v $
27 //
28 // Purpose : Independent current source
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.178 $
40 //
41 // Revision Date : $Date: 2014/08/04 21:16:30 $
42 //
43 // Current Owner : $Author: erkeite $
44 //-------------------------------------------------------------------------
45 
46 #include <Xyce_config.h>
47 
48 
49 // ---------- Standard Includes ----------
50 #ifdef HAVE_CSTDIO
51 #include <cstdio>
52 #else
53 #include <stdio.h>
54 #endif
55 
56 // ---------- Xyce Includes ----------
57 #include <N_DEV_DeviceOptions.h>
58 #include <N_DEV_ExternData.h>
59 #include <N_DEV_ISRC.h>
60 #include <N_DEV_MatrixLoadData.h>
61 #include <N_DEV_SolverState.h>
62 #include <N_DEV_SourceData.h>
63 #include <N_DEV_Message.h>
64 #include <N_ERH_ErrorMgr.h>
65 
66 #include <N_LAS_Vector.h>
67 #include <N_LAS_Matrix.h>
68 
69 namespace Xyce {
70 namespace Device {
71 namespace ISRC {
72 
74 {
75  // DC parameters
76  p.addPar ("DCV0", 0.0, &ISRC::Instance::DCV0)
77  .setOriginalValueStored(true)
78  .setUnit(U_VOLT)
79  .setDescription("DC Current");
80 
81  // Pulse parameters
82  p.addPar ("V0", 0.0, &ISRC::Instance::par0)
83  .setUnit(U_AMP)
84  .setDescription("Offset Current");
85 
86  p.addPar ("V1", 0.0, &ISRC::Instance::par0)
87  .setUnit(U_AMP)
88  .setDescription("Initial Current");
89 
90  p.addPar ("V2", 0.0, &ISRC::Instance::par1)
91  .setUnit(U_AMP)
92  .setDescription("Pulsed Current");
93 
94  p.addPar ("TD", 0.0, &ISRC::Instance::par2)
95  .setUnit(U_SECOND)
96  .setDescription("Delay");
97 
98  p.addPar ("TR", 0.0, &ISRC::Instance::par3)
99  .setUnit(U_SECOND)
100  .setDescription("Rise Time");
101 
102  p.addPar ("TF", 0.0, &ISRC::Instance::par4)
103  .setUnit(U_SECOND)
104  .setDescription("Fall Time");
105 
106  p.addPar ("PW", 0.0, &ISRC::Instance::par5)
107  .setUnit(U_SECOND)
108  .setDescription("Pulse Width");
109 
110  p.addPar ("PER", 0.0, &ISRC::Instance::par6)
111  .setUnit(U_SECOND)
112  .setDescription("Period");
113 
114  p.addPar ("SF", 0.0, &ISRC::Instance::par7)
115  .setDescription("Scale Factor -- smooth pulse only");
116 
117  // Sin parameters
118  p.addPar ("VA", 0.0, &ISRC::Instance::par1)
119  .setUnit(U_AMP)
120  .setDescription("Amplitude");
121 
122  p.addPar ("FREQ", 0.0, &ISRC::Instance::par3)
123  .setUnit(U_SECM1)
124  .setDescription("Frequency");
125 
126  p.addPar ("THETA", 0.0, &ISRC::Instance::par4)
127  .setDescription("Theta");
128 
129  p.addPar ("PHASE", 0.0, &ISRC::Instance::par5)
130  .setDescription("Phase");
131 
132  // Exp parameters
133  p.addPar ("TD1", 0.0, &ISRC::Instance::par2)
134  .setUnit(U_SECOND)
135  .setDescription("Rise Delay Time");
136 
137  p.addPar ("TAU1", 0.0, &ISRC::Instance::par3)
138  .setUnit(U_SECOND)
139  .setDescription("Rise Time Constant");
140 
141  p.addPar ("TD2", 0.0, &ISRC::Instance::par4)
142  .setUnit(U_SECOND)
143  .setDescription("Fall Delay Time");
144 
145  p.addPar ("TAU2", 0.0, &ISRC::Instance::par5)
146  .setUnit(U_SECOND)
147  .setDescription("Fall Time Constant");
148 
149  // AC parameters
150  p.addPar ("ACMAG", 0.0, &ISRC::Instance::ACMAG)
151  .setUnit(U_VOLT)
152  .setDescription("Amplitude");
153 
154  p.addPar ("ACPHASE", 0.0, &ISRC::Instance::ACPHASE)
155  .setDescription("Phase");
156 
157  // SFFM parameters
158  p.addPar ("FC", 0.0, &ISRC::Instance::par2)
159  .setUnit(U_SECM1)
160  .setDescription("Carrier Frequency");
161 
162  p.addPar ("FS", 0.0, &ISRC::Instance::par4)
163  .setUnit(U_SECM1)
164  .setDescription("Signal Frequency");
165 
166  p.addPar ("MDI", 0.0, &ISRC::Instance::par3)
167  .setDescription("Modulation Index");
168 
169  // PWL params
170  p.addPar ("R", 0.0, &ISRC::Instance::REPEATTIME)
171  .setUnit(U_SECOND)
172  .setDescription("Repeat Time");
173 
174  p.addPar ("T", 0.0, &ISRC::Instance::T)
175  .setUnit(U_SECOND)
176  .setDescription("Time"); // time-voltage pairs
177 
178  p.addPar ("V", 0.0, &ISRC::Instance::V)
179  .setUnit(U_AMP)
180  .setDescription("Current"); // time-voltage pairs
181 
182  // Set up non-double precision variables:
183  p.addPar ("TRANSIENTSOURCETYPE", (int)_DC_DATA, &ISRC::Instance::TRANSIENTSOURCETYPE)
185 
186  p.addPar ("ACSOURCETYPE", (int) _AC_DATA, &ISRC::Instance::ACSOURCETYPE)
187  .setGivenMember(&ISRC::Instance::ACSOURCETYPEgiven);
188 
189  p.addPar ("DCSOURCETYPE", (int) _DC_DATA, &ISRC::Instance::DCSOURCETYPE)
190  .setGivenMember(&ISRC::Instance::DCSOURCETYPEgiven);
191 
192  p.addPar ("NUM", 0, &ISRC::Instance::NUM);
193 }
194 
196 {
197 }
198 
199 
200 std::vector< std::vector<int> > Instance::jacStamp;
201 
202 //-----------------------------------------------------------------------------
203 // Function : Instance::Instance
204 // Purpose : instance block constructor
205 // Special Notes :
206 // Scope : public
207 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
208 // Creation Date : 04/06/00
209 //-----------------------------------------------------------------------------
211  const Configuration & configuration,
212  const InstanceBlock & instance_block,
213  Model & model,
214  const FactoryBlock & factory_block)
215  : SourceInstance(instance_block, configuration.getInstanceParameters(), factory_block),
216  model_(model),
217  li_Pos(-1),
218  li_Neg(-1),
219  li_store_dev_i(-1),
220  DCV0(0.0),
221  par0(0.0),
222  par1(0.0),
223  par2(0.0),
224  par3(0.0),
225  par4(0.0),
226  par5(0.0),
227  par6(0.0),
228  par7(0.0),
229  REPEATTIME(),
230  T(0.0),
231  V(0.0),
232  ACMAG(1.0),
233  ACPHASE(0.0),
234  NUM(0),
235  REPEAT(false),
236  TRANSIENTSOURCETYPE(_DC_DATA),
237  TRANSIENTSOURCETYPEgiven(false),
238  ACSOURCETYPE(_AC_DATA),
239  ACSOURCETYPEgiven(false),
240  DCSOURCETYPE(_AC_DATA),
241  DCSOURCETYPEgiven(false),
242  gotParams(false)
243 {
244  numIntVars = 0;
245  numExtVars = 2;
246  numStateVars = 0;
247  numLeadCurrentStoreVars = 1; // lead current DEV_I
248 
249  if( jacStamp.empty() )
250  jacStamp.resize(2);
251 
252  // Set params to constant default values:
253  setDefaultParams ();
254 
255  // Set params according to instance line and constant defaults from metadata:
256  setParams (instance_block.params);
257 
258  // Set any non-constant parameter defaults:
259 
260  if (getSolverState().ACspecified && ACSOURCETYPEgiven)
261  {
262  acSourceData_ = new ACData (instance_block.params,getSolverState(),getDeviceOptions());
263  }
264 
265  if (DCSOURCETYPEgiven) // this will always be given, if the source spec was valid.
266  {
267  dcSourceData_ = new ConstData (instance_block.params,getSolverState(),getDeviceOptions());
268  }
269 
270  if (getSolverState().HBspecified || TRANSIENTSOURCETYPEgiven)
271  {
272  switch (TRANSIENTSOURCETYPE)
273  {
274  case _SIN_DATA:
275  tranSourceData_ = new SinData (instance_block.params,getSolverState(),getDeviceOptions());
276  break;
277 
278  case _EXP_DATA:
279  tranSourceData_ = new ExpData (instance_block.params,getSolverState(),getDeviceOptions());
280  break;
281 
282  case _PULSE_DATA:
284  break;
285 
286  case _PWL_DATA:
288  break;
289 
290  case _SFFM_DATA:
292  break;
293 
294  case _DC_DATA:
296  break;
297 
298  case _SMOOTH_PULSE_DATA:
300  break;
301 
302  default:
303  UserError0(*this) << "Cannot identify source data type for " << getName();
304  break;
305  }
306  }
307 
308  processParams();
309 
310  // Calculate any parameters specified as expressions:
311 
313  processParams();
314 
315  // calculate dependent (ie computed) params and check for errors:
316 
317 
318 }
319 
320 //-----------------------------------------------------------------------------
321 // Function : Instance::processParams
322 // Purpose :
323 // Special Notes :
324 // Scope : public
325 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
326 // Creation Date : 04/06/00
327 //-----------------------------------------------------------------------------
329 {
330  if (gotParams)
331  {
332  if (dcSourceData_ != 0)
333  {
335  }
336  if (acSourceData_ != 0)
337  {
339  }
340  if (tranSourceData_ != 0)
341  {
343  }
344  }
345  else
346  {
347  if (dcSourceData_ != 0)
348  {
350  }
351  if (acSourceData_ != 0)
352  {
354  }
355  if (tranSourceData_ != 0)
356  {
358  }
359  gotParams = true;
360  }
361 
362  return true;
363 }
364 
365 //-----------------------------------------------------------------------------
366 // Function : Instance::~Instance
367 // Purpose : destructor
368 // Special Notes :
369 // Scope : public
370 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
371 // Creation Date : 04/06/00
372 //-----------------------------------------------------------------------------
374 {
375  delete tranSourceData_;
376  delete acSourceData_;
377  delete dcSourceData_;
378 }
379 
380 // additional Declarations
381 //-----------------------------------------------------------------------------
382 // Function : Instance::registerLIDs
383 // Purpose :
384 // Special Notes :
385 // Scope : public
386 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
387 // Creation Date : 6/20/02
388 //-----------------------------------------------------------------------------
389 void Instance::registerLIDs( const std::vector<int> & intLIDVecRef,
390  const std::vector<int> & extLIDVecRef)
391 {
392  AssertLIDs(intLIDVecRef.size() == numIntVars);
393  AssertLIDs(extLIDVecRef.size() == numExtVars);
394 
395 #ifdef Xyce_DEBUG_DEVICE
396  if (getDeviceOptions().debugLevel > 0 )
397  {
398  Xyce::dout() << std::endl << section_divider << std::endl;
399  Xyce::dout() << " ISRCInstance::registerLIDs" << std::endl;
400  Xyce::dout() << " name = " << getName() << std::endl;
401  }
402 #endif
403 
404  intLIDVec = intLIDVecRef;
405  extLIDVec = extLIDVecRef;
406 
407  // Now use these lists to obtain the indices into the
408  // linear algebra entities. This assumes an order. Note that
409  // for a current source, there will be no Jacobian entries.
410 
411  li_Pos = extLIDVec[0];
412  li_Neg = extLIDVec[1];
413 
414 #ifdef Xyce_DEBUG_DEVICE
415  if (getDeviceOptions().debugLevel > 0 )
416  {
417  Xyce::dout() << " li_Pos = " << li_Pos << std::endl;
418  Xyce::dout() << " li_Neg = " << li_Neg << std::endl;
419  Xyce::dout() << section_divider << std::endl;
420  }
421 #endif
422 
423 }
424 
425 //-----------------------------------------------------------------------------
426 // Function : Instance::registerStateLIDs
427 // Purpose :
428 // Special Notes :
429 // Scope : public
430 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
431 // Creation Date : 6/20/02
432 //-----------------------------------------------------------------------------
433 void Instance::registerStateLIDs(const std::vector<int> & staLIDVecRef )
434 {
435  AssertLIDs(staLIDVecRef.size() == numStateVars);
436 }
437 
438 //-----------------------------------------------------------------------------
439 // Function : Instance::registerStoreLIDs
440 // Purpose : One store var for device current.
441 // Special Notes :
442 // Scope : public
443 // Creator : Richard Schiek, Electrical Systems Modeling
444 // Creation Date : 03/27/2013
445 //-----------------------------------------------------------------------------
446 void Instance::registerStoreLIDs(const std::vector<int> & stoLIDVecRef )
447 {
448  AssertLIDs(stoLIDVecRef.size() == getNumStoreVars());
449 
450  if( loadLeadCurrent )
451  {
452  li_store_dev_i = stoLIDVecRef[0];
453  }
454 }
455 
456 
457 //-----------------------------------------------------------------------------
458 // Function : Instance::getStoreNameMap
459 // Purpose :
460 // Special Notes :
461 // Scope : public
462 // Creator : Richard Schiek, Electrical Systems Modeling
463 // Creation Date : 03/27/2013
464 //-----------------------------------------------------------------------------
465 std::map<int,std::string> & Instance::getStoreNameMap ()
466 {
467  // set up the internal name map, if it hasn't been already.
468  if( loadLeadCurrent && storeNameMap.empty ())
469  {
471  }
472 
473  return storeNameMap;
474 }
475 
476 
477 //-----------------------------------------------------------------------------
478 // Function : Instance::jacobianStamp
479 // Purpose :
480 // Special Notes :
481 // Scope : public
482 // Creator : Robert Hoekstra, SNL, Parallel Computational Sciences
483 // Creation Date : 9/5/2
484 //-----------------------------------------------------------------------------
485 const std::vector< std::vector<int> > & Instance::jacobianStamp() const
486 {
487  return jacStamp;
488 }
489 
490 //-----------------------------------------------------------------------------
491 // Function : Instance::loadBVectorsforAC
492 //
493 // Purpose : Loads the B-vector contributions for a single
494 // isrc instance.
495 //
496 // Special Notes :
497 //
498 // Scope : public
499 // Creator : Ting Mei, SNL
500 // Creation Date : 5/11
501 //-----------------------------------------------------------------------------
502 bool Instance::loadBVectorsforAC(double * bVecReal, double * bVecImag )
503 {
504  if (acSourceData_ != 0)
505  {
506  bool flag = true;
507  acSourceData_->setRealFlag(flag);
508 
510  double source = acSourceData_->returnSource();
511 
512  bVecReal[li_Pos] -= source;
513  bVecReal[li_Neg] += source;
514 
515  flag = false;
516  acSourceData_->setRealFlag(flag);
517 
519  source = acSourceData_->returnSource();
520 
521  bVecImag[li_Pos] -= source;
522  bVecImag[li_Neg] += source;
523  }
524 
525  return true;
526 }
527 
528 //-----------------------------------------------------------------------------
529 // Function : Instance::updatePrimaryState
530 // Purpose :
531 // Special Notes :
532 // Scope : public
533 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
534 // Creation Date : 01/29/01
535 //-----------------------------------------------------------------------------
537 {
538  return true;
539 }
540 
541 //-----------------------------------------------------------------------------
542 // Function : Instance::loadDAEFVector
543 // Purpose : Loads the F-vector contributions for a single
544 // ISRC instance.
545 // Special Notes :
546 // Scope : public
547 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
548 // Creation Date : 03/05/04
549 //-----------------------------------------------------------------------------
551 {
552  bool bsuccess = true;
553 
554 #ifndef SEPARATE_F_AND_B
555  double * fVec = extData.daeFVectorRawPtr;
556 
557  // get the source value:
558  SourceData *dataPtr = dcSourceData_; // by default assume the DC value.
559  if ( (getSolverState().HBspecified || getSolverState().tranopFlag || getSolverState().transientFlag) && tranSourceData_ != 0 )
560  {
561  dataPtr = tranSourceData_;
562  }
563 
564  double source = 0.0;
565  if (dataPtr != 0)
566  {
567  source = dataPtr->returnSource();
568  }
569  fVec[li_Pos] += source;
570  fVec[li_Neg] -= source;
571 
572  if( loadLeadCurrent )
573  {
574  double * stoVec = extData.nextStoVectorRawPtr;
575  stoVec[li_store_dev_i] = source;
576  }
577 #endif
578 
579  return bsuccess;
580 }
581 
582 
583 //-----------------------------------------------------------------------------
584 // Function : Instance::loadDAEBVector
585 // Purpose : Loads the F-vector contributions for a single
586 // ISRC instance.
587 // Special Notes :
588 // Scope : public
589 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
590 // Creation Date : 03/05/04
591 //-----------------------------------------------------------------------------
593 {
594  bool bsuccess = true;
595 
596  double * bVec = extData.daeBVectorRawPtr;
597 
598  // get the source value:
599  SourceData *dataPtr = dcSourceData_; // by default assume the DC value.
600  if ( (getSolverState().HBspecified || getSolverState().tranopFlag || getSolverState().transientFlag) && tranSourceData_ != 0 )
601  {
602  dataPtr = tranSourceData_;
603  }
604 
605  double source = 0.0;
606  if (dataPtr != 0)
607  {
608  source = dataPtr->returnSource();
609  }
610  bVec[li_Pos] -= source;
611  bVec[li_Neg] += source;
612 
613  if( loadLeadCurrent )
614  {
615  double * stoVec = extData.nextStoVectorRawPtr;
616  stoVec[li_store_dev_i] = source;
617  }
618 
619  return bsuccess;
620 }
621 
622 
623 
624 //-----------------------------------------------------------------------------
625 // Function : Model::Model
626 // Purpose : copy constructor
627 // Special Notes :
628 // Scope : public
629 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
630 // Creation Date : 04/06/00
631 //-----------------------------------------------------------------------------
633  const Configuration & configuration,
634  const ModelBlock & MB,
635  const FactoryBlock & factory_block)
636  : DeviceModel(MB, configuration.getModelParameters(), factory_block)
637 {
638 
639 }
640 
641 //-----------------------------------------------------------------------------
642 // Function : Model::~Model
643 // Purpose : destructor
644 // Special Notes :
645 // Scope : public
646 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
647 // Creation Date : 04/06/00
648 //-----------------------------------------------------------------------------
650 {
651  std::vector<Instance*>::iterator iter;
652  std::vector<Instance*>::iterator first = instanceContainer.begin();
653  std::vector<Instance*>::iterator last = instanceContainer.end();
654 
655  for (iter=first; iter!=last; ++iter)
656  {
657  delete (*iter);
658  }
659 }
660 
661 // additional Declarations
662 
663 //----------------------------------------------------------------------------
664 // Function : Model::processParams
665 // Purpose :
666 // Special Notes :
667 // Scope : public
668 // Creator : Lon Waters
669 // Creation Date : 07/29/2002
670 //----------------------------------------------------------------------------
672 {
673  return true;
674 }
675 
676 //----------------------------------------------------------------------------
677 // Function : Model::processInstanceParams
678 // Purpose :
679 // Special Notes :
680 // Scope : public
681 // Creator : Dave Shirely, PSSI
682 // Creation Date : 03/23/06
683 //----------------------------------------------------------------------------
685 {
686 
687  std::vector<Instance*>::iterator iter;
688  std::vector<Instance*>::iterator first = instanceContainer.begin();
689  std::vector<Instance*>::iterator last = instanceContainer.end();
690 
691  for (iter=first; iter!=last; ++iter)
692  {
693  (*iter)->processParams();
694  }
695 
696  return true;
697 }
698 
699 //-----------------------------------------------------------------------------
700 // Function : Model::printOutInstances
701 // Purpose : debugging tool.
702 // Special Notes :
703 // Scope : public
704 // Creator : Eric Keiter, SNL, Parallel Computational Sciences
705 // Creation Date : 4/03/00
706 //-----------------------------------------------------------------------------
707 std::ostream &Model::printOutInstances(std::ostream &os) const
708 {
709 #ifdef Xyce_DEBUG_DEVICE
710 
711  std::vector<Instance*>::const_iterator iter;
712  std::vector<Instance*>::const_iterator first = instanceContainer.begin();
713  std::vector<Instance*>::const_iterator last = instanceContainer.end();
714 
715  int i;
716  os << std::endl;
717  os << " name modelName Parameters" << std::endl;
718  for (i=0, iter=first; iter!=last; ++iter, ++i)
719  {
720  os << " " << i << ": " << (*iter)->getName() << " ";
721  os << getName();
722  os << std::endl;
723  if ( (*iter)->tranSourceData_ != 0 )
724  {
725  (*iter)->tranSourceData_->printOutParams ();
726  }
727 
728  if ( (*iter)->dcSourceData_ != 0 )
729  {
730  (*iter)->dcSourceData_->printOutParams ();
731  }
732 
733  if ( (*iter)->acSourceData_ != 0 )
734  {
735  (*iter)->acSourceData_->printOutParams ();
736  }
737  }
738 
739  os << std::endl;
740 #endif
741  return os;
742 }
743 
744 //-----------------------------------------------------------------------------
745 // Function : Model::forEachInstance
746 // Purpose :
747 // Special Notes :
748 // Scope : public
749 // Creator : David Baur
750 // Creation Date : 2/4/2014
751 //-----------------------------------------------------------------------------
752 /// Apply a device instance "op" to all instances associated with this
753 /// model
754 ///
755 /// @param[in] op Operator to apply to all instances.
756 ///
757 ///
758 void Model::forEachInstance(DeviceInstanceOp &op) const /* override */
759 {
760  for (std::vector<Instance *>::const_iterator it = instanceContainer.begin(); it != instanceContainer.end(); ++it)
761  op(*it);
762 }
763 
764 //-----------------------------------------------------------------------------
765 // ISRC Master functions:
766 //-----------------------------------------------------------------------------
767 
768 //-----------------------------------------------------------------------------
769 // Function : Master::updateState
770 // Purpose :
771 // Special Notes :
772 // Scope : public
773 // Creator : Eric Keiter, SNL
774 // Creation Date : 11/26/08
775 //-----------------------------------------------------------------------------
776 bool Master::updateState (double * solVec, double * staVec, double * stoVec)
777 {
778  return true;
779 }
780 
781 //-----------------------------------------------------------------------------
782 // Function : Master::loadDAEVectors
783 // Purpose :
784 // Special Notes :
785 // Scope : public
786 // Creator : Eric Keiter, SNL
787 // Creation Date : 11/26/08
788 //-----------------------------------------------------------------------------
789 bool Master::loadDAEVectors (double * solVec, double * fVec, double *qVec, double * bVec, double * storeLeadF, double * storeLeadQ)
790 {
791  for (InstanceVector::const_iterator it = getInstanceBegin(); it != getInstanceEnd(); ++it)
792  {
793  Instance & inst = *(*it);
794 
795  SourceData *dataPtr = inst.dcSourceData_; // by default assume the DC value.
796  if ( (getSolverState().HBspecified || getSolverState().tranopFlag || getSolverState().transientFlag) && inst.tranSourceData_ != 0 )
797  {
798  dataPtr = inst.tranSourceData_;
799  }
800 
801  double source = 0.0;
802  if (dataPtr != 0)
803  {
804  source = dataPtr->returnSource();
805  }
806 #ifndef SEPARATE_F_AND_B
807  fVec[inst.li_Pos] += source;
808  fVec[inst.li_Neg] -= source;
809 #else
810  bVec[inst.li_Pos] -= source;
811  bVec[inst.li_Neg] += source;
812 #endif
813 
814  // Note that the SEPARATE F and B implementation has not been extended
815  // to lead currents yet. So, no storeLeadB vector available.
816  if( inst.loadLeadCurrent )
817  {
818  storeLeadF[inst.li_store_dev_i] = source;
819  }
820 
821  }
822  return true;
823 }
824 
825 //-----------------------------------------------------------------------------
826 // Function : Master::loadDAEMatrices
827 // Purpose :
828 // Special Notes :
829 // Scope : public
830 // Creator : Eric Keiter, SNL
831 // Creation Date : 11/26/08
832 //-----------------------------------------------------------------------------
833 bool Master::loadDAEMatrices (N_LAS_Matrix & dFdx, N_LAS_Matrix & dQdx)
834 {
835  return true;
836 }
837 
838 
839 Device *Traits::factory(const Configuration &configuration, const FactoryBlock &factory_block)
840 {
841  return new DeviceMaster<Traits>(configuration, factory_block, factory_block.solverState_, factory_block.deviceOptions_);
842 }
843 
845 {
847  .registerDevice("i", 1);
848 }
849 
850 } // namespace Resistor
851 } // namespace Device
852 } // namespace Xyce