40 #include <Xyce_config.h>
59 #include <N_IO_CmdParse.h>
60 #include <N_IO_OutputMgr.h>
61 #include <N_IO_ActiveOutput.h>
62 #include <N_IO_RestartMgr.h>
63 #include <N_LAS_LAFactory.h>
64 #include <N_LAS_Matrix.h>
65 #include <N_LAS_System.h>
66 #include <N_LAS_Vector.h>
67 #include <N_LOA_CktLoader.h>
68 #include <N_LOA_Loader.h>
69 #include <N_LOA_NonlinearEquationLoader.h>
70 #include <N_MPDE_Manager.h>
72 #include <N_PDS_Comm.h>
73 #include <N_PDS_Manager.h>
81 #include <N_TOP_Topology.h>
82 #include <N_UTL_BreakPoint.h>
83 #include <N_UTL_OptionBlock.h>
84 #include <N_UTL_Stats.h>
85 #include <N_UTL_Timer.h>
93 struct AnalysisManager_ResultOptionsReg :
public IO::PkgOptionsReg
95 AnalysisManager_ResultOptionsReg(AnalysisManager &analysis_manager)
99 bool operator()(
const Util::OptionBlock & option_block)
111 struct AnalysisManager_TransAnalysisReg :
public IO::PkgOptionsReg
113 AnalysisManager_TransAnalysisReg( AnalysisManager * mgr )
117 bool operator()(
const N_UTL_OptionBlock & options )
118 {
return Mgr->setTranAnalysisParams( options ); }
124 struct AnalysisManager_TranOptionsReg :
public IO::PkgOptionsReg
126 AnalysisManager_TranOptionsReg( AnalysisManager * mgr )
130 bool operator()(
const N_UTL_OptionBlock & options )
131 {
return Mgr->setTranOptions( options ); }
133 AnalysisManager *
Mgr;
137 struct AnalysisManager_DCAnalysisReg :
public IO::PkgOptionsReg
139 AnalysisManager_DCAnalysisReg( AnalysisManager * mgr )
143 bool operator()(
const N_UTL_OptionBlock & options )
144 {
return Mgr->setDCAnalysisParams( options ); }
146 AnalysisManager *
Mgr;
150 struct AnalysisManager_DCOPOptionsReg :
public IO::PkgOptionsReg
152 AnalysisManager_DCOPOptionsReg( AnalysisManager * mgr )
156 bool operator()(
const N_UTL_OptionBlock & options )
157 {
return Mgr->setDCOPRestartParams( options ); }
159 AnalysisManager *
Mgr;
164 struct AnalysisManager_OPAnalysisReg :
public IO::PkgOptionsReg
166 AnalysisManager_OPAnalysisReg( AnalysisManager * mgr )
170 bool operator()(
const N_UTL_OptionBlock & options )
171 {
return Mgr->setOPAnalysisParams( options ); }
173 AnalysisManager *
Mgr;
177 struct AnalysisManager_STEPAnalysisReg :
public IO::PkgOptionsReg
179 AnalysisManager_STEPAnalysisReg( AnalysisManager * mgr )
183 bool operator()(
const N_UTL_OptionBlock & options )
184 {
return Mgr->setSTEPAnalysisParams( options ); }
186 AnalysisManager *
Mgr;
190 struct AnalysisManager_SaveOptionsReg :
public IO::PkgOptionsReg
192 AnalysisManager_SaveOptionsReg( AnalysisManager * mgr )
196 bool operator()(
const N_UTL_OptionBlock & options )
197 {
return Mgr->setSaveOptions( options ); }
199 AnalysisManager *
Mgr;
203 struct AnalysisManager_MPDE_AnalysisReg :
public IO::PkgOptionsReg
205 AnalysisManager_MPDE_AnalysisReg( AnalysisManager * anpInt )
209 bool operator()(
const N_UTL_OptionBlock & options )
210 {
return anpInt_->setMPDEAnalysisParams( options ); }
216 struct AnalysisManager_HB_AnalysisReg :
public IO::PkgOptionsReg
218 AnalysisManager_HB_AnalysisReg( AnalysisManager * anpInt )
222 bool operator()(
const N_UTL_OptionBlock & options )
223 {
return anpInt_->setHBAnalysisParams( options ); }
229 struct AnalysisManager_HB_OptionsReg :
public IO::PkgOptionsReg
231 AnalysisManager_HB_OptionsReg( AnalysisManager * anpInt )
235 bool operator()(
const N_UTL_OptionBlock & options )
236 {
return anpInt_->setHBOptions( options ); }
242 struct AnalysisManager_LinSolReg :
public IO::PkgOptionsReg
244 AnalysisManager_LinSolReg( AnalysisManager * anpInt )
248 bool operator()(
const N_UTL_OptionBlock & options )
249 {
return anpInt_->setLinSol( options ); }
255 struct AnalysisManager_HB_LinSolReg :
public IO::PkgOptionsReg
257 AnalysisManager_HB_LinSolReg( AnalysisManager * anpInt )
261 bool operator()(
const N_UTL_OptionBlock & options )
262 {
return anpInt_->setHBLinSol( options ); }
268 struct AnalysisManager_MPDE_OptionsReg :
public IO::PkgOptionsReg
270 AnalysisManager_MPDE_OptionsReg( AnalysisManager * anpInt )
274 bool operator()(
const N_UTL_OptionBlock & options )
275 {
return anpInt_->setMPDEOptions( options ); }
281 struct AnalysisManager_MPDE_TranMPDEOptionsReg :
public IO::PkgOptionsReg
283 AnalysisManager_MPDE_TranMPDEOptionsReg( AnalysisManager * anpInt )
287 bool operator()(
const N_UTL_OptionBlock & options )
288 {
return anpInt_->setTRANMPDEOptions( options ); }
294 struct AnalysisManager_AC_AnalysisReg :
public IO::PkgOptionsReg
296 AnalysisManager_AC_AnalysisReg( AnalysisManager * anpInt )
300 bool operator()(
const N_UTL_OptionBlock & options )
301 {
return anpInt_->setACAnalysisParams( options ); }
307 struct AnalysisManager_MOR_AnalysisReg :
public IO::PkgOptionsReg
309 AnalysisManager_MOR_AnalysisReg( AnalysisManager * anpInt )
313 bool operator()(
const N_UTL_OptionBlock & options )
314 {
return anpInt_->setMORAnalysisParams( options ); }
320 struct AnalysisManager_MOR_OptionsReg :
public IO::PkgOptionsReg
322 AnalysisManager_MOR_OptionsReg( AnalysisManager * anpInt )
326 bool operator()(
const N_UTL_OptionBlock & options )
327 {
return anpInt_->setMOROptions( options ); }
334 struct AnalysisManager_SensOptionsReg :
public IO::PkgOptionsReg
336 AnalysisManager_SensOptionsReg( AnalysisManager * anpInt )
340 bool operator()(
const N_UTL_OptionBlock & options )
341 {
return anpInt_->setSensOptions( options ); }
353 static const char *
const mode_names[] = {
"Invalid",
"DC OP",
"DC Sweep",
"Transient",
"MPDE",
"HB",
"AC",
"MOR"};
355 if (mode <
sizeof(mode_names)/
sizeof(mode_names[0]))
356 return mode_names[mode];
358 return mode_names[0];
373 Util::ListenerAutoSubscribe<
StepEvent>(this),
377 workingIntgMethod_(0),
378 stepErrorControl_(0),
385 nonlinearEquationLoaderPtr_(0),
391 outputManagerAdapter_(0),
394 analysisParamsRegistered(false),
396 oldPercentComplete(0.0),
398 calledBeforeTwoLevelTran_(false),
399 switchIntegrator_(false),
400 initializeAllFlag_(false),
402 stepLoopFlag_(false),
403 stepLoopInitialized_(false),
404 dcLoopInitialized_(false),
406 daeStateDerivFlag_(true),
407 initializeSolvers_mixedSignal_(false),
409 sweepSourceResetFlag_(true),
411 rootStat_(
"Analysis Manager", root_stat),
412 xyceTranTimerPtr_(0),
414 solverStartTime_(0.0),
415 dakotaRunFlag_(false),
416 dakotaIterationNumber_(0),
418 saveTimeGiven_(false),
420 savedAlready_(false),
421 dcopRestartFlag_(false),
422 dotOpSpecified_(false),
423 initialOutputInterval_(0.0),
425 nextOutputTime_(0.0),
426 initialRestartInterval_(0.0),
428 nextRestartSaveTime_(0.0),
429 blockAnalysisFlag_(false),
434 stepAnalysisTarget_(),
435 dakotaAnalysisTarget_(),
436 primaryAnalysisObject_(),
439 twoLevelAnalysisObject_(),
440 mixedSignalAnalysisObject_(),
441 breakPointRestartStep(0),
450 atoi(
commandLine_.getArgumentValue(
"-maxord" ).c_str() );
674 static Stats::Stat initialize_stat(
"Initialize",
rootStat_);
676 Stats::TimeBlock x(initialize_stat);
680 Report::DevelFatal0().in(
"AnalysisManager::initializeAll")
681 <<
"Register LAS system first.";
688 #ifdef Xyce_DEBUG_ANALYSIS
691 Xyce::dout() <<
"AnalysisManager::initializeAll. " ;
819 Report::UserError0() <<
"No analysis statement in the netlist";
845 Report::DevelFatal0().in(
"AnalysisManager::run")
846 <<
"Call the initializeAll function first";
851 Report::UserError0() <<
"No analysis statement in the netlist";
858 std::vector<char> varTypes;
862 bool runStatus =
false;
871 #ifdef Xyce_VERBOSE_TIME
875 #ifndef Xyce_NO_MASKED_WRMS_NORMS
907 Report::safeBarrier(
pdsMgrPtr_->getPDSComm()->comm());
979 Report::UserError0() <<
"Unknown type of analysis";
991 Report::DevelFatal0().in(
"AnalysisManager::initializeAll")
992 <<
"Unable to allocate analysis type";
1092 Xyce::dout() <<
"Calling SAVE outputs!" <<std::endl;
1111 #ifdef Xyce_DEBUG_RESTART
1112 Xyce::dout() <<
"TESTING FOR RESTART SAVE" << std::endl
1113 << Xyce::subsection_divider << std::endl
1114 <<
"stepErrorControl_->currentTime: " << stepErrorControl_->currentTime << std::endl
1115 <<
"nextSaveTime: " << nextRestartSaveTime_ << std::endl
1116 <<
"initialRestartInterval_: " << initialRestartInterval_ << std::endl;
1117 if (!(restartIntervals_.empty()))
1119 Xyce::dout() <<
"First restart interval: " << restartIntervals_[0].first << std::endl;
1123 Xyce::dout() <<
"restartIntervals_ is empty" << std::endl;
1127 if (initialRestartInterval_ == 0.0)
1131 else if (stepErrorControl_->currentTime < nextRestartSaveTime_)
1135 else if (restartIntervals_.empty())
1137 while (nextRestartSaveTime_ <= stepErrorControl_->currentTime)
1139 nextRestartSaveTime_ += initialRestartInterval_;
1143 else if (stepErrorControl_->currentTime < restartIntervals_[0].first)
1145 while (nextRestartSaveTime_ <= stepErrorControl_->currentTime)
1147 nextRestartSaveTime_ += initialRestartInterval_;
1149 if (nextRestartSaveTime_ > restartIntervals_[0].first)
1151 nextRestartSaveTime_ = restartIntervals_[0].first;
1157 std::pair<double, double> currInterval, nextInterval;
1158 int size = restartIntervals_.size();
1159 for (
int i = 0; i < size; ++i)
1161 if (restartIntervals_[i].first <= stepErrorControl_->currentTime)
1163 currInterval = restartIntervals_[i];
1164 if ((i+1) < (
int)restartIntervals_.size())
1166 nextInterval = restartIntervals_[i+1];
1170 int step = static_cast <
int> ((stepErrorControl_->currentTime-currInterval.first) /
1171 currInterval.second);
1172 nextRestartSaveTime_ = currInterval.first + (step+1)*currInterval.second;
1174 if (nextInterval.first && (nextInterval.first!=currInterval.first)
1175 && (nextRestartSaveTime_>=nextInterval.first))
1177 nextRestartSaveTime_ = nextInterval.first;
1182 #ifdef Xyce_DEBUG_RESTART
1183 Xyce::dout() <<
"new nextSaveTime: " << nextRestartSaveTime_ << std::endl
1184 <<
"restart flag: " << flag << std::endl
1185 << Xyce::subsection_divider << std::endl;
1209 #ifdef Xyce_DEBUG_ANALYSIS
1212 Xyce::dout() <<
"AnalysisManager::partialTimeDerivative.";
1235 return N_UTL_BreakPoint::getBPTol();
1248 N_UTL_BreakPoint::setBPTol(bptol);
1262 std::vector< std::pair<double,double> > intPairs;
1263 restartPtr_->getRestartIntervals(initInt, intPairs);
1281 std::vector< std::pair<double,double> > intPairs;
1298 const N_UTL_OptionBlock & paramsBlock)
1319 (
const N_UTL_OptionBlock & paramsBlock)
1321 analysisParamsRegistered =
true;
1328 bool foundMatch =
false;
1329 std::vector<N_UTL_OptionBlock>::iterator paramsBlockVecItr = dcParamsBlockVec.begin();
1330 std::vector<N_UTL_OptionBlock>::iterator paramsBlockVecEnd = dcParamsBlockVec.end();
1331 while( paramsBlockVecItr != paramsBlockVecEnd )
1333 if( paramsBlockVecItr->compareParamLists( paramsBlock ) )
1339 paramsBlockVecItr++;
1345 *paramsBlockVecItr = paramsBlock;
1350 dcParamsBlockVec.push_back (paramsBlock);
1364 const N_UTL_OptionBlock & paramsBlock)
1380 const N_UTL_OptionBlock & paramsBlock)
1387 bool foundMatch =
false;
1388 std::vector<N_UTL_OptionBlock>::iterator paramsBlockVecItr =
stepParamsBlockVec.begin();
1389 std::vector<N_UTL_OptionBlock>::iterator paramsBlockVecEnd =
stepParamsBlockVec.end();
1390 while( paramsBlockVecItr != paramsBlockVecEnd )
1392 if( paramsBlockVecItr->compareParamLists( paramsBlock ) )
1398 paramsBlockVecItr++;
1404 *paramsBlockVecItr = paramsBlock;
1425 const N_UTL_OptionBlock & OB)
1427 #ifdef Xyce_DEBUG_ANALYSIS
1430 Xyce::dout() <<
"In AnalysisManager::setSaveOptions" << std::endl;
1436 Util::ParameterList::const_iterator iterPL = OB.getParams().begin();
1437 Util::ParameterList::const_iterator iterPL_end = OB.getParams().end();
1439 while (iterPL != iterPL_end)
1441 #ifdef Xyce_DEBUG_IO
1442 Xyce::dout() <<
"iterPL->tag = " << iterPL->tag() << std::endl;
1444 if (iterPL->tag() ==
"TYPE")
1448 else if (iterPL->tag() ==
"FILE")
1452 else if (iterPL->tag() ==
"TIME")
1454 saveTime_ = iterPL->getImmutableValue<
double>();
1457 else if (iterPL->tag() ==
"LEVEL")
1484 (
const N_UTL_OptionBlock & paramsBlock)
1486 analysisParamsRegistered =
true;
1488 acParamsBlock = paramsBlock;
1502 (
const N_UTL_OptionBlock & paramsBlock)
1504 analysisParamsRegistered =
true;
1506 morParamsBlock = paramsBlock;
1520 Util::ParameterList::const_iterator it_tpL;
1521 Util::ParameterList::const_iterator first = OB.getParams().begin();
1522 Util::ParameterList::const_iterator last = OB.getParams().end();
1524 for (it_tpL = first; it_tpL != last; ++it_tpL)
1526 if (it_tpL->uTag()==
"METHOD")
1528 ExtendedString stringVal ( it_tpL->stringValue() );
1529 stringVal.toUpper();
1532 else if (it_tpL->uTag()==
"SAVEREDSYS")
1536 else if (it_tpL->uTag()==
"COMPORIGTF")
1540 else if (it_tpL->uTag()==
"COMPREDTF")
1544 else if (it_tpL->uTag()==
"COMPTYPE")
1546 ExtendedString stringVal ( it_tpL->stringValue() );
1547 stringVal.toUpper();
1550 else if (it_tpL->uTag()==
"COMPNP")
1554 else if (it_tpL->uTag()==
"COMPFSTART")
1558 else if (it_tpL->uTag()==
"COMPFSTOP")
1562 else if (it_tpL->uTag()==
"EXPPOINT")
1566 else if (it_tpL->uTag()==
"SCALETYPE")
1570 else if (it_tpL->uTag()==
"SCALEFACTOR")
1574 else if (it_tpL->uTag()==
"SCALEFACTOR1")
1578 else if (it_tpL->uTag()==
"SPARSIFICATIONTYPE")
1584 Report::UserError0() << it_tpL->uTag() <<
" is not a recognized model-order reduction option.";
1614 Util::ParameterList::const_iterator iterPL = OB.getParams().begin();
1615 Util::ParameterList::const_iterator iterPL_end = OB.getParams().end();
1617 while (iterPL != iterPL_end)
1619 #ifdef Xyce_DEBUG_IO
1620 Xyce::dout() <<
"iterPL->tag = " << iterPL->tag() << std::endl;
1623 if (iterPL->tag() ==
"INPUT")
1627 else if (iterPL->tag() ==
"OUTPUT")
1631 else if (iterPL->tag() ==
"TIME")
1633 saveTime_ = iterPL->getImmutableValue<
double>();
1659 Util::ParameterList::const_iterator it_tpL;
1660 Util::ParameterList::const_iterator first = OB.getParams().begin();
1661 Util::ParameterList::const_iterator last = OB.getParams().end();
1663 for (it_tpL = first; it_tpL != last; ++it_tpL)
1665 if (it_tpL->uTag()==
"METHOD")
1669 if (it_tpL->isInteger())
1674 ExtendedString stringVal ( it_tpL->stringValue() );
1675 stringVal.toUpper();
1677 if (stringVal ==
"TRAP" || stringVal ==
"TRAPEZOIDAL")
1679 else if (stringVal ==
"BDF")
1681 else if (stringVal ==
"GEAR")
1685 Report::UserError0() <<
"Unsupported transient method type";
1690 #ifdef Xyce_DEBUG_ANALYSIS
1691 else if (it_tpL->uTag()==
"CONSTSTEP")
1694 =
static_cast<bool> (it_tpL->getImmutableValue<
int>());
1697 else if (it_tpL->uTag()==
"USEDEVICEMAX")
1701 else if (it_tpL->uTag()==
"RELTOL")
1706 else if (it_tpL->uTag()==
"ABSTOL")
1710 else if (it_tpL->uTag()==
"DOUBLEDCOPSTEP")
1714 else if (it_tpL->uTag()==
"FIRSTDCOPSTEP")
1718 else if (it_tpL->uTag()==
"LASTDCOPSTEP")
1722 else if (it_tpL->uTag()==
"BPENABLE" )
1726 else if (it_tpL->uTag()==
"RESTARTSTEPSCALE" )
1730 else if (it_tpL->uTag()==
"EXITTIME" )
1734 else if (it_tpL->uTag()==
"EXITSTEP" )
1738 else if (it_tpL->uTag() ==
"MINTIMESTEPSBP")
1743 else if (it_tpL->uTag()==
"ERROPTION" )
1755 else if (it_tpL->uTag()==
"NLNEARCONV" )
1759 else if (it_tpL->uTag()==
"NLSMALLUPDATE" )
1763 else if (it_tpL->uTag()==
"JACLIMITFLAG" )
1767 else if (it_tpL->uTag()==
"JACLIMIT" )
1771 else if (it_tpL->uTag()==
"DAESTATEDERIV" )
1775 else if (it_tpL->uTag()==
"MAXORD" )
1779 else if (it_tpL->uTag()==
"MINORD" )
1783 else if (it_tpL->uTag()==
"TIMESTEPSREVERSAL" )
1787 else if (it_tpL->uTag()==
"TESTFIRSTSTEP" )
1791 else if (it_tpL->uTag()==
"DELMAX" )
1797 else if (it_tpL->uTag()==
"NLMIN" )
1801 else if (it_tpL->uTag()==
"NLMAX" )
1805 else if (it_tpL->uTag()==
"OUTPUTINTERPMPDE")
1809 else if (it_tpL->uTag()==
"NEWLTE")
1813 else if (it_tpL->uTag()==
"NEWBPSTEPPING")
1817 else if (it_tpL->uTag()==
"INTERPOUTPUT")
1821 else if (it_tpL->uTag()==
"CONDTEST")
1825 else if (it_tpL->uTag()==
"CONDTESTDEVICENAME")
1829 else if (it_tpL->uTag() ==
"DTMIN")
1834 else if (it_tpL->uTag() ==
"PASSNLSTALL")
1838 else if (it_tpL->uTag() ==
"FASTTESTS")
1842 else if (it_tpL->uTag() ==
"MINTIMESTEPRECOVERY")
1846 else if (it_tpL->uTag()==
"VOLTZEROTOL" )
1850 else if (it_tpL->uTag()==
"CURRZEROTOL" )
1854 else if (it_tpL->uTag()==
"DEBUGLEVEL" )
1856 #ifdef Xyce_DEBUG_TIME
1869 else if (it_tpL->uTag()==
"HISTORYTRACKINGDEPTH" )
1875 Report::UserError() << it_tpL->uTag() <<
" is not a recognized time integration option";
1894 atoi(
commandLine_.getArgumentValue(
"-maxord" ).c_str() );
1924 bool bsuccess =
mpdeMgrPtr_->setMPDEAnalysisParams(OB);
1959 Util::ParameterList::const_iterator it_tpL;
1960 Util::ParameterList::const_iterator first = OB.getParams().begin();
1961 Util::ParameterList::const_iterator last = OB.getParams().end();
1963 for (it_tpL = first; it_tpL != last; ++it_tpL)
1965 if (it_tpL->uTag() ==
"FREQ")
1975 Report::UserError() <<
"Frequency of oscillation " <<
tiaParams_.
freqs[0] <<
" is less than or equal to zero, invalid .HB specification";
1980 dout() << section_divider << std::endl
1981 <<
"HB transient simulation parameters"
2082 bool bsuccess =
true;
2101 (
const std::vector<std::string> & paramNames,
2102 const std::vector<double> & paramVals,
2103 N_LAS_Vector * solnVecPtr )
2105 bool bsuccess =
true;
2107 #ifdef Xyce_DEBUG_ANALYSIS
2108 std::string netListFile = commandLine_.getArgumentValue(
"netlist");
2109 Xyce::dout() <<
"\n " << netListFile;
2110 Xyce::dout() <<
" AnalysisManager::completeHomotopyStep " << std::endl;
2114 bool bs1 = tiaDataStore_->updateStateDataArrays (); bsuccess = bsuccess && bs1;
2115 tiaDataStore_->setConstantHistory();
2116 tiaDataStore_->equateTmpVectors();
2119 loader_->homotopyStepSuccess (paramNames,paramVals);
2122 outputManagerAdapter_->outputHomotopy( paramNames, paramVals, *solnVecPtr );
2138 bool bsuccess =
true;
2140 #ifdef Xyce_DEBUG_ANALYSIS
2141 std::string netListFile =
commandLine_.getArgumentValue(
"netlist");
2142 Xyce::dout() <<
"\n " << netListFile;
2143 Xyce::dout() <<
" AnalysisManager::failHomotopyStep " << std::endl;
2147 loader_->homotopyStepFailure ();
2167 bool bsuccess =
true;
2169 bsuccess = bsuccess && bs1;
2173 Report::DevelFatal0().in(
"AnalysisManager::setupMPDEMgr_") <<
"Registration function failed";
2191 std::string netListFile =
"";
2194 netListFile =
commandLine_.getArgumentValue(
"netlist");
2198 "TIMEINT", netListFile,
new AnalysisManager_TranOptionsReg(
this ) );
2201 "TRAN", netListFile,
new AnalysisManager_TransAnalysisReg(
this ) );
2204 "RESULT", netListFile,
new AnalysisManager_ResultOptionsReg( *
this ) );
2207 "DC", netListFile,
new AnalysisManager_DCAnalysisReg(
this ) );
2210 "OP", netListFile,
new AnalysisManager_OPAnalysisReg(
this ) );
2213 "STEP", netListFile,
new AnalysisManager_STEPAnalysisReg(
this ) );
2216 "OP_IO", netListFile,
new AnalysisManager_DCOPOptionsReg(
this ) );
2219 "SAVE", netListFile,
new AnalysisManager_SaveOptionsReg(
this ) );
2223 "MPDE", netListFile,
new AnalysisManager_MPDE_AnalysisReg(
this ) );
2226 "MPDEINT", netListFile,
new AnalysisManager_MPDE_OptionsReg(
this ) );
2229 "TIMEINT-MPDE", netListFile,
new AnalysisManager_MPDE_TranMPDEOptionsReg(
this ) );
2233 "HB", netListFile,
new AnalysisManager_HB_AnalysisReg(
this ) );
2236 "HBINT", netListFile,
new AnalysisManager_HB_OptionsReg(
this ) );
2239 "LINSOL-HB", netListFile,
new AnalysisManager_HB_LinSolReg(
this ) );
2242 "LINSOL", netListFile,
new AnalysisManager_LinSolReg(
this ) );
2246 "AC", netListFile,
new AnalysisManager_AC_AnalysisReg(
this ) );
2250 "MOR", netListFile,
new AnalysisManager_MOR_AnalysisReg(
this ) );
2254 "MOR_OPTS", netListFile,
new AnalysisManager_MOR_OptionsReg(
this ) );
2257 "SENS", netListFile,
new AnalysisManager_SensOptionsReg(
this ) );
2276 mpdeMgrPtr_->registerAnalysisManager(
this);
2277 mpdeMgrPtr_->registerDeviceInterface(devInterfacePtr_);
2278 mpdeMgrPtr_->registerParallelManager(pdsMgrPtr_);
2279 mpdeMgrPtr_->registerTopology(topoMgrPtr_);
2280 mpdeMgrPtr_->registerRestartManager(restartPtr_);
2281 mpdeMgrPtr_->registerOutputManager(outMgrPtr_);
2282 mpdeMgrPtr_->registerApplicationLoader(loader_);
2283 mpdeMgrPtr_->registerNonlinearEquationLoader(nonlinearEquationLoaderPtr_);
2284 mpdeMgrPtr_->registerApplicationBuilder(appBuilderPtr_);
2285 mpdeMgrPtr_->registerLinearSystem(linearSystem_);
2287 mpdeMgrPtr_->registerTIAMPDEInterface(tiaMPDEIfacePtr_);
2319 N_LAS_Vector * SolVectorPtr,
2320 N_LAS_Vector * CurrSolVectorPtr,
2321 N_LAS_Vector * LastSolVectorPtr,
2322 N_LAS_Vector * StaVectorPtr,
2323 N_LAS_Vector * CurrStaVectorPtr,
2324 N_LAS_Vector * LastStaVectorPtr,
2325 N_LAS_Vector * StaDerivVectorPtr,
2326 N_LAS_Vector * StoVectorPtr,
2327 N_LAS_Vector * CurrStoVectorPtr,
2328 N_LAS_Vector * LastStoVectorPtr,
2329 N_LAS_Vector * stoLeadCurrQVectorPtr,
2330 N_LAS_Vector * QVectorPtr,
2331 N_LAS_Vector * FVectorPtr,
2332 N_LAS_Vector * BVectorPtr,
2333 N_LAS_Vector * dFdxdVpVectorPtr,
2334 N_LAS_Vector * dQdxdVpVectorPtr,
2335 N_LAS_Matrix * dQdxMatrixPtr,
2336 N_LAS_Matrix * dFdxMatrixPtr
2340 bool bsuccess =
loader_->loadDAEVectors(
2351 stoLeadCurrQVectorPtr,
2359 bsuccess = bsuccess &&
loader_->loadDAEMatrices(
2379 N_LAS_Vector * SolVectorPtr,
2380 N_LAS_Vector * StaVectorPtr,
2381 N_LAS_Vector * StoVectorPtr
2388 bool bsuccess =
loader_->updateState(
2528 Report::DevelFatal0().in(
"AnalysisManager::simulationComplete") <<
"Called for non-transient run, not currently valid";
2628 return (stepNum <= 0);
2874 const std::list<index_pair> & solGIDList,
2875 const std::list<index_pair> & staGIDList)
2933 (
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm,
bool pack)
2935 return stepErrorControl_->dumpRestartData(buf, bsize, pos, comm, pack);
2947 (
char * buf,
int bsize,
int & pos, N_PDS_Comm * comm,
bool pack)
2949 return stepErrorControl_->restoreRestartData(buf, bsize, pos, comm, pack);
2961 std::vector<double> & varData )
2975 std::vector<double> & varData )
2989 std::vector<double> & varData )
3055 const std::vector<double> & varData )
3069 const std::vector<double> & varData )
3083 const std::vector<double> & varData )
3178 IO::RestartMgr * restartPtr_tmp)