49 #include <Xyce_config.h>
55 #include <N_UTL_fwd.h>
58 #include <N_ERH_ErrorMgr.h>
59 #include <N_IO_CmdParse.h>
60 #include <N_IO_OutputMgr.h>
61 #include <N_LAS_Builder.h>
62 #include <N_LAS_Matrix.h>
63 #include <N_LAS_PrecondFactory.h>
64 #include <N_LAS_Problem.h>
65 #include <N_LAS_Solver.h>
66 #include <N_LAS_SolverFactory.h>
67 #include <N_LAS_System.h>
68 #include <N_LAS_Vector.h>
75 #include <N_PDS_Manager.h>
76 #include <N_PDS_ParComm.h>
78 #include <N_UTL_Diagnostic.h>
79 #include <N_UTL_FeatureTest.h>
80 #include <N_UTL_OptionBlock.h>
97 nextSolVectorPtrPtr_(0),
98 currSolVectorPtrPtr_(0),
99 tmpSolVectorPtrPtr_(0),
102 jacTestMatrixPtr_(0),
103 dFdxTestMatrixPtr_(0),
104 dQdxTestMatrixPtr_(0),
105 dxVoltlimVectorPtr_(0),
110 jacobianMatrixPtr_(0),
117 linsolOptionBlockPtr_(0),
118 nonlinearEquationLoader_(0),
121 nonlinearParameterManager_(0),
128 numJacobianLoads_(0),
129 numJacobianFactorizations_(0),
131 numFailedLinearSolves_(0),
132 numResidualLoads_(0),
133 totalNumLinearIters_(0),
135 totalLinearSolveTime_(0.0),
136 totalResidualLoadTime_(0.0),
137 totalJacobianLoadTime_(0.0),
139 matrixFreeFlag_(false),
140 outputStepNumber_(0),
141 debugTimeFlag_(true),
232 std::string msg =
"DCOP restart options not supported for this solver. Use nox instead. ";
233 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL_0, msg);
247 std::string msg =
".IC options not supported for this nonlinear solver. Use nox instead. ";
248 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL_0, msg);
262 std::string msg =
".NODESET options not supported for this nonlinear solver. Use nox instead. ";
263 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL_0, msg);
277 std::string msg =
"NonLinearSolver::setLocaOptions - not implemented for this solver. Use nox instead. ";
278 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL_0, msg);
292 std::string msg =
"NonLinearSolver::setTwoLevelLocaOptions - not implemented for this solver. Use nox instead.";
293 N_ERH_ErrorMgr::report(N_ERH_ErrorMgr::DEV_FATAL_0, msg);
453 tlnPtr_ = tmp_tlnPtr;
454 return (tlnPtr_ != 0);
469 nonlinearParameterManager_ = ptr;
470 return (nonlinearParameterManager_ != 0);
504 bool bsuccess =
true;
516 bsuccess = bsuccess && (rhsVectorPtr_ != 0);
520 bsuccess = bsuccess && (currSolVectorPtrPtr_ != 0);
524 bsuccess = bsuccess && (nextSolVectorPtrPtr_ != 0);
528 bsuccess = bsuccess && (jacobianMatrixPtr_ != 0);
530 Linear::Builder & bld_ =
lasSysPtr_->builder();
538 bsuccess = bsuccess && (NewtonVectorPtr_ != 0);
542 bsuccess = bsuccess && (solWtVectorPtr_ != 0);
550 Teuchos::RCP<Linear::Vector> NewtonVectorRCPtr = Teuchos::rcp(NewtonVectorPtr_,
false);
551 Teuchos::RCP<Linear::Vector> rhsVectorRCPtr = Teuchos::rcp(rhsVectorPtr_,
false);
555 Teuchos::RCP<Linear::Matrix> jacobianMatrixRCPtr = Teuchos::rcp(jacobianMatrixPtr_,
false);
565 Teuchos::RCP<NonLinearSolver> NonlinearSolverRCPtr = Teuchos::rcp(
this,
false);
566 Teuchos::RCP<MatrixFreeEpetraOperator>
568 NonlinearSolverRCPtr,
571 bld_.getSolutionMap()
574 Teuchos::RCP<Epetra_Operator> epetraOperator = Teuchos::rcp_dynamic_cast<Epetra_Operator>(matFreeOp,
true);
589 Teuchos::RCP<Linear::Preconditioner> precond =
lasPrecPtr_->create( Teuchos::rcp(
lasSysPtr_,
false ) );
594 Xyce::dout() <<
"size of solution vector: " <<
lasSysPtr_->getGlobalSolutionSize() << std::endl
595 <<
"size of state vector: " <<
lasSysPtr_->getGlobalStateSize() << std::endl
596 <<
"End of NonLinearSolver::initializeAll\n";
614 Linear::Matrix & jacobian,
615 Linear::Vector & rhs)
623 if (!
debugTimeFlag_ || !isActive(Diag::NONLINEAR_DUMP_MASK))
return;
625 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
626 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
628 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
630 sprintf(filename1,
"matrix_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
632 if (isActive(Diag::NONLINEAR_DUMP_STEP))
636 if (isActive(Diag::NONLINEAR_DUMP))
638 sprintf(filename1,
"matrix_%03d.txt", newtStep);
641 jacobian.writeToFile(filename1,
false,
getMMFormat () );
643 if (screenOutput == 1)
645 Xyce::dout() <<
"\n\t***** Jacobian matrix:" << std::endl;
646 jacobian.printPetraObject(Xyce::dout());
649 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
651 sprintf(filename2,
"rhs_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
653 if (isActive(Diag::NONLINEAR_DUMP_STEP))
659 sprintf(filename2,
"rhs_%03d.txt", newtStep);
662 if (screenOutput == 1)
664 Xyce::dout() <<
"\n\t***** RHS vector:" << std::endl;
666 rhs.printPetraObject(Xyce::dout());
669 rhs.writeToFile(filename2);
694 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
695 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
696 char filename3[256];
for (
int ich = 0; ich < 256; ++ich) filename3[ich] = 0;
698 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
700 sprintf(filename1,
"jdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
701 sprintf(filename2,
"fdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
702 sprintf(filename3,
"qdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
704 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
712 sprintf(filename1,
"jdxVL_%03d.txt", newtStep);
713 sprintf(filename2,
"fdxVL_%03d.txt", newtStep);
714 sprintf(filename3,
"qdxVL_%03d.txt", newtStep);
717 bool Transpose =
false;
731 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
733 sprintf(filename1,
"jtest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
734 sprintf(filename2,
"ftest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
735 sprintf(filename3,
"qtest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
737 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
745 sprintf(filename1,
"jtest_%03d.txt", newtStep);
746 sprintf(filename2,
"ftest_%03d.txt", newtStep);
747 sprintf(filename3,
"qtest_%03d.txt", newtStep);
772 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
773 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
775 char filename4[256];
for (
int ich = 0; ich < 256; ++ich) filename4[ich] = 0;
776 char filename6[256];
for (
int ich = 0; ich < 256; ++ich) filename6[ich] = 0;
777 char filename7[256];
for (
int ich = 0; ich < 256; ++ich) filename7[ich] = 0;
778 char filename8[256];
for (
int ich = 0; ich < 256; ++ich) filename8[ich] = 0;
779 char filename9[256];
for (
int ich = 0; ich < 256; ++ich) filename9[ich] = 0;
781 Linear::Matrix *dQdx =
lasSysPtr_->getDAEdQdxMatrix ();
782 Linear::Matrix *dFdx =
lasSysPtr_->getDAEdFdxMatrix ();
784 Linear::Vector *daeQ =
lasSysPtr_->getDAEQVector();
785 Linear::Vector *daeF =
lasSysPtr_->getDAEFVector();
787 Linear::Vector *daeFlim =
lasSysPtr_->getdFdxdVpVector ();
788 Linear::Vector *daeQlim =
lasSysPtr_->getdQdxdVpVector ();
792 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
794 sprintf(filename1,
"dQdx_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
795 sprintf(filename2,
"dFdx_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
797 sprintf(filename4,
"daeQ_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
798 sprintf(filename6,
"daeF_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
800 sprintf(filename8,
"daeQlim_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
801 sprintf(filename9,
"daeFlim_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
803 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
816 sprintf(filename1,
"dQdx_%03d.txt" , newtStep);
817 sprintf(filename2,
"dFdx_%03d.txt" , newtStep);
819 sprintf(filename4,
"daeQ_%03d.txt" , newtStep);
820 sprintf(filename6,
"daeF_%03d.txt" , newtStep);
822 sprintf(filename8,
"daeQlim_%03d.txt" , newtStep);
823 sprintf(filename9,
"daeFlim_%03d.txt" , newtStep);
827 dQdx->writeToFile (filename1,
false,
getMMFormat () );
828 dFdx->writeToFile (filename2,
false,
getMMFormat () );
831 daeQ->writeToFile(filename4);
832 daeF->writeToFile(filename6);
833 daeQlim->writeToFile(filename8);
834 daeFlim->writeToFile(filename9);
850 Linear::Vector & dxVector,
851 Linear::Vector & xVector)
859 if (!
debugTimeFlag_ || !isActive(Diag::NONLINEAR_DUMP_MASK))
return;
861 char filename[256];
for (
int ich = 0; ich < 256; ++ich) filename[ich] = 0;
863 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
865 sprintf(filename,
"update_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, nlStep);
867 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
873 sprintf(filename,
"update_%03d.txt", nlStep);
875 dxVector.writeToFile(filename);
877 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
879 sprintf(filename,
"solution_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, nlStep);
881 if (isActive(Diag::NONLINEAR_DUMP_STEP))
885 if (isActive(Diag::NONLINEAR_DUMP))
887 sprintf(filename,
"solution_%03d.txt", nlStep);
889 xVector.writeToFile(filename);
954 Stats::StatTop _residualStat(
"Residual");
955 Stats::TimeBlock _residualTimer(_residualStat);
980 Stats::StatTop _jacobianStat(
"Jacobian");
981 Stats::TimeBlock _jacobianTimer(_jacobianStat);
1002 Stats::StatTop _jacobianStat(
"Apply Jacobian");
1003 Stats::TimeBlock _jacobianTime(_jacobianStat);
1033 Util::Param param(
"Iterations", 0 );
1041 Util::Param param(
"Refactored", 0 );
1047 if( solutionStatus )
return false;
1071 bool transpose =
true;
1104 int output_step_number,
virtual ~NonLinearSolver()
void debugOutput3(Linear::Vector &dxVector, Linear::Vector &xVector)
virtual bool setTwoLevelLocaOptions(const Util::OptionBlock &OB)
virtual int getContinuationStep() const =0
virtual bool setTwoLevelOptions(const Util::OptionBlock &OB)
IO::InitialConditionsManager & initialConditionsManager_
virtual bool setNodeSetOptions(const Util::OptionBlock &OB)
Pure virtual class to augment a linear system.
int numFailedLinearSolves_
unsigned int totalNumLinearIters_
Util::OptionBlock * linsolOptionBlockPtr_
bool applyJacobian(const Linear::Vector &input, Linear::Vector &result)
virtual bool applyJacobian(const Linear::Vector &input, Linear::Vector &result)
std::string netlistFilename_
Linear::Matrix * dFdxTestMatrixPtr_
virtual bool setICOptions(const Util::OptionBlock &OB)
Linear::Vector ** tmpSolVectorPtrPtr_
virtual void resetCountersAndTimers_()
Linear::Vector * rhsVectorPtr_
TimeIntg::DataStore * dsPtr_
Linear::Vector * gradVectorPtr_
virtual int getDebugLevel() const =0
NonLinearSolver(const IO::CmdParse &cp)
virtual bool initializeAll()
Linear::Matrix * jacobianMatrixPtr_
IO::OutputMgr * outMgrPtr_
bool registerParamMgr(ParamMgr *ptr)
N_PDS_Manager * pdsMgrPtr_
Linear::System * lasSysPtr_
void setDebugFlags(int output_step_number, double time)
Linear::Vector ** nextSolVectorPtrPtr_
virtual bool getScreenOutputFlag() const =0
void debugOutput1(Linear::Matrix &jacobian, Linear::Vector &rhs)
bool registerTwoLevelSolver(TwoLevelNewton *ptr)
Linear::Solver * lasSolverPtr_
const Linear::PrecondFactory * lasPrecPtr_
bool registerInitialConditionsManager(IO::InitialConditionsManager *outPtr)
const IO::CmdParse & commandLine_
Linear::Vector * fdxVLVectorPtr_
Linear::Vector * jdxVLVectorPtr_
virtual TwoLevelNewtonMode getCouplingMode()
bool registerPrecondFactory(const Linear::PrecondFactory *ptr)
virtual double getDebugMinTime() const =0
virtual int getDebugMinTimeStep() const =0
Analysis::AnalysisManager * analysisManager_
double totalResidualLoadTime_
Linear::Matrix * jacTestMatrixPtr_
AnalysisManager & analysisManager_
void debugOutputJDX_VOLTLIM()
RCP< Linear::Problem > lasProblemRCPtr_
Loader::NonlinearEquationLoader * nonlinearEquationLoader_
virtual bool registerTIADataStore(TimeIntg::DataStore *ptr)
virtual bool getMMFormat() const =0
Linear::Vector * solWtVectorPtr_
virtual int getDebugMaxTimeStep() const =0
virtual bool registerLinearSystem(Linear::System *ptr)
Linear::Vector * dxVoltlimVectorPtr_
virtual bool setLinsolOptions(const Util::OptionBlock &OB)
int numJacobianFactorizations_
Linear::Vector * NewtonVectorPtr_
IO::InitialConditionsManager * initialConditionsManager_
Linear::Vector * qdxVLVectorPtr_
RCP< MatrixFreeEpetraOperator > matrixFreeEpetraOperator(RCP< NonLinearSolver > nonlinearSolver, RCP< Linear::Vector > solVector, RCP< Linear::Vector > rhsVector, RCP< const Epetra_Map > solutionMap)
virtual bool registerParallelMgr(N_PDS_Manager *ptr)
Linear::Matrix * dQdxTestMatrixPtr_
virtual bool registerAnalysisManager(Analysis::AnalysisManager *tmp_anaIntPtr)
double totalLinearSolveTime_
virtual int getParameterNumber() const =0
Linear::Vector ** currSolVectorPtrPtr_
double totalJacobianLoadTime_
virtual double getDebugMaxTime() const =0
bool registerOutputMgr(IO::OutputMgr *outPtr)
bool registerRHSVector(Linear::Vector *ptr)
virtual bool setDCOPRestartOptions(const Util::OptionBlock &OB)
virtual int getNumIterations() const =0
virtual bool registerNonlinearEquationLoader(Loader::NonlinearEquationLoader *ptr)
virtual bool setTwoLevelTranOptions(const Util::OptionBlock &OB)
virtual bool setLocaOptions(const Util::OptionBlock &OB)