46 #include <Xyce_config.h>
56 #include <N_ERH_ErrorMgr.h>
57 #include <N_IO_OutputMgr.h>
58 #include <N_LAS_Builder.h>
59 #include <N_LAS_Matrix.h>
60 #include <N_LAS_System.h>
61 #include <N_LAS_Vector.h>
70 #include <N_UTL_FeatureTest.h>
71 #include <N_UTL_OptionBlock.h>
72 #include <N_UTL_Param.h>
90 const IO::CmdParse & cp)
92 twoLevelAlgorithm_(3),
93 twoLevelAlgorithmTran_(0),
97 setupOuterLoopParamsFlag_(false),
98 setupTranParamsFlag_(false),
99 externalAnalysisMode(
DC_OP),
100 outerLoopActiveFlag_(true),
102 noxFlagInner_(noxFlagInner),
103 numInterfaceNodesSetup_(false),
109 continuationType_(1),
110 innerLoopFailFatal_(true),
111 totalSolveFailFatal_(false),
112 doFullNewtonFinalEnforcement_(true),
114 firstDCOPFlag_(false),
115 increaseContScalar_(1.5),
116 decreaseContScalar_(0.2),
117 continuationCalledBefore_(false),
172 bool bsuccess =
true;
177 bsuccess = bsuccess && tmpBool;
180 bsuccess = bsuccess && tmpBool;
194 (Linear::System * ptr)
196 bool bsuccess =
true;
200 tmpBool = nlsOuterPtr_->registerLinearSystem (ptr);
201 bsuccess = bsuccess && tmpBool;
203 tmpBool = nlsInnerPtr_->registerLinearSystem (ptr);
204 bsuccess = bsuccess && tmpBool;
219 bool bsuccess =
true;
224 bsuccess = bsuccess && tmpBool;
227 bsuccess = bsuccess && tmpBool;
242 bool bsuccess =
true;
247 bsuccess = bsuccess && tmpBool;
250 bsuccess = bsuccess && tmpBool;
311 int numLinSolves = 0;
327 int numFLinSolves = 0;
330 return numFLinSolves;
375 double totalLinSolveTime = 0.0;
378 return totalLinSolveTime;
391 double totalResLoadTime = 0.0;
394 return totalResLoadTime;
407 double totalJacLoadTime = 0.0;
410 return totalJacLoadTime;
496 bool bsuccess =
true;
500 bsuccess = bsuccess && tmpBool;
503 bsuccess = bsuccess && tmpBool;
506 bsuccess = bsuccess && tmpBool;
540 Util::ParamList::const_iterator it_tpL = OB.begin();
541 Util::ParamList::const_iterator end_tpL = OB.end();
542 for ( ; it_tpL != end_tpL; ++it_tpL)
544 if (it_tpL->uTag() ==
"MAXSTEP")
546 maxOuterSteps_ =
static_cast<int>(it_tpL->getImmutableValue<
int>());
611 Util::OptionBlock OBtmp;
613 Util::ParamList::const_iterator it_tpL = OB.begin();
614 Util::ParamList::const_iterator end_tpL = OB.end();
615 for ( ; it_tpL != end_tpL; ++it_tpL)
617 if (it_tpL->uTag() ==
"ALGORITHM")
621 else if (it_tpL->uTag() ==
"NOX")
625 else if (it_tpL->uTag() ==
"MAXCONTSTEPS")
627 maxContSteps_ =
static_cast<int>(it_tpL->getImmutableValue<
int>());
629 else if (it_tpL->uTag() ==
"CONTINUATIONFLAG")
631 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
634 else if (it_tpL->uTag() ==
"INNERFAIL")
636 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
639 else if (it_tpL->uTag() ==
"EXITWITHFAILURE")
641 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
644 else if (it_tpL->uTag() ==
"FULLNEWTONENFORCE")
646 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
649 else if (it_tpL->uTag() ==
"CONPARAM")
653 else if (it_tpL->uTag() ==
"VOLTLIMTOL")
655 voltLimTol_ =
static_cast<double>(it_tpL->getImmutableValue<
double>());
660 OBtmp.getParams().push_back(*it_tpL);
668 if (twoLevelAlgorithm_ < 0 || twoLevelAlgorithm_ > 5)
670 Report::UserWarning0() <<
"Now the only algorithms 0 to 5 are two-level algorithm. Resetting to 0";
675 if (VERBOSE_NONLINEAR)
677 Xyce::dout() <<
"\n" << std::endl
678 << Xyce::section_divider << std::endl
679 <<
"\n***** 2-level Inner Loop Nonlinear solver options:\n" << std::endl
684 Xyce::dout() <<
"\n***** Done printing Inner Loop Params:\n" << std::endl
685 << Xyce::section_divider << std::endl
686 <<
"\n" << std::endl;
707 if (VERBOSE_NONLINEAR)
708 Xyce::dout() <<
"In TwoLevelNewton::setTwoLevelTranOptions" << std::endl;
710 Util::OptionBlock OBtmp;
712 Util::ParamList::const_iterator it_tpL = OB.begin();
713 Util::ParamList::const_iterator end_tpL = OB.end();
714 for ( ; it_tpL != end_tpL; ++it_tpL)
716 if (it_tpL->uTag() ==
"ALGORITHM")
720 else if ( it_tpL->uTag() ==
"MAXCONTSTEPS" )
727 OBtmp.getParams().push_back(*it_tpL);
733 if (twoLevelAlgorithmTran_ < 0 || twoLevelAlgorithmTran_ > 3)
735 Report::UserWarning0() <<
"Now the only algorithms 0 to 3 are two-level algorithm. Resetting to 0";
757 if (VERBOSE_NONLINEAR)
758 Xyce::dout() << std::endl
759 <<
"Setting the externalAnalysisMode = " << mode << std::endl;
778 bool bsuccess =
true;
781 bsuccess = bsuccess && tmpBool;
784 bsuccess = bsuccess && tmpBool;
787 bsuccess = bsuccess && tmpBool;
807 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tFULL PROBLEM --------------------------------" << std::endl;
811 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tINNER PROBLEM ----------------------------" << std::endl;
815 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tOUTER PROBLEM ----------------------------" << std::endl;
900 if (VERBOSE_NONLINEAR)
901 Xyce::dout() << std::endl <<
"Running algorithm 0:" << std::endl;
962 if (VERBOSE_NONLINEAR)
963 Xyce::dout() << std::endl <<
"Running algorithm 1:" << std::endl;
965 bool firstOuterStepTaken =
false;
981 if (VERBOSE_NONLINEAR)
994 if (firstOuterStepTaken)
1000 firstOuterStepTaken =
true;
1007 if (VERBOSE_NONLINEAR)
1020 if (VERBOSE_NONLINEAR && status >=0)
1021 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1046 bool statusFull =
false;
1047 bool firstOuterStepTaken =
false;
1049 if (VERBOSE_NONLINEAR)
1050 Xyce::dout() << std::endl <<
"Running algorithm 2:" << std::endl;
1055 firstOuterStepTaken =
true;
1060 if (VERBOSE_NONLINEAR)
1089 if (VERBOSE_NONLINEAR)
1106 if (firstOuterStepTaken)
1112 firstOuterStepTaken =
true;
1118 if (VERBOSE_NONLINEAR)
1127 if (status > 0 && statInner>0) statusFull =
true;
1129 if (statusFull)
break;
1134 if (VERBOSE_NONLINEAR && status >0 && statInner > 0)
1135 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1161 bool statusFull =
false;
1162 bool firstOuterStepTaken =
false;
1164 if (VERBOSE_NONLINEAR)
1165 Xyce::dout() << std::endl <<
"Running algorithm 3:" << std::endl;
1196 if (VERBOSE_NONLINEAR)
1215 if (firstOuterStepTaken)
1221 firstOuterStepTaken =
true;
1231 if (VERBOSE_NONLINEAR)
1236 double twoNormJDXP_ = 0.0;
1241 if (VERBOSE_NONLINEAR)
1242 Xyce::dout() << std::endl
1243 <<
" 2-norm of voltage limiting vector: " << twoNormJDXP_ << std::endl;
1247 if (status > 0 && statInner>0 && voltLimStat) statusFull =
true;
1249 if (statusFull)
break;
1264 if (VERBOSE_NONLINEAR)
1274 if (VERBOSE_NONLINEAR && status >0 && statInner > 0 && statFinal > 0)
1275 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1303 bool continuationLoop =
false;
1305 int contMaxTmp = 100;
1306 int stepsLeft = contMaxTmp;
1308 if (VERBOSE_NONLINEAR)
1309 Xyce::dout() << std::endl <<
"Running algorithm 4:" << std::endl
1310 << std::endl <<
"Initial continuation steps: "
1311 << contMaxTmp << std::endl;
1326 double initVal = 0.0;
1327 double currVal = initVal;
1328 double prevVal = initVal;
1331 std::vector<std::string>::iterator iter;
1332 std::vector<std::string>::iterator begin =
paramNameList.begin ();
1333 std::vector<std::string>::iterator end =
paramNameList.end ();
1335 std::vector<double>::iterator iterFinalVal;
1336 std::vector<double>::iterator beginFinalVal =
paramFinalVal.begin ();
1337 std::vector<double>::iterator endFinalVal =
paramFinalVal.end ();
1339 std::vector<double>::iterator iterCurrentVal;
1340 std::vector<double>::iterator beginCurrentVal =
paramCurrentVal.begin ();
1344 for (iter=begin, iterFinalVal=beginFinalVal, iterCurrentVal=beginCurrentVal;
1346 ++iter, ++iterFinalVal, ++iterCurrentVal)
1349 *iterFinalVal = 1.0;
1357 for (iter=begin, iterFinalVal=beginFinalVal;
1359 ++iter, ++iterFinalVal)
1362 stepSizeEst = (*iterFinalVal-0.0)/(
static_cast<double>(contMaxTmp));
1367 if (VERBOSE_NONLINEAR)
1368 Xyce::dout() <<
"Parameter = " << *iter
1369 <<
" finalVal = " << *iterFinalVal << std::endl;
1372 bool continuationLoopFinished =
false;
1373 int numTotalFailures = 0;
1374 while (!continuationLoopFinished)
1376 bool stepFinished =
false;
1377 int numFailures = 0;
1379 while(!stepFinished)
1381 if (stepSizeEst != 0.0)
1383 stepsLeft =
static_cast<int>((*iterFinalVal-currVal)/stepSizeEst) + 1;
1390 if (VERBOSE_NONLINEAR)
1391 Xyce::dout() << std::endl <<
"Continuation Step: " <<
contStep_
1392 <<
" Estimated Remaining Steps: " << stepsLeft
1395 <<
"currVal= " << currVal
1396 <<
" prevVal= " << prevVal
1397 <<
" step= " << stepSizeEst
1402 std::string tmp =
"Continuation step estimate broken. Exiting\n";
1403 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1407 (*savedNextSolPtr_) = (**nextSolVectorPtrPtr_);
1411 *iterCurrentVal = currVal;
1426 successBool = (statNL > 0);
1430 stepFinished =
true;
1433 if (numFailures <= 0)
1439 if (numFailures < 0) numFailures = 0;
1442 currVal += stepSizeEst;
1444 if ( (*iterFinalVal >= 0 && currVal > *iterFinalVal) ||
1445 (*iterFinalVal < 0 && currVal < *iterFinalVal) )
1447 currVal = *iterFinalVal;
1448 stepSizeEst = currVal - prevVal;
1451 if (DEBUG_NONLINEAR)
1453 Xyce::dout() <<
"\nRight before outputHOMOTOPY:" << std::endl;
1474 currVal = prevVal + stepSizeEst;
1485 continuationLoopFinished =
1486 ( (*iterFinalVal >= 0 && prevVal >= *iterFinalVal) ||
1487 (*iterFinalVal < 0 && prevVal <= *iterFinalVal) );
1491 if (VERBOSE_NONLINEAR)
1492 Xyce::dout() <<
"currVal= " << currVal
1493 <<
" prevVal= " << prevVal
1496 <<
"Total number of failures = " << numTotalFailures << std::endl
1497 <<
"Number of actual steps = " <<
contStep_-1
1525 if (VERBOSE_NONLINEAR)
1526 Xyce::dout() << std::endl <<
"Running algorithm 5:" << std::endl;
1566 if (doubleDCOPEnable && (tiaMode == 0) && (ddcopStep==0) )
1582 if (VERBOSE_NONLINEAR)
1583 Xyce::dout() << std::endl
1595 else if (algorithm == 1)
1600 else if (algorithm == 2)
1606 else if (algorithm == 3)
1610 else if (algorithm == 4)
1614 else if (algorithm == 5)
1621 "Two-Level Newton Algorithm set to invalid number.\n";
1622 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1631 #ifndef Xyce_PARALLEL_MPI
1636 "Two-Level Newton Algorithm failed to converge. Exiting.\n";
1637 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1670 bool bsuccess =
true;
1671 bool tmpBool =
true;
1673 char filename1[256];
1675 for (
int ich = 0; ich < 256; ++ich)
1676 { filename1[ich] = 0; }
1689 sprintf(filename1,
"%s",
"tmpJac.txt");
1690 Linear::Matrix *A =
lasSysPtr_->getJacobianMatrix();
1691 A->writeToFile(filename1);
1694 Linear::Vector *rhsVecPtr =
lasSysPtr_->getRHSVector();
1705 if (VERBOSE_NONLINEAR)
1706 Xyce::dout() <<
"\n numCoupleTerms = " << numCoupleTerms << std::endl;
1708 for (iCouple=0;iCouple<numCoupleTerms;++iCouple)
1711 rhsVecPtr->putScalar(0.0);
1715 bsuccess = bsuccess && tmpBool;
1717 sprintf(filename1,
"dfdv%02d.txt", iCouple);
1718 rhsVecPtr->writeToFile(filename1);
1722 bsuccess = bsuccess && tmpBool;
1725 sprintf(filename1,
"dvdx%02d.txt", iCouple);
1726 newtVecPtr->writeToFile(filename1);
1731 *rhsVecPtr = *newtVecPtr;
1735 bsuccess = bsuccess && tmpBool;
1765 int suggestedSteps = 10;
1768 if (suggestedSteps < 1) suggestedSteps = 1;
1769 contMaxTmp = suggestedSteps;
1771 double stepSizeEst = 1.0/(
static_cast<double>(contMaxTmp));
1772 double currentAlpha = 0.0;
1773 double previousAlpha = 0.0;
1774 int stepsLeft = contMaxTmp;
1783 currentAlpha = stepSizeEst;
1788 bool continuationLoopFinished =
false;
1790 int numTotalFailures = 0;
1792 while (!continuationLoopFinished)
1794 bool stepFinished =
false;
1795 int numFailures = 0;
1797 while(!stepFinished)
1800 stepsLeft =
static_cast<int>((1.0-currentAlpha)/stepSizeEst) + 1;
1802 if (VERBOSE_NONLINEAR)
1803 Xyce::dout() << std::endl <<
"Continuation Step: " <<
contStep_
1804 <<
" Estimated Remaining Steps: " << stepsLeft
1806 <<
"current alpha = " << currentAlpha
1807 <<
" prev. alpha = " << previousAlpha
1808 <<
" step = " << stepSizeEst
1813 std::string tmp =
"Continuation step estimate broken. Exiting\n";
1814 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1818 (*savedNextSolPtr_) = (**nextSolVectorPtrPtr_);
1820 std::string paramName =
"pdealpha";
1833 if (DEBUG_NONLINEAR)
1834 Xyce::dout() <<
"Status of inner loop solve: " << statInner << std::endl;
1836 successBool = (statInner > 0);
1840 stepFinished =
true;
1842 if (numFailures <= 0)
1848 if (numFailures < 0) numFailures = 0;
1850 previousAlpha = currentAlpha;
1851 currentAlpha += stepSizeEst;
1853 if (currentAlpha > 1.0)
1856 stepSizeEst = currentAlpha - previousAlpha;
1864 (**nextSolVectorPtrPtr_) = (*savedNextSolPtr_);
1869 currentAlpha = previousAlpha + stepSizeEst;
1879 continuationLoopFinished = (previousAlpha >= 1.0);
1883 if (VERBOSE_NONLINEAR)
1884 Xyce::dout() <<
"current alpha = " << currentAlpha
1885 <<
" previous alpha = " << previousAlpha
1888 <<
"Total number of failures = " << numTotalFailures << std::endl
1889 <<
"Number of actual steps = " <<
contStep_-1
1923 Xyce::dout() <<
"suggested steps are: " << suggestedSteps << std::endl;
1925 Util::ParamList::const_iterator it_tpL;
1930 ExtendedString tmpTag = it_tpL->tag ();
1933 Xyce::dout() <<
"tmpTag = " << tmpTag << std::endl;
1935 if (tmpTag ==
"CONTINUATION")
1937 if (suggestedSteps <= 1)
1939 Xyce::dout() <<
"Setting the solver type to 0" << std::endl;
1982 if (VERBOSE_NONLINEAR)
1983 Xyce::dout() << std::endl
1984 << Xyce::section_divider << std::endl
1985 <<
"TwoLevelNewton::enableSensitivity " << std::endl;
1987 bool bsuccess =
true;
1988 bool tmpBool =
true;
1994 if (VERBOSE_NONLINEAR) {
1996 double maxNormRHS_=0, twoNormRHS_ = 0.0;
1999 Xyce::dout().width(21); Xyce::dout().precision(13); Xyce::dout().setf(std::ios::scientific);
2000 Xyce::dout() << std::endl;
2001 Xyce::dout() <<
"Max. norm of full Newton RHS: " << maxNormRHS_ << std::endl;
2002 Xyce::dout() <<
" 2-norm of full Newton RHS: " << twoNormRHS_ << std::endl;
2003 Xyce::dout() << Xyce::section_divider << std::endl;
2006 if (DEBUG_NONLINEAR)
2009 static int callsSens = 0;
2010 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
2011 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
2013 sprintf(filename1,
"matrixTmp%d.txt",callsSens);
2014 Linear::Matrix *A =
lasSysPtr_->getJacobianMatrix();
2015 A->writeToFile(filename1);
2018 Linear::Vector *b =
lasSysPtr_->getRHSVector();
2019 sprintf(filename2,
"rhsTmp%d.txt", callsSens);
2023 #ifndef Xyce_PARALLEL_MPI
2024 fp1 = fopen(filename2,
"w");
2026 for (i=0;i<size;++i)
2028 double output = b->getElementByGlobalIndex(i);
2029 fprintf(fp1,
"%25.18e\n",output);
2034 Linear::Vector *x = (*nextSolVectorPtrPtr_);
2035 sprintf(filename2,
"solTmp%d.txt", callsSens);
2037 #ifndef Xyce_PARALLEL_MPI
2038 fp1 = fopen(filename2,
"w");
2040 for (i=0;i<size;++i)
2042 double output = x->getElementByGlobalIndex(i);
2043 fprintf(fp1,
"%25.18e\n",output);
virtual int getNumFailedLinearSolves()
Util::OptionBlock innerLocaOptions_
virtual int getMaxNormFindex() const =0
void zeroInnerLoopStatistics_()
bool outerLoopActiveFlag_
std::vector< std::string > paramNameList
virtual double getTotalLinearSolveTime()
bool registerLoader(Loader::NonlinearEquationLoader *ptr)
std::vector< int > numInterfaceNodes_
bool setTwoLevelTranOptions(const Util::OptionBlock &OB)
bool loadCouplingRHS(int iSubProblem, int iCouple, Linear::Vector *dfdvPtr)
void setAnalysisMode(AnalysisMode mode)
virtual int solve(NonLinearSolver *nlsTmpPtr=NULL)=0
void calcInnerLoopStatistics_()
bool doFullNewtonFinalEnforcement_
bool registerLinearSystem(Linear::System *ptr)
virtual bool setTranOptions(const Util::OptionBlock &OB)=0
virtual int takeFirstSolveStep(NonLinearSolver *nlsTmpPtr=NULL)
double totalResidualLoadTime_
Linear::Vector * jdxpVectorPtr_
bool calcCouplingTerms_()
Pure virtual class to augment a linear system.
bool setTranOptions(const Util::OptionBlock &OB)
virtual int getNumJacobianLoads()
virtual int getNumLinearSolves()
virtual double getTotalResidualLoadTime()
NonLinearSolver * nlsOuterPtr_
int doubleDCOPStep
Analysis.
bool totalSolveFailFatal_
virtual int getNumIterations() const =0
bool setTwoLevelLocaOptions(const Util::OptionBlock &OB)
bool setTwoLevelOptions(const Util::OptionBlock &OB)
Analysis::AnalysisManager * analysisManager_
virtual void setReturnCodes(const ReturnCodes &retCodesTmp)
double increaseContScalar_
std::vector< double > paramCurrentVal
virtual double getTotalLinearSolveTime()
bool setLocaOptions(const Util::OptionBlock &OB)
unsigned int totalNumLinearIters_
Linear::Vector * rhsVectorPtr_
bool isFirstContinuationParam() const
virtual double getTotalResidualLoadTime()
bool registerAnalysisManager(Analysis::AnalysisManager *analysis_manager)
Util::OptionBlock innerSolverOptions_
bool setHBOptions(const Util::OptionBlock &OB)
virtual bool setPetraOptions(const Util::OptionBlock &OB)
bool doubleDCOPEnabled
Analysis.
TwoLevelNewtonMode getCouplingMode()
virtual bool initializeAll()
void getTimeIntInfo(const AnalysisManager &analysis_manager, TimeIntg::TimeIntInfo &tiInfo)
bool disablePDEContinuation()
int solve(NonLinearSolver *nlsTmpPtr=NULL)
int twoLevelAlgorithmTran_
double totalJacobianLoadTime_
bool setParam(std::string &name, double val, bool overrideOriginal=false)
const Loader & getLoader() const
void calcOuterLoopStatistics_()
IO::OutputMgr * outMgrPtr_
bool registerLoader(Loader::NonlinearEquationLoader *ptr)
N_PDS_Manager * pdsMgrPtr_
int getMaxNormFindex() const
bool setOptions(const Util::OptionBlock &OB)
int numFailedLinearSolves_
bool calcCouplingTerms(int iSubProblem, int iCouple, const Linear::Vector *dxdvPtr)
Linear::System * lasSysPtr_
Linear::Vector ** nextSolVectorPtrPtr_
bool registerTwoLevelSolver(TwoLevelNewton *ptr)
virtual unsigned int getTotalNumLinearIters()
const IO::CmdParse & commandLine_
virtual int getNumResidualLoads()
virtual unsigned int getTotalNumLinearIters()
double getMaxNormF() const
virtual int getNumJacobianLoads()
bool numInterfaceNodesSetup_
int getNumIterations() const
bool continuationCalledBefore_
int getParameterNumber() const
Linear::Vector * savedNextSolPtr_
Util::OptionBlock outerLocaOptions_
int getContinuationStep() const
virtual double getTotalJacobianLoadTime()
virtual int getNumLinearSolves()
double decreaseContScalar_
Linear::Vector * NewtonVectorPtr_
NonLinearSolver * nlsPassingPtr_
virtual int takeOneSolveStep()
AnalysisMode externalAnalysisMode
Linear::Vector * savedRHSPtr_
int numJacobianFactorizations_
double totalLinearSolveTime_
bool registerAnalysisManager(Analysis::AnalysisManager *tmp_anaIntPtr)
NonLinearSolver * nlsInnerPtr_
bool setPetraOptions(const Util::OptionBlock &OB)
virtual int getNumJacobianFactorizations()
virtual int getNumFailedLinearSolves()
TwoLevelNewtonMode twoLevelCouplingMode_
void getNumInterfaceNodes(std::vector< int > &numINodes)
int enablePDEContinuation()
virtual void setAnalysisMode(AnalysisMode mode)=0
bool registerOutputMgr(IO::OutputMgr *ptr)
virtual int getNumJacobianFactorizations()
Loader::NonlinearEquationLoader * loaderPtr_
bool registerOutputMgr(IO::OutputMgr *outPtr)
void printStepInfo_(int step, int success, TwoLevelNewtonMode solveType)
virtual bool setOptions(const Util::OptionBlock &OB)=0
virtual int getNumResidualLoads()
virtual double getTotalJacobianLoadTime()
virtual double getMaxNormF() const =0
std::vector< double > paramFinalVal
bool setupTranParamsFlag_
virtual bool output() const
virtual bool setLocaOptions(const Util::OptionBlock &OB)