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 petraOptionBlockPtr_(0),
121 nonlinearParameterManager_(0),
124 initialConditionsManager_(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);
454 tlnPtr_ = tmp_tlnPtr;
455 return (tlnPtr_ != 0);
470 nonlinearParameterManager_ = ptr;
471 return (nonlinearParameterManager_ != 0);
505 bool bsuccess =
true;
518 bsuccess = bsuccess && (rhsVectorPtr_ != 0);
522 bsuccess = bsuccess && (currSolVectorPtrPtr_ != 0);
526 bsuccess = bsuccess && (nextSolVectorPtrPtr_ != 0);
530 bsuccess = bsuccess && (jacobianMatrixPtr_ != 0);
532 Linear::Builder & bld_ =
lasSysPtr_->builder();
540 bsuccess = bsuccess && (NewtonVectorPtr_ != 0);
544 bsuccess = bsuccess && (solWtVectorPtr_ != 0);
552 Teuchos::RCP<Linear::Vector> NewtonVectorRCPtr = Teuchos::rcp(NewtonVectorPtr_,
false);
553 Teuchos::RCP<Linear::Vector> rhsVectorRCPtr = Teuchos::rcp(rhsVectorPtr_,
false);
557 Teuchos::RCP<Linear::Matrix> jacobianMatrixRCPtr = Teuchos::rcp(jacobianMatrixPtr_,
false);
567 Teuchos::RCP<NonLinearSolver> NonlinearSolverRCPtr = Teuchos::rcp(
this,
false);
568 Teuchos::RCP<MatrixFreeEpetraOperator>
570 NonlinearSolverRCPtr,
573 bld_.getSolutionMap()
576 Teuchos::RCP<Epetra_Operator> epetraOperator = Teuchos::rcp_dynamic_cast<Epetra_Operator>(matFreeOp,
true);
591 Teuchos::RCP<Linear::Preconditioner> precond =
lasPrecPtr_->create( Teuchos::rcp(
lasSysPtr_,
false ) );
596 Xyce::dout() <<
"size of solution vector: " <<
lasSysPtr_->getGlobalSolutionSize() << std::endl
597 <<
"size of state vector: " <<
lasSysPtr_->getGlobalStateSize() << std::endl
598 <<
"End of NonLinearSolver::initializeAll\n";
616 Linear::Matrix & jacobian,
617 Linear::Vector & rhs)
625 if (!
debugTimeFlag_ || !isActive(Diag::NONLINEAR_DUMP_MASK))
return;
627 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
628 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
630 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
632 sprintf(filename1,
"matrix_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
634 if (isActive(Diag::NONLINEAR_DUMP_STEP))
638 if (isActive(Diag::NONLINEAR_DUMP))
640 sprintf(filename1,
"matrix_%03d.txt", newtStep);
643 jacobian.writeToFile(filename1,
false,
getMMFormat () );
645 if (screenOutput == 1)
647 Xyce::dout() <<
"\n\t***** Jacobian matrix:" << std::endl;
648 jacobian.printPetraObject(Xyce::dout());
651 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
653 sprintf(filename2,
"rhs_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
655 if (isActive(Diag::NONLINEAR_DUMP_STEP))
661 sprintf(filename2,
"rhs_%03d.txt", newtStep);
664 if (screenOutput == 1)
666 Xyce::dout() <<
"\n\t***** RHS vector:" << std::endl;
668 rhs.printPetraObject(Xyce::dout());
671 rhs.writeToFile(filename2);
696 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
697 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
698 char filename3[256];
for (
int ich = 0; ich < 256; ++ich) filename3[ich] = 0;
700 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
702 sprintf(filename1,
"jdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
703 sprintf(filename2,
"fdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
704 sprintf(filename3,
"qdxVL_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
706 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
714 sprintf(filename1,
"jdxVL_%03d.txt", newtStep);
715 sprintf(filename2,
"fdxVL_%03d.txt", newtStep);
716 sprintf(filename3,
"qdxVL_%03d.txt", newtStep);
719 bool Transpose =
false;
733 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
735 sprintf(filename1,
"jtest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
736 sprintf(filename2,
"ftest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
737 sprintf(filename3,
"qtest_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, newtStep);
739 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
747 sprintf(filename1,
"jtest_%03d.txt", newtStep);
748 sprintf(filename2,
"ftest_%03d.txt", newtStep);
749 sprintf(filename3,
"qtest_%03d.txt", newtStep);
774 char filename1[256];
for (
int ich = 0; ich < 256; ++ich) filename1[ich] = 0;
775 char filename2[256];
for (
int ich = 0; ich < 256; ++ich) filename2[ich] = 0;
777 char filename4[256];
for (
int ich = 0; ich < 256; ++ich) filename4[ich] = 0;
778 char filename6[256];
for (
int ich = 0; ich < 256; ++ich) filename6[ich] = 0;
779 char filename7[256];
for (
int ich = 0; ich < 256; ++ich) filename7[ich] = 0;
780 char filename8[256];
for (
int ich = 0; ich < 256; ++ich) filename8[ich] = 0;
781 char filename9[256];
for (
int ich = 0; ich < 256; ++ich) filename9[ich] = 0;
783 Linear::Matrix *dQdx =
lasSysPtr_->getDAEdQdxMatrix ();
784 Linear::Matrix *dFdx =
lasSysPtr_->getDAEdFdxMatrix ();
786 Linear::Vector *daeQ =
lasSysPtr_->getDAEQVector();
787 Linear::Vector *daeF =
lasSysPtr_->getDAEFVector();
789 Linear::Vector *daeFlim =
lasSysPtr_->getdFdxdVpVector ();
790 Linear::Vector *daeQlim =
lasSysPtr_->getdQdxdVpVector ();
794 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
796 sprintf(filename1,
"dQdx_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
797 sprintf(filename2,
"dFdx_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
799 sprintf(filename4,
"daeQ_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
800 sprintf(filename6,
"daeF_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
802 sprintf(filename8,
"daeQlim_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
803 sprintf(filename9,
"daeFlim_%03d_%03d_%03d_%03d.txt" ,
outputStepNumber_, paramNumber, contStep, newtStep);
805 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
818 sprintf(filename1,
"dQdx_%03d.txt" , newtStep);
819 sprintf(filename2,
"dFdx_%03d.txt" , newtStep);
821 sprintf(filename4,
"daeQ_%03d.txt" , newtStep);
822 sprintf(filename6,
"daeF_%03d.txt" , newtStep);
824 sprintf(filename8,
"daeQlim_%03d.txt" , newtStep);
825 sprintf(filename9,
"daeFlim_%03d.txt" , newtStep);
829 dQdx->writeToFile (filename1,
false,
getMMFormat () );
830 dFdx->writeToFile (filename2,
false,
getMMFormat () );
833 daeQ->writeToFile(filename4);
834 daeF->writeToFile(filename6);
835 daeQlim->writeToFile(filename8);
836 daeFlim->writeToFile(filename9);
852 Linear::Vector & dxVector,
853 Linear::Vector & xVector)
861 if (!
debugTimeFlag_ || !isActive(Diag::NONLINEAR_DUMP_MASK))
return;
863 char filename[256];
for (
int ich = 0; ich < 256; ++ich) filename[ich] = 0;
865 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
867 sprintf(filename,
"update_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, nlStep);
869 else if (isActive(Diag::NONLINEAR_DUMP_STEP))
875 sprintf(filename,
"update_%03d.txt", nlStep);
877 dxVector.writeToFile(filename);
879 if (isActive(Diag::NONLINEAR_DUMP_PARAM_NUMBER))
881 sprintf(filename,
"solution_%03d_%03d_%03d_%03d.txt",
outputStepNumber_, paramNumber, contStep, nlStep);
883 if (isActive(Diag::NONLINEAR_DUMP_STEP))
887 if (isActive(Diag::NONLINEAR_DUMP))
889 sprintf(filename,
"solution_%03d.txt", nlStep);
891 xVector.writeToFile(filename);
956 Stats::StatTop _residualStat(
"Residual");
957 Stats::TimeBlock _residualTimer(_residualStat);
982 Stats::StatTop _jacobianStat(
"Jacobian");
983 Stats::TimeBlock _jacobianTimer(_jacobianStat);
1004 Stats::StatTop _jacobianStat(
"Jacobian");
1005 Stats::TimeBlock _jacobianTime(_jacobianStat);
1035 Util::Param param(
"Iterations", 0 );
1043 Util::Param param(
"Refactored", 0 );
1049 if( solutionStatus )
return false;
1073 bool transpose =
true;
1132 int output_step_number,
virtual ~NonLinearSolver()
virtual bool getScreenOutputFlag() const =0
void debugOutput3(Linear::Vector &dxVector, Linear::Vector &xVector)
bool registerLoader(Loader::NonlinearEquationLoader *ptr)
virtual void setMatrixFreeFlag(bool matrixFreeFlag)
virtual bool setTwoLevelLocaOptions(const Util::OptionBlock &OB)
virtual bool setTwoLevelOptions(const Util::OptionBlock &OB)
virtual bool setNodeSetOptions(const Util::OptionBlock &OB)
bool registerTIADataStore(TimeIntg::DataStore *tiaDSPtr)
bool registerParallelMgr(N_PDS_Manager *pdsMgrPtr)
Pure virtual class to augment a linear system.
int numFailedLinearSolves_
unsigned int totalNumLinearIters_
bool applyJacobian(const Linear::Vector &input, Linear::Vector &result)
virtual bool applyJacobian(const Linear::Vector &input, Linear::Vector &result)
virtual int getNumIterations() const =0
virtual double getDebugMaxTime() const =0
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 bool setPetraOptions(const Util::OptionBlock &OB)
NonLinearSolver(const IO::CmdParse &cp)
virtual bool initializeAll()
virtual int getParameterNumber() const =0
Linear::Matrix * jacobianMatrixPtr_
virtual int getDebugLevel() const =0
IO::OutputMgr * outMgrPtr_
bool registerParamMgr(ParamMgr *ptr)
N_PDS_Manager * pdsMgrPtr_
Linear::System * lasSysPtr_
void setDebugFlags(int output_step_number, double time)
virtual bool getMatrixFreeFlag()
Linear::Vector ** nextSolVectorPtrPtr_
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)
Analysis::AnalysisManager * analysisManager_
virtual bool getMMFormat() const =0
double totalResidualLoadTime_
virtual int getContinuationStep() const =0
Linear::Matrix * jacTestMatrixPtr_
AnalysisManager & analysisManager_
void debugOutputJDX_VOLTLIM()
RCP< Linear::Problem > lasProblemRCPtr_
Linear::Vector * solWtVectorPtr_
bool registerLinearSystem(Linear::System *ptr)
Linear::Vector * dxVoltlimVectorPtr_
virtual int getDebugMaxTimeStep() const =0
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)
Linear::Matrix * dQdxTestMatrixPtr_
virtual double getDebugMinTime() const =0
bool registerAnalysisManager(Analysis::AnalysisManager *tmp_anaIntPtr)
double totalLinearSolveTime_
Linear::Vector ** currSolVectorPtrPtr_
virtual int getDebugMinTimeStep() const =0
double totalJacobianLoadTime_
Loader::NonlinearEquationLoader * loaderPtr_
bool registerOutputMgr(IO::OutputMgr *outPtr)
bool registerRHSVector(Linear::Vector *ptr)
virtual bool setDCOPRestartOptions(const Util::OptionBlock &OB)
Util::OptionBlock * petraOptionBlockPtr_
virtual bool setTwoLevelTranOptions(const Util::OptionBlock &OB)
virtual bool setLocaOptions(const Util::OptionBlock &OB)