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>
69 #include <N_UTL_FeatureTest.h>
70 #include <N_UTL_OptionBlock.h>
71 #include <N_UTL_Param.h>
89 const IO::CmdParse & cp)
91 twoLevelAlgorithm_(3),
92 twoLevelAlgorithmTran_(0),
96 setupOuterLoopParamsFlag_(false),
97 setupTranParamsFlag_(false),
98 externalAnalysisMode(
DC_OP),
99 outerLoopActiveFlag_(true),
101 noxFlagInner_(noxFlagInner),
102 numInterfaceNodesSetup_(false),
108 continuationType_(1),
109 innerLoopFailFatal_(true),
110 totalSolveFailFatal_(false),
111 doFullNewtonFinalEnforcement_(true),
113 increaseContScalar_(1.5),
114 decreaseContScalar_(0.2),
115 continuationCalledBefore_(false),
169 bool bsuccess =
true;
174 bsuccess = bsuccess && tmpBool;
177 bsuccess = bsuccess && tmpBool;
192 bool bsuccess =
true;
198 bsuccess = bsuccess && tmpBool;
201 bsuccess = bsuccess && tmpBool;
217 bool bsuccess =
true;
223 bsuccess = bsuccess && tmpBool;
226 bsuccess = bsuccess && tmpBool;
241 bool bsuccess =
true;
246 bsuccess = bsuccess && tmpBool;
249 bsuccess = bsuccess && tmpBool;
264 bool bsuccess =
true;
269 bsuccess = bsuccess && tmpBool;
272 bsuccess = bsuccess && tmpBool;
287 bool bsuccess =
true;
292 bsuccess = bsuccess && tmpBool;
295 bsuccess = bsuccess && tmpBool;
356 int numLinSolves = 0;
372 int numFLinSolves = 0;
375 return numFLinSolves;
420 double totalLinSolveTime = 0.0;
423 return totalLinSolveTime;
436 double totalResLoadTime = 0.0;
439 return totalResLoadTime;
452 double totalJacLoadTime = 0.0;
455 return totalJacLoadTime;
541 bool bsuccess =
true;
545 bsuccess = bsuccess && tmpBool;
548 bsuccess = bsuccess && tmpBool;
551 bsuccess = bsuccess && tmpBool;
585 Util::ParamList::const_iterator it_tpL = OB.begin();
586 Util::ParamList::const_iterator end_tpL = OB.end();
587 for ( ; it_tpL != end_tpL; ++it_tpL)
589 if (it_tpL->uTag() ==
"MAXSTEP")
591 maxOuterSteps_ =
static_cast<int>(it_tpL->getImmutableValue<
int>());
677 Util::OptionBlock OBtmp;
679 Util::ParamList::const_iterator it_tpL = OB.begin();
680 Util::ParamList::const_iterator end_tpL = OB.end();
681 for ( ; it_tpL != end_tpL; ++it_tpL)
683 if (it_tpL->uTag() ==
"ALGORITHM")
687 else if (it_tpL->uTag() ==
"NOX")
691 else if (it_tpL->uTag() ==
"MAXCONTSTEPS")
693 maxContSteps_ =
static_cast<int>(it_tpL->getImmutableValue<
int>());
695 else if (it_tpL->uTag() ==
"CONTINUATIONFLAG")
697 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
700 else if (it_tpL->uTag() ==
"INNERFAIL")
702 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
705 else if (it_tpL->uTag() ==
"EXITWITHFAILURE")
707 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
710 else if (it_tpL->uTag() ==
"FULLNEWTONENFORCE")
712 int tmp =
static_cast<int>(it_tpL->getImmutableValue<
int>());
715 else if (it_tpL->uTag() ==
"CONPARAM")
719 else if (it_tpL->uTag() ==
"VOLTLIMTOL")
721 voltLimTol_ =
static_cast<double>(it_tpL->getImmutableValue<
double>());
726 OBtmp.addParam(*it_tpL);
734 if (twoLevelAlgorithm_ < 0 || twoLevelAlgorithm_ > 5)
736 Report::UserWarning0() <<
"Now the only algorithms 0 to 5 are two-level algorithm. Resetting to 0";
741 if (VERBOSE_NONLINEAR)
743 Xyce::dout() <<
"\n" << std::endl
744 << Xyce::section_divider << std::endl
745 <<
"\n***** 2-level Inner Loop Nonlinear solver options:\n" << std::endl
750 Xyce::dout() <<
"\n***** Done printing Inner Loop Params:\n" << std::endl
751 << Xyce::section_divider << std::endl
752 <<
"\n" << std::endl;
773 if (VERBOSE_NONLINEAR)
774 Xyce::dout() <<
"In TwoLevelNewton::setTwoLevelTranOptions" << std::endl;
776 Util::OptionBlock OBtmp;
778 Util::ParamList::const_iterator it_tpL = OB.begin();
779 Util::ParamList::const_iterator end_tpL = OB.end();
780 for ( ; it_tpL != end_tpL; ++it_tpL)
782 if (it_tpL->uTag() ==
"ALGORITHM")
786 else if ( it_tpL->uTag() ==
"MAXCONTSTEPS" )
793 OBtmp.addParam(*it_tpL);
799 if (twoLevelAlgorithmTran_ < 0 || twoLevelAlgorithmTran_ > 3)
801 Report::UserWarning0() <<
"Now the only algorithms 0 to 3 are two-level algorithm. Resetting to 0";
823 if (VERBOSE_NONLINEAR)
824 Xyce::dout() << std::endl
825 <<
"Setting the externalAnalysisMode = " << mode << std::endl;
844 bool bsuccess =
true;
847 bsuccess = bsuccess && tmpBool;
850 bsuccess = bsuccess && tmpBool;
853 bsuccess = bsuccess && tmpBool;
873 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tFULL PROBLEM --------------------------------" << std::endl;
877 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tINNER PROBLEM ----------------------------" << std::endl;
881 Xyce::lout() <<
"---------- 2LNiter: " << step <<
"\t" << success <<
"\tOUTER PROBLEM ----------------------------" << std::endl;
964 bool nl_poisson_dcop)
968 if (VERBOSE_NONLINEAR)
969 Xyce::dout() << std::endl <<
"Running algorithm 0:" << std::endl;
981 if (!nl_poisson_dcop)
1030 if (VERBOSE_NONLINEAR)
1031 Xyce::dout() << std::endl <<
"Running algorithm 1:" << std::endl;
1033 bool firstOuterStepTaken =
false;
1049 if (VERBOSE_NONLINEAR)
1062 if (firstOuterStepTaken)
1068 firstOuterStepTaken =
true;
1075 if (VERBOSE_NONLINEAR)
1088 if (VERBOSE_NONLINEAR && status >=0)
1089 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1114 bool statusFull =
false;
1115 bool firstOuterStepTaken =
false;
1117 if (VERBOSE_NONLINEAR)
1118 Xyce::dout() << std::endl <<
"Running algorithm 2:" << std::endl;
1123 firstOuterStepTaken =
true;
1128 if (VERBOSE_NONLINEAR)
1157 if (VERBOSE_NONLINEAR)
1174 if (firstOuterStepTaken)
1180 firstOuterStepTaken =
true;
1186 if (VERBOSE_NONLINEAR)
1195 if (status > 0 && statInner>0) statusFull =
true;
1197 if (statusFull)
break;
1202 if (VERBOSE_NONLINEAR && status >0 && statInner > 0)
1203 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1229 bool statusFull =
false;
1230 bool firstOuterStepTaken =
false;
1232 if (VERBOSE_NONLINEAR)
1233 Xyce::dout() << std::endl <<
"Running algorithm 3:" << std::endl;
1264 if (VERBOSE_NONLINEAR)
1283 if (firstOuterStepTaken)
1289 firstOuterStepTaken =
true;
1299 if (VERBOSE_NONLINEAR)
1304 double twoNormJDXP_ = 0.0;
1309 if (VERBOSE_NONLINEAR)
1310 Xyce::dout() << std::endl
1311 <<
" 2-norm of voltage limiting vector: " << twoNormJDXP_ << std::endl;
1315 if (status > 0 && statInner>0 && voltLimStat) statusFull =
true;
1317 if (statusFull)
break;
1332 if (VERBOSE_NONLINEAR)
1342 if (VERBOSE_NONLINEAR && status >0 && statInner > 0 && statFinal > 0)
1343 Xyce::dout() <<
"TWO LEVEL Newton succeeded!" << std::endl;
1371 bool continuationLoop =
false;
1373 int contMaxTmp = 100;
1374 int stepsLeft = contMaxTmp;
1376 if (VERBOSE_NONLINEAR)
1377 Xyce::dout() << std::endl <<
"Running algorithm 4:" << std::endl
1378 << std::endl <<
"Initial continuation steps: "
1379 << contMaxTmp << std::endl;
1394 double initVal = 0.0;
1395 double currVal = initVal;
1396 double prevVal = initVal;
1399 std::vector<std::string>::iterator iter;
1400 std::vector<std::string>::iterator begin =
paramNameList.begin ();
1401 std::vector<std::string>::iterator end =
paramNameList.end ();
1403 std::vector<double>::iterator iterFinalVal;
1404 std::vector<double>::iterator beginFinalVal =
paramFinalVal.begin ();
1405 std::vector<double>::iterator endFinalVal =
paramFinalVal.end ();
1407 std::vector<double>::iterator iterCurrentVal;
1408 std::vector<double>::iterator beginCurrentVal =
paramCurrentVal.begin ();
1412 for (iter=begin, iterFinalVal=beginFinalVal, iterCurrentVal=beginCurrentVal;
1414 ++iter, ++iterFinalVal, ++iterCurrentVal)
1417 *iterFinalVal = 1.0;
1425 for (iter=begin, iterFinalVal=beginFinalVal;
1427 ++iter, ++iterFinalVal)
1430 stepSizeEst = (*iterFinalVal-0.0)/(
static_cast<double>(contMaxTmp));
1435 if (VERBOSE_NONLINEAR)
1436 Xyce::dout() <<
"Parameter = " << *iter
1437 <<
" finalVal = " << *iterFinalVal << std::endl;
1440 bool continuationLoopFinished =
false;
1441 int numTotalFailures = 0;
1442 while (!continuationLoopFinished)
1444 bool stepFinished =
false;
1445 int numFailures = 0;
1447 while(!stepFinished)
1449 if (stepSizeEst != 0.0)
1451 stepsLeft =
static_cast<int>((*iterFinalVal-currVal)/stepSizeEst) + 1;
1458 if (VERBOSE_NONLINEAR)
1459 Xyce::dout() << std::endl <<
"Continuation Step: " <<
contStep_
1460 <<
" Estimated Remaining Steps: " << stepsLeft
1463 <<
"currVal= " << currVal
1464 <<
" prevVal= " << prevVal
1465 <<
" step= " << stepSizeEst
1470 std::string tmp =
"Continuation step estimate broken. Exiting\n";
1471 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1475 (*savedNextSolPtr_) = (**nextSolVectorPtrPtr_);
1479 *iterCurrentVal = currVal;
1494 successBool = (statNL > 0);
1498 stepFinished =
true;
1501 if (numFailures <= 0)
1507 if (numFailures < 0) numFailures = 0;
1510 currVal += stepSizeEst;
1512 if ( (*iterFinalVal >= 0 && currVal > *iterFinalVal) ||
1513 (*iterFinalVal < 0 && currVal < *iterFinalVal) )
1515 currVal = *iterFinalVal;
1516 stepSizeEst = currVal - prevVal;
1519 if (DEBUG_NONLINEAR)
1521 Xyce::dout() <<
"\nRight before outputHOMOTOPY:" << std::endl;
1542 currVal = prevVal + stepSizeEst;
1553 continuationLoopFinished =
1554 ( (*iterFinalVal >= 0 && prevVal >= *iterFinalVal) ||
1555 (*iterFinalVal < 0 && prevVal <= *iterFinalVal) );
1559 if (VERBOSE_NONLINEAR)
1560 Xyce::dout() <<
"currVal= " << currVal
1561 <<
" prevVal= " << prevVal
1564 <<
"Total number of failures = " << numTotalFailures << std::endl
1565 <<
"Number of actual steps = " <<
contStep_-1
1593 if (VERBOSE_NONLINEAR)
1594 Xyce::dout() << std::endl <<
"Running algorithm 5:" << std::endl;
1643 if (VERBOSE_NONLINEAR)
1644 Xyce::dout() << std::endl
1650 if (algorithm == 0 || nl_poisson_dcop)
1656 else if (algorithm == 1)
1661 else if (algorithm == 2)
1667 else if (algorithm == 3)
1671 else if (algorithm == 4)
1675 else if (algorithm == 5)
1682 "Two-Level Newton Algorithm set to invalid number.\n";
1683 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1692 #ifndef Xyce_PARALLEL_MPI
1697 "Two-Level Newton Algorithm failed to converge. Exiting.\n";
1698 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1731 bool bsuccess =
true;
1732 bool tmpBool =
true;
1734 char filename1[256];
1736 for (
int ich = 0; ich < 256; ++ich)
1737 { filename1[ich] = 0; }
1750 sprintf(filename1,
"%s",
"tmpJac.txt");
1751 Linear::Matrix *A =
lasSysPtr_->getJacobianMatrix();
1752 A->writeToFile(filename1);
1755 Linear::Vector *rhsVecPtr =
lasSysPtr_->getRHSVector();
1766 if (VERBOSE_NONLINEAR)
1767 Xyce::dout() <<
"\n numCoupleTerms = " << numCoupleTerms << std::endl;
1769 for (iCouple=0;iCouple<numCoupleTerms;++iCouple)
1772 rhsVecPtr->putScalar(0.0);
1776 bsuccess = bsuccess && tmpBool;
1778 sprintf(filename1,
"dfdv%02d.txt", iCouple);
1779 rhsVecPtr->writeToFile(filename1);
1783 bsuccess = bsuccess && tmpBool;
1786 sprintf(filename1,
"dvdx%02d.txt", iCouple);
1787 newtVecPtr->writeToFile(filename1);
1792 *rhsVecPtr = *newtVecPtr;
1796 bsuccess = bsuccess && tmpBool;
1826 int suggestedSteps = 10;
1829 if (suggestedSteps < 1) suggestedSteps = 1;
1830 contMaxTmp = suggestedSteps;
1832 double stepSizeEst = 1.0/(
static_cast<double>(contMaxTmp));
1833 double currentAlpha = 0.0;
1834 double previousAlpha = 0.0;
1835 int stepsLeft = contMaxTmp;
1844 currentAlpha = stepSizeEst;
1849 bool continuationLoopFinished =
false;
1851 int numTotalFailures = 0;
1853 while (!continuationLoopFinished)
1855 bool stepFinished =
false;
1856 int numFailures = 0;
1858 while(!stepFinished)
1861 stepsLeft =
static_cast<int>((1.0-currentAlpha)/stepSizeEst) + 1;
1863 if (VERBOSE_NONLINEAR)
1864 Xyce::dout() << std::endl <<
"Continuation Step: " <<
contStep_
1865 <<
" Estimated Remaining Steps: " << stepsLeft
1867 <<
"current alpha = " << currentAlpha
1868 <<
" prev. alpha = " << previousAlpha
1869 <<
" step = " << stepSizeEst
1874 std::string tmp =
"Continuation step estimate broken. Exiting\n";
1875 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::USR_FATAL_0, tmp);
1879 (*savedNextSolPtr_) = (**nextSolVectorPtrPtr_);
1881 std::string paramName =
"pdealpha";
1894 if (DEBUG_NONLINEAR)
1895 Xyce::dout() <<
"Status of inner loop solve: " << statInner << std::endl;
1897 successBool = (statInner > 0);
1901 stepFinished =
true;
1903 if (numFailures <= 0)
1909 if (numFailures < 0) numFailures = 0;
1911 previousAlpha = currentAlpha;
1912 currentAlpha += stepSizeEst;
1914 if (currentAlpha > 1.0)
1917 stepSizeEst = currentAlpha - previousAlpha;
1925 (**nextSolVectorPtrPtr_) = (*savedNextSolPtr_);
1930 currentAlpha = previousAlpha + stepSizeEst;
1940 continuationLoopFinished = (previousAlpha >= 1.0);
1944 if (VERBOSE_NONLINEAR)
1945 Xyce::dout() <<
"current alpha = " << currentAlpha
1946 <<
" previous alpha = " << previousAlpha
1949 <<
"Total number of failures = " << numTotalFailures << std::endl
1950 <<
"Number of actual steps = " <<
contStep_-1
1984 Xyce::dout() <<
"suggested steps are: " << suggestedSteps << std::endl;
1986 Util::ParamList::const_iterator it_tpL;
1991 ExtendedString tmpTag = it_tpL->tag ();
1994 Xyce::dout() <<
"tmpTag = " << tmpTag << std::endl;
1996 if (tmpTag ==
"CONTINUATION")
1998 if (suggestedSteps <= 1)
2000 Xyce::dout() <<
"Setting the solver type to 0" << std::endl;
2043 if (VERBOSE_NONLINEAR)
2044 Xyce::dout() << std::endl
2045 << Xyce::section_divider << std::endl
2046 <<
"TwoLevelNewton::enableSensitivity " << std::endl;
2048 bool bsuccess =
true;
2049 bool tmpBool =
true;
2055 if (VERBOSE_NONLINEAR) {
2057 double maxNormRHS_=0, twoNormRHS_ = 0.0;
2060 Xyce::dout().width(21); Xyce::dout().precision(13); Xyce::dout().setf(std::ios::scientific);
2061 Xyce::dout() << std::endl;
2062 Xyce::dout() <<
"Max. norm of full Newton RHS: " << maxNormRHS_ << std::endl;
2063 Xyce::dout() <<
" 2-norm of full Newton RHS: " << twoNormRHS_ << std::endl;
2064 Xyce::dout() << Xyce::section_divider << std::endl;
2067 if (DEBUG_NONLINEAR)
2070 static int callsSens = 0;
2071 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
2072 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
2074 sprintf(filename1,
"matrixTmp%d.txt",callsSens);
2075 Linear::Matrix *A =
lasSysPtr_->getJacobianMatrix();
2076 A->writeToFile(filename1);
2079 Linear::Vector *b =
lasSysPtr_->getRHSVector();
2080 sprintf(filename2,
"rhsTmp%d.txt", callsSens);
2084 #ifndef Xyce_PARALLEL_MPI
2085 fp1 = fopen(filename2,
"w");
2087 for (i=0;i<size;++i)
2089 double output = b->getElementByGlobalIndex(i);
2090 fprintf(fp1,
"%25.18e\n",output);
2095 Linear::Vector *x = (*nextSolVectorPtrPtr_);
2096 sprintf(filename2,
"solTmp%d.txt", callsSens);
2098 #ifndef Xyce_PARALLEL_MPI
2099 fp1 = fopen(filename2,
"w");
2101 for (i=0;i<size;++i)
2103 double output = x->getElementByGlobalIndex(i);
2104 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()
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 registerNonlinearEquationLoader(Loader::NonlinearEquationLoader *ptr)
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_
virtual bool outputPlotFiles() const
bool totalSolveFailFatal_
bool setTwoLevelLocaOptions(const Util::OptionBlock &OB)
bool setLinsolOptions(const Util::OptionBlock &OB)
virtual double getMaxNormF() const =0
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()
TimeIntg::DataStore * dsPtr_
bool registerAnalysisManager(Analysis::AnalysisManager *analysis_manager)
Util::OptionBlock innerSolverOptions_
bool setHBOptions(const Util::OptionBlock &OB)
TwoLevelNewtonMode getCouplingMode()
virtual bool initializeAll()
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_
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 registerTIADataStore(TimeIntg::DataStore *ptr)
bool continuationCalledBefore_
int getParameterNumber() const
Linear::Vector * savedNextSolPtr_
Util::OptionBlock outerLocaOptions_
int getContinuationStep() const
Loader::NonlinearEquationLoader * nonlinearEquationLoader_
virtual double getTotalJacobianLoadTime()
virtual int getNumLinearSolves()
virtual bool registerTIADataStore(TimeIntg::DataStore *ptr)
virtual bool registerLinearSystem(Linear::System *ptr)
virtual bool setLinsolOptions(const Util::OptionBlock &OB)
DCOPType getDCOPSolve() const
double decreaseContScalar_
Linear::Vector * NewtonVectorPtr_
NonLinearSolver * nlsPassingPtr_
virtual int takeOneSolveStep()
AnalysisMode externalAnalysisMode
int algorithm0_(bool nl_poisson_dcop)
Linear::Vector * savedRHSPtr_
int numJacobianFactorizations_
virtual bool registerParallelMgr(N_PDS_Manager *ptr)
double totalLinearSolveTime_
virtual bool registerAnalysisManager(Analysis::AnalysisManager *tmp_anaIntPtr)
NonLinearSolver * nlsInnerPtr_
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()
bool setNLPOptions(const Util::OptionBlock &OB)
bool registerOutputMgr(IO::OutputMgr *outPtr)
void printStepInfo_(int step, int success, TwoLevelNewtonMode solveType)
virtual bool setOptions(const Util::OptionBlock &OB)=0
virtual int getNumIterations() const =0
virtual bool registerNonlinearEquationLoader(Loader::NonlinearEquationLoader *ptr)
virtual int getNumResidualLoads()
bool registerParallelMgr(N_PDS_Manager *ptr)
virtual double getTotalJacobianLoadTime()
std::vector< double > paramFinalVal
bool setupTranParamsFlag_
virtual bool setLocaOptions(const Util::OptionBlock &OB)