Xyce  6.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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-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_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.58 $
40 //
41 // Revision Date : $Date: 2014/02/24 23:49:12 $
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 <Teuchos_RefCountPtr.hpp>
52 using Teuchos::RefCountPtr;
53 using Teuchos::rcp;
54 
55 #include <N_UTL_Misc.h>
56 #include <N_UTL_Xyce.h>
57 #include <N_ANP_fwd.h>
58 #include <N_IO_fwd.h>
59 #include <N_UTL_fwd.h>
60 #include <N_PDS_fwd.h>
61 #include <N_UTL_OptionBlock.h>
62 
63 #include <N_TIA_TIAParams.h>
64 #include <N_TIA_StepErrorControl.h>
67 #include <N_TIA_DataStore.h>
68 #include <N_TIA_TimeIntInfo.h>
69 
70 #include <N_ANP_AnalysisBase.h>
71 #include <N_ANP_OutputMgrAdapter.h>
72 #include <N_ANP_SweepParam.h>
73 
74 #include <N_LOA_NonlinearEquationLoader.h>
75 #include <N_DEV_DeviceInterface.h>
76 #include <N_TOP_Topology.h>
77 #include <N_LAS_Builder.h>
78 #include <N_NLS_Manager.h>
79 
80 class N_TIA_Assembler;
85 
86 class N_NLS_Manager;
87 
88 class N_LAS_System;
89 
90 class N_LOA_Loader;
91 
92 class N_PDS_Manager;
93 
94 class N_MPDE_Manager;
95 
96 
97 namespace Xyce {
98 namespace Analysis {
99 
100 //-----------------------------------------------------------------------------
101 // Class : AnalysisManager
102 //
103 // Purpose : This class manages, allocates, and sets up the
104 // various analysis types, such as DC, Trn,a HB, etc.
105 //
106 // Special Notes : Some of this class was once in the N_TIA_ControlAlgorithm
107 // class, which was set up back when Xyce only did transient
108 // simulations. As we added analysis types it became necessary
109 // to refactor the code so that each analysis type had its own
110 // set of classes.
111 //
112 // Creator : Eric Keiter, SNL
113 // Creation Date : 6/01/00 (N_TIA_ControlAlgorithm, now deprecated)
114 // Creation Date : 1/24/08 (for this version of the class. Date is approximate)
115 //-----------------------------------------------------------------------------
117 {
118  // Friended class for lookup and set of restart data.
119  friend class ::N_TIA_StepErrorControl;
120  friend class ::N_TIA_DAE_Assembler;
121  friend class ::N_TIA_Assembler;
122 
123  friend class MOR;
124  friend class Dakota;
125  friend class AnalysisInterface;
126  friend class AnalysisBase;
127  friend class MPDE;
128  friend class AC;
129  friend class Step;
130  friend class HB;
131  friend class Transient;
132  friend class DCSweep;
133 
134  public:
135 
136  // Default constructor.
137  AnalysisManager(N_IO_CmdParse & cp, AnalysisInterface * anaIntPtr);
138 
139  // Destructor
141 
142  // Execution functions:
143  void resetAll();
144 
145  // Execute the control loop for the set analysis type.
146  bool run();
147 
148  // This function performs the final initializations. Mainly, it initializes
149  // the two data container classes, DataStore and StepErrorControl. It also
150  // registers the neccessary vectors with the LAS system class.
151  bool initializeAll();
152 
153  // Returns the current partial time derivative
154  double partialTimeDerivative();
155 
156  // Gets the next time-step value.
157  double getTime() const;
158 
159  // Gets the current time-step value.
160  double getCurrentTime() const;
161 
162  // Gets the final time-step value.
163  double getFinalTime() const;
164 
165  // Gets the initial time-step value.
166  double getInitialTime() const;
167 
168  // Gets the starting time-step value.
169  double getStartingTimeStep();
170 
171  // Updates the divided difference values.
172  bool updateDivDiffs();
173 
174  // Calls the time int. method to update the corrector derivatives.
175  bool updateDerivs();
176 
177  // updates state vectors following initial solve with previous operating point constraints
178  bool completeOPStartStep();
179 
180  // 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  N_LAS_Vector * solnVecPtr );
185 
186  bool failHomotopyStep ();
187 
188  // This function equates the 6 temporary vectors with their "next" vector
189  // equivalents. This function is neccessary for the nonlinear solver damping
190  // loop.
191  bool equateTmpVectors();
192 
193  // Compute an estimate of the error in the integration step.
194  bool updateDerivsBlock(const std::list< index_pair > & solGIDList,
195  const std::list< index_pair > & staGIDList);
196 
197  // Prints out time loop information.
198  bool printLoopInfo(int start, int finish);
199 
200  // Gets the time-integration method.
201  int getTimeIntMode();
202 
203  // Get the steady-state flag (true if time int mode is none)
204  bool getSteadyStateFlag ();
205 
206  // Get the dcop flag for transient.(true if doing DCOP for transient initialization)
207  bool getTranOPFlag ();
208 
209  // Get the dcop flag for AC.(true if doing DCOP for AC initialization)
210  bool getACOPFlag ();
211 
212  bool getDCSweepFlag ();
213 
214  bool getDotOpFlag() {return dotOpSpecified_;};
215  bool getStepFlag() {return stepLoopFlag_;};
216 
218  void setSweepSourceResetFlag (bool ssrf) { sweepSourceResetFlag_=ssrf;} ;
219 
220  bool getTransientFlag () const;
221 
222  // Is the doubleDCOP algorithm enabled?
223  bool getDoubleDCOPEnabled ();
224 
225  // Get block analysis information for HB
226  void setBlockAnalysisFlag( bool flagVal ) { blockAnalysisFlag_ = flagVal; }
227  bool getBlockAnalysisFlag() const;
228 
229  void setHBFlag( bool flagVal ) { hbFlag_ = flagVal; }
230  bool getHBFlag () {return hbFlag_; }
231 
232  // gets the index of the DCOP step.
233  // 0 = nonlinear poisson, 1=full TCAD
234  int getDoubleDCOPStep();
235 
236  // Gets/sets the step number.
237  int getStepNumber();
238  int getTranStepNumber();
239 
240  void setStepNumber(int step);
241  void setTranStepNumber(int step);
242 
243  // This is true only at the beginning of integration, not at a breakpoint.
244  bool getInitTranFlag();
245 
246  // Gets the step number.
247  //int getStepLoopIter () { return stepLoopIter_; }
248 
249  // Returns the time integration order
250  int getOrder ();
251 
252  int getNumberOfSteps ();
253  int getUsedOrder ();
254  int getNscsco ();
255 
256  const N_IO_CmdParse &getCommandLine() const {
257  return commandLine_;
258  }
259 
260  // Returns the "current" time step size.
261  double getCurrentStepSize();
262 
263  // Returns the "last" time step size.
264  double getLastStepSize();
265 
266  // Returns the breakpoint tolerance.
267  double getBreakpointTol();
268  // Sets the breakpoint tolerance.
269  void setBreakpointTol(double bptol);
270 
271  // returns whether transient analysis is completed
272  bool simulationComplete();
273 
274  // Gets the size of the restart data (bytes?).
275  int restartDataSize( bool pack );
276 
277  // Sets the transient calculations parameters
278  bool setTranAnalysisParams(const N_UTL_OptionBlock & paramsBlock);
279 
280  // Sets the DC sweep calculation parameters.
281  bool setDCAnalysisParams(const N_UTL_OptionBlock & paramsBlock);
282 
283  // Method to handle OP statements.
284  bool setOPAnalysisParams(const N_UTL_OptionBlock & paramsBlock);
285 
286  // Sets the STEP calculation parameters.
287  bool setSTEPAnalysisParams(const N_UTL_OptionBlock & paramsBlock);
288 
289  // Sets the SAVE parameters.
290  bool setSaveOptions(const N_UTL_OptionBlock & OB);
291 
292  // Sets the DCOP restart parameters.
293  bool setDCOPRestartParams(const N_UTL_OptionBlock & OB);
294 
295  // Method to register the AC Analysis options.
296  bool setACAnalysisParams(const N_UTL_OptionBlock & OB);
297 
298  // Method to register the MOR Analysis options.
299  bool setMORAnalysisParams(const N_UTL_OptionBlock & OB);
300 
301  // Method to register the MOR utility options.
302  bool setMOROptions(const N_UTL_OptionBlock & OB);
303 
304  // sets a time at which to pause the simulation
305  void setPauseTime(double pauseTime);
306  // returns time at which to pause the simulation
307  double getPauseTime();
308 
309  // returns true if the simulation is currently paused
310  bool isPaused();
311 
312  // signal that simulation is being resumed from previously paused state
313  void resumeSimulation();
314  // reset the resume flag to false.
315  void unset_resumeSimulation();
316 
317  // Registers the options block reference.
318  bool setTranOptions(const N_UTL_OptionBlock & OB);
319 
320  // Method to register the MPDE Analysis options.
321  bool setMPDEAnalysisParams(const N_UTL_OptionBlock & OB);
322 
323  // Method to register the MPDE utility options.
324  bool setMPDEOptions(const N_UTL_OptionBlock & OB);
325 
326  // Method to register the HB Analysis options.
327  bool setHBAnalysisParams(const N_UTL_OptionBlock & OB);
328 
329  // Method to register the HB utility options.
330  bool setHBOptions(const N_UTL_OptionBlock & OB);
331 
332  // Method to register the linear solver / preconditioning options.
333  bool setLinSol(const N_UTL_OptionBlock & OB);
334 
335  // Method to register the HB linear solver / preconditioning options.
336  bool setHBLinSol(const N_UTL_OptionBlock & OB);
337 
338  // Method to register the MPDE utility options.
339  bool setTRANMPDEOptions(const N_UTL_OptionBlock & OB);
340 
341  // Method to register the sensitivity options.
342  bool setSensOptions(const N_UTL_OptionBlock & OB);
343 
344  // Registers the TIA parameters block reference.
345  bool registerTIAParams(const N_TIA_TIAParams & tiaParams_tmp);
346 
347  // Registers the TIA MPDE Interface reference.
348  bool registerMPDEInterface(N_TIA_MPDEInterface * tiaMPDEIface_tmp);
349 
350  // Registers the linear system pointer.
351  bool registerLinearSystem(N_LAS_System * lasSysPtr_tmp);
352 
353  // Registers the nonlinear system manager pointer.
354  bool registerNLSManager(N_NLS_Manager * nlsMgrPtr_tmp);
355 
356  // Registers the nonlinear loader pointer.
357  bool registerLoader(N_LOA_Loader * loaderPtr_tmp);
358 
359  // Registers the output manager pointer.
360  bool registerOutputMgr(N_IO_OutputMgr * outputPtr_tmp);
361 
362  // Registers the restart manager pointer.
363  bool registerRestartMgr(N_IO_RestartMgr * restartPtr_tmp);
364 
365  // Method to register the ?DAE? Loader pointer
366  bool registerNonlinearEquationLoader( N_LOA_NonlinearEquationLoader * nonlinearEquationLoaderPtr );
367 
368  // Method to register the Device inerfaace pointer
370 
371  // Method to register the Topology pointer
372  bool registerTopology( N_TOP_Topology * topoMgrPtr );
373 
374  // Method to register the Restart Manager pointer
375  bool registerRestartManager( N_IO_RestartMgr * resMgrPtr );
376 
377  // Method to register the Output Manager pointer
378  bool registerOutputManager( N_IO_OutputMgr * outMgrPtr );
379 
380  // Method to register the Application Builder pointer
381  bool registerApplicationBuilder( N_LAS_Builder * appBuilderPtr );
382 
383  // Registers the parallel services manager pointer.
384  bool registerParallelServices(N_PDS_Manager * pds_tmp);
385 
386  // Registers the restart intervals.
388 
389  // Registers the restart output intervals.
391 
392  // Registers the elapsed time timer
393  bool registerElapsedTimer(N_UTL_Timer *);
394 
395  // Writes-out the restart data.
396  bool dumpRestartData(char * buf, int bsize, int & pos, N_PDS_Comm * comm, bool pack);
397 
398  // Restores the restart data.
399  bool restoreRestartData(char * buf, int bsize, int & pos, N_PDS_Comm * comm, bool pack );
400 
401  // Gets the solution variable data.
402  bool getSolnVarData(const int & gid, std::vector< double > & varData);
403 
404  // Gets the state variable data.
405  bool getStateVarData(const int & gid, std::vector< double > & varData);
406 
407  // Gets the store variable data.
408  bool getStoreVarData(const int & gid, std::vector< double > & varData);
409 
410  // Sets the solution variable data.
411  bool setSolnVarData(const int & gid, const std::vector< double > & varData);
412 
413  // Sets the state variable data.
414  bool setStateVarData(const int & gid, const std::vector< double > & varData);
415 
416  // Sets the store variable data.
417  bool setStoreVarData(const int & gid, const std::vector< double > & varData);
418 
419  // set/get beginning integration flag
420  void setBeginningIntegrationFlag(bool bif);
422 
423  // set/get integration method
424  void setIntegrationMethod(int im);
425  unsigned int getIntegrationMethod();
426 
427  // Gets the total time spent in the linear solvers.
428  double getTotalLinearSolutionTime() const;
429 
430  // Gets the total time spent in the residual load calculations.
431  double getTotalResidualLoadTime() const;
432 
433  // Gets the total time spent in the Jacobian load calculations.
434  double getTotalJacobianLoadTime() const;
435 
436  // set the next solution vector pointer. Needed for NOX...
437  bool setNextSolVectorPtr (N_LAS_Vector * solVecPtr);
438 
439  // Habanero API mixed signal functions:
440  bool provisionalStep (double maxTimeStep, double &currTimeStep);
441  void acceptProvisionalStep ();
442  void rejectProvisionalStep ();
443 
444  // Two-level Newton API functions:
445  // Execute the control loop for the set analysis type,
446  // for a set number of steps.
447  bool runStep
448  (const N_TIA_TimeIntInfo & tiInfo, N_TIA_TwoLevelError & tlError);
449 
450  void conductanceTest ();
451  bool startupSolvers ();
452  bool finishSolvers ();
453 
455  ( const std::vector<std::string> & paramNames,
456  const std::vector<double> & paramVals);
457 
458  void homotopyStepFailure ();
459 
460  void stepSuccess (int analysisUpper);
461  void stepFailure (int analysisUpper);
463  bool getBreakPoints (std::vector<N_UTL_BreakPoint> &breakPointTimes);
464  bool startTimeStep (const N_TIA_TimeIntInfo & tiInfo);
465 
466 
467  // routines to get/set Dakota run flags and actually run a Dakota iteration
468  bool getDakotaRunFlag();
469  void setDakotaRunFlag( bool flag );
470  int getDakotaIteration();
471  void setDakotaIteration( int iterNumber );
472  void getTimeIntInfo (N_TIA_TimeIntInfo & tiInfo);
473 
475  bool evalTransientModel(
476  double t,
477  N_LAS_Vector * SolVectorPtr,
478  N_LAS_Vector * CurrSolVectorPtr,
479  N_LAS_Vector * LasSolVectorPtr,
480  N_LAS_Vector * StaVectorPtr,
481  N_LAS_Vector * CurrStaVectorPtr,
482  N_LAS_Vector * LasStaVectorPtr,
483  N_LAS_Vector * StaDerivVectorPtr,
484  N_LAS_Vector * StoVectorPtr,
485  N_LAS_Vector * CurrStoVectorPtr,
486  N_LAS_Vector * LasStoVectorPtr,
487  N_LAS_Vector * stoLeadCurrQCompVectorPtr,
488  N_LAS_Vector * QVectorPtr,
489  N_LAS_Vector * FVectorPtr,
490  N_LAS_Vector * dFdxdVpVectorPtr,
491  N_LAS_Vector * dQdxdVpVectorPtr,
492  N_LAS_Matrix * dQdxMatrixPtr,
493  N_LAS_Matrix * dFdxMatrixPtr
494  );
496  double t,
497  N_LAS_Vector * SolVectorPtr,
498  N_LAS_Vector * StaVectorPtr,
499  N_LAS_Vector * StoVectorPtr
500  );
501 
502  protected:
503 
504  private :
505 
506  bool getInputOPFlag ();
507 
508  // Allocate and register the MPDE Manager
509  void setupMPDEMgr_();
510 
511  // allocate analysis objects:
513 
515 
517 
518  // Sets the nonlinear solver solution parameters.
519  void setNLSParams_();
520 
521  // Two level Newton API:
523  Teuchos::RefCountPtr<AnalysisBase> twoLevelAnalysisObject_;
524 
525  // Habanero mixed-signal API:
526  Teuchos::RefCountPtr<AnalysisBase> mixedSignalAnalysisObject_;
527 
528  // Queries about output and restart times
530  bool testRestartSaveTime_();
531 
532  public:
533  // Queries to the MPDE Manager.
534  // keep there like this so we don't have to
535  // expose the MPDE Manager pointer
536  void setMPDEFlag( bool flagVal ) { mpdeFlag_ = flagVal; }
537  bool getMPDEFlag (); // "get" function for MPDE flag. (true if not IC)
538 
539  private:
540  bool getMPDEIcFlag(); // get function for MPDE initial condition flag (true if MPDE & IC)
541  bool getMPDEStartupFlag(); // True if you have done an initial transient simulation before starting MPDE IC calculation
542  bool getWaMPDEFlag (); // "get" function for WaMPDE flag. (true if not IC)
543 
544  // For DCOP restart and/or .SAVE files.
545  bool testDCOPOutputTime_();
546  bool testSaveOutputTime_();
547 
548  public:
549 
550  unsigned int breakPointRestartStep;
551 
552  // The current time-integration method.
553  RefCountPtr<N_TIA_WorkingIntegrationMethod> wimPtr;
554 
555  // TIA params object.
557 
558  // Pointer to the ANP Analysis Interface
559  RefCountPtr<AnalysisInterface> anaIntPtr;
560 
561  // Pointer to the linear system information and containers.
562  RefCountPtr<N_LAS_System> lasSysPtr;
563 
564  // Pointer to the nonlinear solver manager.
565  RefCountPtr<N_NLS_Manager> nlsMgrPtr;
566 
567  // Pointer to the nonlinear loader object.
568  RefCountPtr<N_LOA_Loader> loaderPtr;
569 
570  // Pointer to residual assembler object
571  RefCountPtr<N_TIA_Assembler> assemblerPtr;
572 
573  // Pointer to the restart manager.
574  RefCountPtr<N_IO_RestartMgr> restartPtr;
575 
576  // Pointer to the application loader
577  RefCountPtr<N_LOA_NonlinearEquationLoader> nonlinearEquationLoaderPtr;
578 
579  // Pointer to the device interface
580  RefCountPtr<N_DEV_DeviceInterface> devInterfacePtr;
581 
582  // Pointer to the topology manager
583  RefCountPtr<N_TOP_Topology> topoMgrPtr;
584 
585  // Pointer to the output manager
586  RefCountPtr<N_IO_OutputMgr> outMgrPtr;
587 
588  // Pointer to the applicaiton builder
589  RefCountPtr<N_LAS_Builder> appBuilderPtr;
590 
591  // Pointer to the parallel services manager.
592  RefCountPtr<N_PDS_Manager> pdsMgrPtr;
593 
595 
597 
598  // 0 = tranop
599  // 1 = transient (time stepping)
600  // 2 = dc sweep.
602 
603  bool firstTime;
605  double startSimTime;
606 
607  N_MPDE_Manager * getMPDEManager() const { return &*mpdeMgrPtr_; }
608  Teuchos::RefCountPtr<N_TIA_DataStore> getTIADataStore() {
609  return tiaDataStore_;
610  }
611  Teuchos::RefCountPtr<const AnalysisBase> getAnalysisObject() const {
612  return primaryAnalysisObject_;
613  }
614 
615  void silenceProgress();
616  void enableProgress();
617 
618  void setNextOutputTime(double next_output_time) {
619  nextOutputTime_ = next_output_time;
620  }
621 
622  protected:
623  private:
624 
625 #if 0
626  // Current time-integration method flag.
627  unsigned int integrationMethod_;
628 #endif
629 
630  // Switch the integration flag.
632 
633  // DC Operating Point flag.
634  bool initializeAllFlag_; // true if the initializeAll function has been
635  // called once.
636 
637  //
638  // 05/26/09 Coffey,Schiek,Mei: We considered the data members down to this point for moving to Transient
639  //
641 
642  bool stepLoopFlag_; // true if there is an external
643  // parameter stepper loop around the dcop or
644  // transient simulation loops.
645 
646  bool stepLoopInitialized_; // true if the step loop has been set up.
647  bool dcLoopInitialized_; // true if the dc sweep loop has been set up.
648  bool gui_; // command line arg -gui is present
649 
650 
651  bool daeStateDerivFlag_; // true if running new-DAE and need
652  // state derivative. true by default.
653  // If set to true, it breaks MPDE.
654 
656 
658 
660 
661  // Flag to decide whether to print progress
663 
664  // Xyce timing utility for timing the transient simulation CPU time.
665  RefCountPtr<N_UTL_Timer> xyceTranTimerPtr_;
666 
667  // Xyce timing utility for timing elapsed run time
668  RefCountPtr<N_UTL_Timer> elapsedTimerPtr_;
669 
671 
672  // pointer to the output manager adapter
673  RefCountPtr<OutputMgrAdapter > outputMgrAdapterRCPtr_;
674 
675  // Pointer to the TIA data store object.
676  RefCountPtr<N_TIA_DataStore> tiaDataStore_;
677 
678  // Pointer to the TIA step-error control object.
679  RefCountPtr<N_TIA_StepErrorControl> secPtr_;
680 
683 
684  // for .SAVE and/or DCOP restart.
685  double saveTime_;
687  bool saveFlag_;
690 
691  // .OP flag(s)
693 
694  // output and restart interval info
696  std::vector< std::pair < double, double > > outputIntervals_;
698 
700  std::vector< std::pair < double, double > > restartIntervals_;
702 
703  // for HB, MPDE, or any other block analysis type
705  bool hbFlag_;
706  bool mpdeFlag_;
707 
708  // sensitivity flag(s)
709  bool sensFlag_;
710 
711  // for handling expressions given for a time dependent max time step
712  //bool maxTimeStepExpressionGiven_;
713  //string maxTimeStepExpressionAsString_;
714 
715  // ref counted pointers for various analyses. Not all are used in every simulation
716  Teuchos::RefCountPtr<AnalysisBase> analysisObject_;
717  Teuchos::RefCountPtr<AnalysisBase> stepAnalysisTarget_;
718  Teuchos::RefCountPtr<AnalysisBase> dakotaAnalysisTarget_;
719  Teuchos::RefCountPtr<AnalysisBase> primaryAnalysisObject_;
720 
721  // command line object
722  N_IO_CmdParse & commandLine_;
723 
724  // MPDE stuff:
725  RefCountPtr<N_MPDE_Manager> mpdeMgrPtr_;
726  RefCountPtr<N_TIA_MPDEInterface> tiaMPDEIfacePtr_;
727 
728  // parameter objects for each analysis type. These are saved until the
729  // analysis object of choice is allocated.
730  N_UTL_OptionBlock tranParamsBlock;
731  N_UTL_OptionBlock opParamsBlock;
732  N_UTL_OptionBlock acParamsBlock;
733  N_UTL_OptionBlock morParamsBlock;
734 
735  // Different block passed in for each sweep variable, so need to have
736  // these containers be vectors.
737  std::vector<N_UTL_OptionBlock> dcParamsBlockVec;
738  std::vector<N_UTL_OptionBlock> stepParamsBlockVec;
739 
740  N_UTL_OptionBlock mpdeParamsBlock;
741  N_UTL_OptionBlock hbParamsBlock;
742  N_UTL_OptionBlock hbOptionsBlock;
743  N_UTL_OptionBlock hbLinSolBlock;
744  N_UTL_OptionBlock linSolBlock;
745  N_UTL_OptionBlock dakotaParamsBlock;
746 };
747 
748 } // namespace Analysis
749 } // namespace Xyce
750 
752 
753 #endif // Xyce_N_ANP_AnalysisManager_h