Xyce  6.1
N_ANP_AnalysisManager.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_ANP_AnalysisManager.h,v $
27 //
28 // Purpose :
29 //
30 // Special Notes :
31 //
32 // Creator : Richard Schiek, SNL, Electrical and Microsystem Modeling
33 //
34 // Creation Date : 01/24/08
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.150.2.1 $
40 //
41 // Revision Date : $Date: 2015/04/02 18:20:06 $
42 //
43 // Current Owner : $Author: tvrusso $
44 //-----------------------------------------------------------------------------
45 
46 #ifndef Xyce_N_ANP_AnalysisManager_h
47 #define Xyce_N_ANP_AnalysisManager_h
48 
49 #include <list>
50 
51 #include <N_ANP_fwd.h>
52 #include <N_DEV_fwd.h>
53 #include <N_IO_fwd.h>
54 #include <N_LAS_fwd.h>
55 #include <N_LOA_fwd.h>
56 #include <N_NLS_fwd.h>
57 #include <N_PDS_fwd.h>
58 #include <N_TIA_fwd.h>
59 #include <N_TOP_fwd.h>
60 #include <N_UTL_fwd.h>
61 
62 #include <N_ANP_AnalysisBase.h>
63 #include <N_ANP_AnalysisEvent.h>
64 #include <N_ANP_Factory.h>
65 #include <N_ANP_StepEvent.h>
66 #include <N_TIA_TIAParams.h>
67 #include <N_UTL_Listener.h>
68 #include <N_UTL_Stats.h>
69 #include <N_UTL_Timer.h>
70 
71 namespace Xyce {
72 namespace Analysis {
73 
74 typedef std::vector<Factory<void> *> CreatorVector;
75 typedef Util::Notifier<StepEvent> StepEventNotifier;
76 typedef Util::Notifier<AnalysisEvent> AnalysisEventNotifier;
77 typedef Util::ListenerAutoSubscribe<StepEvent> StepEventListener;
78 typedef Util::ListenerAutoSubscribe<AnalysisEvent> AnalysisEventListener;
79 
80 //-----------------------------------------------------------------------------
81 // Class :
82 // Purpose : This function converts between Nonlinear::AnalysisMode
83 // : and AnalysisManager.h ANP_Analysis_Mode
84 // Special Notes :
85 // Creator : Todd Coffey, 1414
86 // Creation Date : 07/23/08
87 //-----------------------------------------------------------------------------
89 
90 //-----------------------------------------------------------------------------
91 // Function : analysisModeName
92 // Purpose :
93 // Special Notes :
94 // Scope : public
95 // Creator : David G. Baur Raytheon Sandia National Laboratories 1355
96 // Creation Date : Mon Mar 16 13:56:09 2015
97 //-----------------------------------------------------------------------------
98 ///
99 /// Returns the name of the analysis mode given by mode.
100 ///
101 /// @param mode Analysis mode
102 ///
103 /// @return name of the mode
104 ///
105 ///
106 const char *analysisModeName(Mode mode);
107 
108 //-----------------------------------------------------------------------------
109 // Class : AnalysisManager
110 //
111 // Purpose : This class manages, allocates, and sets up the
112 // various analysis types, such as DC, Tran, HB, etc.
113 //
114 // Special Notes : Some of this class was once in the TimeIntg::ControlAlgorithm
115 // class, which was set up back when Xyce only did transient
116 // simulations. As we added analysis types it became necessary
117 // to refactor the code so that each analysis type had its own
118 // set of classes.
119 //
120 // Creator : Eric Keiter, SNL
121 // Creation Date : 6/01/00 (TimeIntg::ControlAlgorithm, now deprecated)
122 // Creation Date : 1/24/08 (for this version of the class. Date is approximate)
123 //-----------------------------------------------------------------------------
124 class AnalysisManager : public StepEventNotifier,
125  public AnalysisEventNotifier,
126  public StepEventListener,
127  public AnalysisEventListener
128 {
129 public:
131  const IO::CmdParse & command_line,
132  IO::RestartMgr & restart_manager,
133  OutputMgrAdapter & output_manager_adapter,
134  Stats::Stat analysis_stat);
135  virtual ~AnalysisManager();
136 
137 private:
140 
141 public:
142  void notify(const StepEvent &step_event);
143  void notify(const AnalysisEvent &analysis_event);
144 
146 
147  void allocateAnalysisObject();
148 
150  const TimeIntg::TIAParams & tia_params,
151  Loader::Loader & loader,
152  Linear::System & linear_system,
153  Nonlinear::Manager & nonlinear_manager,
154  Device::DeviceMgr & device_manager);
155 
156  void resetSolverSystem();
157 
158  // Execute the control loop for the set analysis type.
159  bool run();
160 
161  // Gets the next time-step value.
162  double getTime() const;
163 
164  // Gets the final time-step value.
165  double getFinalTime() const;
166 
167  // Gets the initial time-step value.
168  double getInitialTime() const;
169 
170  // Updates the divided difference values.
171  bool updateDivDiffs();
172 
173  // Calls the time int. method to update the corrector derivatives.
174  bool updateDerivs();
175 
176  // updates state vectors following initial solve with previous operating point constraints
177  bool completeOPStartStep();
178 
179  // updates the State vectors. This function is called from the LOCA interface.
182  const std::vector<std::string> & paramNames,
183  const std::vector<double> & paramVals,
184  Linear::Vector * solnVecPtr );
185 
187 
188  // Compute an estimate of the error in the integration step.
189  bool updateDerivsBlock(const std::list< IndexPair > & solGIDList,
190  const std::list< IndexPair > & staGIDList);
191 
192  // Prints out time loop information.
193  bool printLoopInfo(int start, int finish);
194 
195  // Get the steady-state flag (true if time int mode is none)
196  bool getDCOPFlag() const;
197 
198  // Get the dcop flag for transient.(true if doing DCOP for transient initialization)
199  bool getTranOPFlag() const;
200 
201  // Get the dcop flag for AC.(true if doing DCOP for AC initialization)
202  bool getACOPFlag() const;
203 
204  bool getDCSweepFlag() const;
205 
207  {
208  return dotOpSpecified_;
209  }
210 
212  {
213  return sweepSourceResetFlag_;
214  }
215 
216  void setSweepSourceResetFlag (bool ssrf) {
217  sweepSourceResetFlag_ = ssrf;
218  }
219 
220  bool getTransientFlag () const;
221 
222  // Is the doubleDCOP algorithm enabled?
223  bool getDoubleDCOPEnabled() const;
224 
225  void setTwoLevelMode(TwoLevelMode current_mode) {
226  twoLevelMode_ = current_mode;
227  }
228 
230  return twoLevelMode_;
231  }
232 
233  // Get block analysis information for HB
234  bool getBlockAnalysisFlag() const;
235 
236  // gets the index of the DCOP step.
237  // 0 = nonlinear poisson, 1=full TCAD
238  int getDoubleDCOPStep() const;
239 
240  // Gets/sets the step number.
241  int getStepNumber() const;
242  int getTranStepNumber();
243 
244  void setStepNumber(int step);
245  void setTranStepNumber(int step);
246 
247  // This is true only at the beginning of integration, not at a breakpoint.
248  bool getInitTranFlag() const;
249 
250  const IO::CmdParse &getCommandLine() const {
251  return commandLine_;
252  }
253 
254  const std::string &getNetlistFilename() const
255  {
256  return netlistFilename_;
257  }
258 
259  // returns whether transient analysis is completed
260  bool isSimulationComplete();
261 
262  // Gets the size of the restart data (bytes?).
263  int getRestartDataSize( bool pack ) const;
264 
265  // Sets the DC sweep calculation parameters.
266  bool setDCAnalysisParams(const Util::OptionBlock & paramsBlock);
267 
268  // Method to handle OP statements.
269  bool setOPAnalysisParams(const Util::OptionBlock & paramsBlock);
270 
271  // Sets the SAVE parameters.
272  bool setSaveOptions(const Util::OptionBlock & OB);
273 
274  // Sets the DCOP restart parameters.
275  bool setDCOPRestartParams(const Util::OptionBlock & OB);
276 
277  // Sets the AC Analysis options.
278  bool setACAnalysisParams(const Util::OptionBlock & OB);
279 
280  // Sets the NOISE Analysis options.
281  bool setNOISEAnalysisParams(const Util::OptionBlock & OB);
282 
283  // sets a time at which to pause the simulation
284  void setPauseTime(double pauseTime, double initial_time);
285 
286  // returns time at which to pause the simulation
287  double getPauseTime() const;
288 
289  // returns true if the simulation is currently paused
290  bool isPaused() const;
291 
292  //-----------------------------------------------------------------------------
293  // Function : AnalysisManager::resumeSimulation
294  //
295  // Purpose : set flag to signify that simulation is continuation of
296  // previously paused simulation.
297  //
298  // Special Notes : This is a temporary implementation that I'm using to
299  // begin the process of hiding time integrator internals from
300  // the "N_CIR_Xyce::simulateUntil" method, so that I can
301  // ultimately change those internals without the simulateUntil
302  // method
303  // In the zero order version, just sets tiaParams_.resume=true
304  // Scope : public
305  // Creator : Tom Russo, SNL, Component Information and Models
306  // Creation Date : 04/29/2004
307  //-----------------------------------------------------------------------------
308  void setResumeSimulation(bool resume)
309  {
310  resumeSimulation_ = resume;
311  }
312 
313  // Sets the sensitivity options.
314  bool setSensOptions(const Util::OptionBlock & OB);
315 
316  // sets the nonlinear loader pointer.
318 
319  // Registers the parallel services manager pointer.
320  bool registerParallelServices(Parallel::Manager * pds_tmp);
321 
322  // Registers the elapsed time timer
323  bool registerElapsedTimer(Util::Timer *);
324 
325  // Writes-out the restart data.
326  bool dumpRestartData(char * buf, int bsize, int & pos, Parallel::Communicator * comm, bool pack);
327 
328  // Restores the restart data.
329  bool restoreRestartData(char * buf, int bsize, int & pos, Parallel::Communicator * comm, bool pack );
330 
331  // Gets the solution variable data.
332  bool getSolnVarData(const int & gid, std::vector< double > & varData) const;
333 
334  // Gets the state variable data.
335  bool getStateVarData(const int & gid, std::vector< double > & varData) const;
336 
337  // Gets the store variable data.
338  bool getStoreVarData(const int & gid, std::vector< double > & varData) const;
339 
340  // Sets the solution variable data.
341  bool setSolnVarData(const int & gid, const std::vector< double > & varData);
342 
343  // Sets the state variable data.
344  bool setStateVarData(const int & gid, const std::vector< double > & varData);
345 
346  // Sets the store variable data.
347  bool setStoreVarData(const int & gid, const std::vector< double > & varData);
348 
349  // set/get beginning integration flag
350  void setBeginningIntegrationFlag(bool bif);
351  bool getBeginningIntegrationFlag() const;
352 
353  // set/get integration method
354  void setIntegrationMethod(int im);
355  int getIntegrationMethod();
356 
357  // Gets the total time spent in the linear solvers.
358  double getTotalLinearSolutionTime() const;
359 
360  // Gets the total time spent in the residual load calculations.
361  double getTotalResidualLoadTime() const;
362 
363  // Gets the total time spent in the Jacobian load calculations.
364  double getTotalJacobianLoadTime() const;
365 
366  // set the next solution vector pointer. Needed for NOX...
367  bool setNextSolVectorPtr (Linear::Vector * solVecPtr);
368 
369  void initializeTransientModel(const TimeIntg::TIAParams &tia_params);
370 
371  void createTimeIntegratorMethod(const TimeIntg::TIAParams &tia_params, const unsigned int integration_method);
372 
373  //-----------------------------------------------------------------------------
374  // Function : AnalysisManager::getTIAParams
375  // Purpose :
376  // Special Notes :
377  // Scope : public
378  // Creator : Eric R. Keiter, SNL, Computational Sciences
379  // Creation Date : 11/05/04
380  //-----------------------------------------------------------------------------
381  const TimeIntg::TIAParams &getTIAParams() const;
383 
384  bool getSensFlag() const {
385  return sensFlag_;
386  }
387 
389  registry_.push_back(factory);
390  }
391 
392  void addAnalysis(Factory<void> *factory) {
393  creatorVector_.push_back(factory);
394  }
395 
396 
397  void setDAEStateDerivFlag(bool state) {
398  daeStateDerivFlag_ = state;
399  }
400 
401 public:
402  // Queries about output and restart times
403  bool testRestartSaveTime();
404 
405  // For DCOP restart and/or .SAVE files.
406  bool testDCOPOutputTime();
407  bool testSaveOutputTime();
408 
409 public:
411  return dataStore_;
412  }
413 
415  return *primaryAnalysisObject_;
416  }
417 
419  return *primaryAnalysisObject_;
420  }
421 
423  primaryAnalysisObject_ = primary;
424  }
425 
426  CreatorVector &getCreatorVector() {
427  return creatorVector_;
428  }
429 
430  Parallel::Manager *getPDSManager() const {
431  return parallelManager_;
432  }
433 
434  bool getSwitchIntegrator() const {
435  return switchIntegrator_;
436  }
437 
438  void setSwitchIntegrator(bool switch_itegrator) {
439  switchIntegrator_ = switch_itegrator;
440  }
441 
442  void setNextOutputTime(double next_output_time) {
443  nextOutputTime_ = next_output_time;
444  }
445 
446  double getNextOutputTime() const {
447  return nextOutputTime_;
448  }
449 
450  Util::Timer &getXyceTranTimer() {
451  return xyceTranTimerPtr_;
452  }
453 
455  return outputManagerAdapter_;
456  }
457 
459  return *workingIntgMethod_;
460  }
461 
463  return *workingIntgMethod_;
464  }
465 
467  return *stepErrorControl_;
468  }
469 
471  return *stepErrorControl_;
472  }
473 
475  return *nonlinearEquationLoader_;
476  }
477 
479  return *loader_;
480  }
481 
482  const Loader::Loader &getLoader() const {
483  return *loader_;
484  }
485 
486  void setAnalysisMode(Mode analysis_mode) {
487  analysisMode_ = analysis_mode;
488  }
489 
491  return analysisMode_;
492  }
493 
494  double getSolverStartTime() const {
495  return solverStartTime_;
496  }
497 
499  {
500  progressFlag_ = false;
501  }
502 
503  bool getProgressFlag() const {
504  return progressFlag_;
505  }
506 
507  double getSaveTime() const {
508  return saveTime_;
509  }
510 
512  currentAnalysisStack_.push_back(analysis);
513  }
514 
516  currentAnalysisStack_.pop_back();
517  }
518 
520  return currentAnalysisStack_.front();
521  }
522 
523  bool getResumingSimulation() const {
524  return resumeSimulation_;
525  }
526 
527 private:
528  const IO::CmdParse & commandLine_; ///< Command line object
529  const std::string netlistFilename_; ///< Netlist file name
530 
531  IO::RestartMgr & restartManager_; ///< Restart manager
532  OutputMgrAdapter & outputManagerAdapter_; ///< Output manager adapter
533 
534  TimeIntg::WorkingIntegrationMethod * workingIntgMethod_; ///< Working integration method
535  TimeIntg::StepErrorControl * stepErrorControl_; ///< Pointer to the TIA step-error control object
536  Loader::NonlinearEquationLoader * nonlinearEquationLoader_; ///< Pointer to the nonlinear equation loader
537 
538  Loader::Loader * loader_; ///< Pointer to the nonlinear loader object
539  Loader::CktLoader * cktLoaderPtr_; ///< 'real' pointer to the ckt-loader
540  Parallel::Manager * parallelManager_; ///< Pointer to the parallel services manager
541  TimeIntg::DataStore * dataStore_; ///< Data store object
542  IO::ActiveOutput * activeOutput_;
543 
544 
547 
548  bool resumeSimulation_; ///< Resume simulation from a paused transient
549  bool blockAnalysisFlag_; ///< HB Analysis (maybe something with MPDE too)
550  bool daeStateDerivFlag_; ///< .OPTIONS TIMEINT DAESTATEDERIV=
551  bool dcopRestartFlag_; ///< Set if .OPTIONS OP_IO
552  bool saveFlag_; ///< Set if .SAVE
553  bool dotOpSpecified_; ///< Set if .OP
554  bool gui_; ///< Set if -giu appears on command line
558  bool sensFlag_;
560  bool switchIntegrator_; ///< Set to true when Transient::integrationMethod_ is changed
561 
562  Util::Timer xyceTranTimerPtr_; /// Xyce timing utility for timing the transient simulation CPU time.
563  Util::Timer * elapsedTimerPtr_; /// Xyce timing utility for timing elapsed run time
564 
566  double saveTime_; /// for .SAVE and/or DCOP restart.
567 
570 
571  AnalysisBase * analysisObject_; ///< .STEP, Dakota
572  AnalysisBase * primaryAnalysisObject_; ///< .TRAN, .AC, .HB, ...
573 
574  std::vector<AnalysisBase *> analysisVector_;
575  std::vector<AnalysisBase *> currentAnalysisStack_;
576 
577  CreatorVector creatorVector_;
579 
580  Stats::Stat analysisStat_;
581 
582 public:
583  unsigned int breakPointRestartStep;
584 };
585 
586 bool registerPkgOptionsMgr(AnalysisManager &analysis_manager, const std::string &netList_file, IO::PkgOptionsMgr &options_manager);
587 
589  const std::string & netlist_filename,
590  IO::PkgOptionsMgr & options_manager,
591  AnalysisManager & analysis_manager,
592  Linear::System & linear_system,
593  Nonlinear::Manager & nonlinear_manager,
594  Device::DeviceMgr & device_manager,
595  Linear::Builder & builder,
596  Topo::Topology & topology);
597 
598 void getTimeIntInfo(const AnalysisManager &analysis_manager, TimeIntg::TimeIntInfo & tiInfo);
599 
600 bool evalTransientModel(
601  Loader::Loader & loader,
602  double t,
603  Linear::Vector * SolVectorPtr,
604  Linear::Vector * CurrSolVectorPtr,
605  Linear::Vector * LasSolVectorPtr,
606  Linear::Vector * StaVectorPtr,
607  Linear::Vector * CurrStaVectorPtr,
608  Linear::Vector * LasStaVectorPtr,
609  Linear::Vector * StaDerivVectorPtr,
610  Linear::Vector * StoVectorPtr,
611  Linear::Vector * CurrStoVectorPtr,
612  Linear::Vector * LasStoVectorPtr,
613  Linear::Vector * stoLeadCurrQVectorPtr,
614  Linear::Vector * NextLeadFVectorPtr,
615  Linear::Vector * CurrLeadFVectorPtr,
616  Linear::Vector * LastLeadFVectorPtr,
617  Linear::Vector * LeadQVectorPtr,
618  Linear::Vector * NextJunctionVVectorPtr,
619  Linear::Vector * CurrentJunctionVVectorPtr,
620  Linear::Vector * LastJunctionVVectorPtr,
621  Linear::Vector * QVectorPtr,
622  Linear::Vector * FVectorPtr,
623  Linear::Vector * BVectorPtr,
624  Linear::Vector * dFdxdVpVectorPtr,
625  Linear::Vector * dQdxdVpVectorPtr,
626  Linear::Matrix * dQdxMatrixPtr,
627  Linear::Matrix * dFdxMatrixPtr);
628 
630  TimeIntg::StepErrorControl & step_error_control,
631  Loader::Loader & loader,
632  double t,
633  Linear::Vector * SolVectorPtr,
634  Linear::Vector * StaVectorPtr,
635  Linear::Vector * StoVectorPtr);
636 
637 void writeConductanceFile(const std::vector<std::string> &device_names, Nonlinear::ConductanceExtractor &conductance_extractor, const std::string &filename);
638 
639 } // namespace Analysis
640 } // namespace Xyce
641 
642 #endif // Xyce_N_ANP_AnalysisManager_h
bool setNextSolVectorPtr(Linear::Vector *solVecPtr)
bool setDCAnalysisParams(const Util::OptionBlock &paramsBlock)
void addAnalysis(Factory< void > *factory)
const char * analysisModeName(Mode mode)
Returns the name of the analysis mode given by mode.
bool run()
Runs the top level analysis.
void notify(const StepEvent &step_event)
Notification that there is a StepEvent.
bool setNOISEAnalysisParams(const Util::OptionBlock &OB)
const AnalysisBase * getActiveAnalysis() const
void setNextOutputTime(double next_output_time)
const Loader::Loader & getLoader() const
bool getStateVarData(const int &gid, std::vector< double > &varData) const
const std::string netlistFilename_
Netlist file name.
Util::ListenerAutoSubscribe< AnalysisEvent > AnalysisEventListener
TimeIntg::DataStore * dataStore_
Data store object.
Pure virtual class to augment a linear system.
bool setDCOPRestartParams(const Util::OptionBlock &OB)
bool dumpRestartData(char *buf, int bsize, int &pos, Parallel::Communicator *comm, bool pack)
Loader::Loader * loader_
Pointer to the nonlinear loader object.
bool gui_
Set if -giu appears on command line.
void pushActiveAnalysis(AnalysisBase *analysis)
void allocateAnalysisObject()
Creates the primary analysis and driving analysis (.STEP, dakota).
void setAnalysisMode(Mode analysis_mode)
bool registerPkgOptionsMgr(AnalysisManager &analysis_manager, const std::string &netList_file, IO::PkgOptionsMgr &options_manager)
void createTimeIntegratorMethod(const TimeIntg::TIAParams &tia_params, const unsigned int integration_method)
const AnalysisBase & getAnalysisObject() const
std::vector< AnalysisBase * > currentAnalysisStack_
const TimeIntg::StepErrorControl & getStepErrorControl() const
Util::ListenerAutoSubscribe< StepEvent > StepEventListener
Parallel::Manager * getPDSManager() const
AnalysisManager & operator=(const AnalysisManager &)
TimeIntg::StepErrorControl & getStepErrorControl()
double nextOutputTime_
for .SAVE and/or DCOP restart.
void getTimeIntInfo(const AnalysisManager &analysis_manager, TimeIntg::TimeIntInfo &tiInfo)
const std::string & getNetlistFilename() const
AnalysisManager(const IO::CmdParse &command_line, IO::RestartMgr &restart_manager, OutputMgrAdapter &output_manager_adapter, Stats::Stat analysis_stat)
Constructs the analysis manager.
bool testDCOPOutputTime()
Returns true if the DCOP Restart parameters have been set.
TimeIntg::StepErrorControl * stepErrorControl_
Pointer to the TIA step-error control object.
Util::Timer * elapsedTimerPtr_
Xyce timing utility for timing the transient simulation CPU time.
bool registerParallelServices(Parallel::Manager *pds_tmp)
void setPrimaryAnalysisObject(AnalysisBase *primary)
Loader::Loader & createLoader(Device::DeviceMgr &device_manager)
Creates the defaults circuit loader.
bool restoreRestartData(char *buf, int bsize, int &pos, Parallel::Communicator *comm, bool pack)
TimeIntg::WorkingIntegrationMethod * workingIntgMethod_
Working integration method.
bool initializeSolverSystem(const TimeIntg::TIAParams &tia_params, Loader::Loader &loader, Linear::System &linear_system, Nonlinear::Manager &nonlinear_manager, Device::DeviceMgr &device_manager)
Initializes the solver system.
void registerAnalysisFactory(const std::string &netlist_filename, IO::PkgOptionsMgr &options_manager, AnalysisManager &analysis_manager, Linear::System &linear_system, Nonlinear::Manager &nonlinear_manager, Device::DeviceMgr &device_manager, Linear::Builder &builder, Topo::Topology &topology)
Registers the analysis factories.
bool blockAnalysisFlag_
HB Analysis (maybe something with MPDE too)
bool getSolnVarData(const int &gid, std::vector< double > &varData) const
Util::Notifier< StepEvent > StepEventNotifier
bool daeStateDerivFlag_
.OPTIONS TIMEINT DAESTATEDERIV=
void setPauseTime(double pauseTime, double initial_time)
bool setLoader(Loader::Loader &loader_)
bool getStoreVarData(const int &gid, std::vector< double > &varData) const
Nonlinear::AnalysisMode nonlinearAnalysisMode(Mode mode)
Returns the nonlinear analysis mode given the analysis mode.
bool setACAnalysisParams(const Util::OptionBlock &OB)
bool setStateVarData(const int &gid, const std::vector< double > &varData)
const TimeIntg::WorkingIntegrationMethod & getWorkingIntegrationMethod() const
AnalysisBase * analysisObject_
.STEP, Dakota
void setTwoLevelMode(TwoLevelMode current_mode)
bool dcopRestartFlag_
Set if .OPTIONS OP_IO.
OutputMgrAdapter & getOutputManagerAdapter() const
Util::Notifier< AnalysisEvent > AnalysisEventNotifier
bool setSolnVarData(const int &gid, const std::vector< double > &varData)
Loader::NonlinearEquationLoader & getNonlinearEquationLoader()
Loader::CktLoader * cktLoaderPtr_
'real' pointer to the ckt-loader
const TimeIntg::TIAParams & getTIAParams() const
bool setOPAnalysisParams(const Util::OptionBlock &paramsBlock)
Loader::NonlinearEquationLoader * nonlinearEquationLoader_
Pointer to the nonlinear equation loader.
void addAnalysisFactory(Factory< void > *factory)
bool updateDerivsBlock(const std::list< IndexPair > &solGIDList, const std::list< IndexPair > &staGIDList)
std::vector< AnalysisBase * > analysisVector_
bool setSensOptions(const Util::OptionBlock &OB)
const IO::CmdParse & commandLine_
Command line object.
IO::RestartMgr & restartManager_
Restart manager.
OutputMgrAdapter & outputManagerAdapter_
Output manager adapter.
Factory for creating analysis objects.
bool completeHomotopyStep(Loader::NonlinearEquationLoader &loader, const std::vector< std::string > &paramNames, const std::vector< double > &paramVals, Linear::Vector *solnVecPtr)
bool failHomotopyStep(Loader::NonlinearEquationLoader &loader)
TimeIntg::WorkingIntegrationMethod & getWorkingIntegrationMethod()
const IO::CmdParse & getCommandLine() const
double solverStartTime_
Xyce timing utility for timing elapsed run time.
bool evalTransientModel(Loader::Loader &loader, double t, Linear::Vector *SolVectorPtr, Linear::Vector *CurrSolVectorPtr, Linear::Vector *LasSolVectorPtr, Linear::Vector *StaVectorPtr, Linear::Vector *CurrStaVectorPtr, Linear::Vector *LasStaVectorPtr, Linear::Vector *StaDerivVectorPtr, Linear::Vector *StoVectorPtr, Linear::Vector *CurrStoVectorPtr, Linear::Vector *LasStoVectorPtr, Linear::Vector *stoLeadCurrQVectorPtr, Linear::Vector *NextLeadFVectorPtr, Linear::Vector *CurrLeadFVectorPtr, Linear::Vector *LastLeadFVectorPtr, Linear::Vector *LeadQVectorPtr, Linear::Vector *NextJunctionVVectorPtr, Linear::Vector *CurrentJunctionVVectorPtr, Linear::Vector *LastJunctionVVectorPtr, Linear::Vector *QVectorPtr, Linear::Vector *FVectorPtr, Linear::Vector *BVectorPtr, Linear::Vector *dFdxdVpVectorPtr, Linear::Vector *dQdxdVpVectorPtr, Linear::Matrix *dQdxMatrixPtr, Linear::Matrix *dFdxMatrixPtr)
void setSwitchIntegrator(bool switch_itegrator)
bool switchIntegrator_
Set to true when Transient::integrationMethod_ is changed.
TimeIntg::DataStore * getDataStore()
void initializeTransientModel(const TimeIntg::TIAParams &tia_params)
bool getBlockAnalysisFlag() const
Return true if primary analysis is HB or MPDE.
bool setStoreVarData(const int &gid, const std::vector< double > &varData)
bool evalTransientModelState(TimeIntg::StepErrorControl &step_error_control, Loader::Loader &loader, double t, Linear::Vector *SolVectorPtr, Linear::Vector *StaVectorPtr, Linear::Vector *StoVectorPtr)
bool resumeSimulation_
Resume simulation from a paused transient.
The analysis factory template defines an interface for analysis type testing and analysis creation...
Definition: N_ANP_Factory.h:80
void writeConductanceFile(const std::vector< std::string > &device_names, Nonlinear::ConductanceExtractor &conductance_extractor, const std::string &filename)
Parallel::Manager * parallelManager_
Pointer to the parallel services manager.
std::vector< Factory< void > * > Registry
Registry of factories.
AnalysisBase * primaryAnalysisObject_
.TRAN, .AC, .HB, ...
std::vector< Factory< void > * > CreatorVector
bool setSaveOptions(const Util::OptionBlock &OB)
bool printLoopInfo(int start, int finish)