NewtonRaphsonSolver Class Reference

#include <nr.h>

Inheritance diagram for NewtonRaphsonSolver:

Collaboration diagram for NewtonRaphsonSolver:

Public Member Functions
	NewtonRaphsonSolver (const bool bTNR, const bool bKJ, const integer IterBfAss, const NonlinearSolverOptions &options)
	~NewtonRaphsonSolver (void)
void	Solve (const NonlinearProblem *pNLP, Solver *pS, const integer iMaxIter, const doublereal &Tol, integer &iIterCnt, doublereal &dErr, const doublereal &SolTol, doublereal &dSolErr)
Public Member Functions inherited from NonlinearSolver
	NonlinearSolver (const NonlinearSolverOptions &options)
virtual void	SetTest (NonlinearSolverTest *pr, NonlinearSolverTest *ps)
virtual	~NonlinearSolver (void)
virtual bool	MakeResTest (Solver *pS, const NonlinearProblem *pNLP, const VectorHandler &Vec, const doublereal &dTol, doublereal &dTest, doublereal &dTestDiff)
virtual integer	TotalAssembledJacobian (void)
virtual NonlinearSolverTest *	pGetResTest (void)
virtual NonlinearSolverTest *	pGetSolTest (void)
Public Member Functions inherited from SolverDiagnostics
	SolverDiagnostics (unsigned OF=OUTPUT_DEFAULT, DriveCaller *pOM=0)
virtual	~SolverDiagnostics (void)
void	SetNoOutput (void)
void	SetOutputMeter (DriveCaller *pOM)
void	SetOutputDriveHandler (const DriveHandler *pDH)
void	SetOutputFlags (unsigned OF)
void	AddOutputFlags (unsigned OF)
void	DelOutputFlags (unsigned OF)
MatrixHandler::Norm_t	GetCondMatNorm (void) const
bool	outputMeter (void) const
bool	outputIters (void) const
bool	outputRes (void) const
bool	outputSol (void) const
bool	outputJac (void) const
bool	outputStep (void) const
bool	outputBailout (void) const
bool	outputCounter (void) const
bool	outputMatrixConditionNumber (void) const
bool	outputSolverConditionNumber (void) const
bool	outputSolverConditionStat (void) const
bool	outputCPUTime (void) const
bool	outputMsg (void) const

Private Attributes
VectorHandler *	pRes
VectorHandler *	pSol
bool	bTrueNewtonRaphson
integer	IterationBeforeAssembly
bool	bKeepJac
integer	iPerformedIterations
const NonlinearProblem *	pPrevNLP

Additional Inherited Members
Public Types inherited from NonlinearSolver
enum	Type {   UNKNOWN = -1, NEWTONRAPHSON, MATRIXFREE, LINESEARCH,   DEFAULT = NEWTONRAPHSON, LASTSOLVERTYPE }
Protected Types inherited from NonlinearSolver
enum	CPUTimeType { CPU_RESIDUAL, CPU_JACOBIAN, CPU_LINEAR_SOLVER, CPU_LAST_TYPE }
Protected Types inherited from SolverDiagnostics
enum	{   OUTPUT_NONE = 0x0000, OUTPUT_ITERS = 0x0001, OUTPUT_RES = 0x0002, OUTPUT_SOL = 0x0004,   OUTPUT_JAC = 0x0008, OUTPUT_BAILOUT = 0x0010, OUTPUT_MSG = 0x0020, OUTPUT_COUNTER = 0x0040,   OUTPUT_MAT_COND_NUM_1 = 0x0080, OUTPUT_MAT_COND_NUM_INF = 0x0100, OUTPUT_SOLVER_COND_NUM = 0x0200, OUTPUT_SOLVER_COND_STAT = 0x400,   OUTPUT_CPU_TIME = 0x800, OUTPUT_MAT_COND_NUM = OUTPUT_MAT_COND_NUM_1 | OUTPUT_MAT_COND_NUM_INF, OUTPUT_DEFAULT = OUTPUT_MSG, OUTPUT_STEP = (OUTPUT_ITERS | OUTPUT_RES | OUTPUT_SOL | OUTPUT_JAC | OUTPUT_MAT_COND_NUM | OUTPUT_SOLVER_COND_NUM),   OUTPUT_MASK = 0x07FF }
Protected Types inherited from NonlinearSolverOptions
enum	ScaleFlags { SCALE_ALGEBRAIC_EQUATIONS_NO = 0, SCALE_ALGEBRAIC_EQUATIONS_YES = 1 }
Protected Member Functions inherited from NonlinearSolver
virtual bool	MakeSolTest (Solver *pS, const VectorHandler &Vec, const doublereal &dTol, doublereal &dTest)
doublereal	dGetCondMax () const
doublereal	dGetCondMin () const
doublereal	dGetCondAvg () const
doublereal	dGetTimeCPU (CPUTimeType eType) const
void	AddCond (doublereal dCond)
void	AddTimeCPU (doublereal dTime, CPUTimeType eType)
Protected Member Functions inherited from NonlinearSolverOptions
	NonlinearSolverOptions (bool bHonorJacRequest=false, enum ScaleFlags eScaleFlags=SCALE_ALGEBRAIC_EQUATIONS_NO, doublereal dScaleAlgebraic=1.)
Protected Attributes inherited from NonlinearSolver
integer	Size
integer	TotJac
NonlinearSolverTest *	pResTest
NonlinearSolverTest *	pSolTest
Protected Attributes inherited from SolverDiagnostics
unsigned	OutputFlags
DriveCaller *	pOutputMeter
Protected Attributes inherited from NonlinearSolverOptions
bool	bHonorJacRequest
enum NonlinearSolverOptions::ScaleFlags	eScaleFlags
doublereal	dScaleAlgebraic

Detailed Description

Definition at line 46 of file nr.h.

Constructor & Destructor Documentation

NewtonRaphsonSolver::NewtonRaphsonSolver	(	const bool	bTNR,
		const bool	bKJ,
		const integer	IterBfAss,
		const NonlinearSolverOptions &	options
	)

Definition at line 58 of file nr.cc.

References NO_OP.

: NonlinearSolver(options), pRes(NULL),
pSol(NULL),
bTrueNewtonRaphson(bTNR),
IterationBeforeAssembly(IterBfAss),
bKeepJac(bKJ),
iPerformedIterations(0),
pPrevNLP(0)
{
        NO_OP;
}

NewtonRaphsonSolver::~NewtonRaphsonSolver

(

void

)

Definition at line 73 of file nr.cc.

References NO_OP.

{
        NO_OP;
}

Member Function Documentation

void NewtonRaphsonSolver::Solve ( const NonlinearProblem *  pNLP, Solver *  pS, const integer  iMaxIter, const doublereal &  Tol, integer &  iIterCnt, doublereal &  dErr, const doublereal &  SolTol, doublereal &  dSolErr  )

virtual

Implements NonlinearSolver.

Definition at line 79 of file nr.cc.

References NonlinearSolver::AddCond(), NonlinearSolver::AddTimeCPU(), ASSERT, SolutionManager::bGetConditionNumber(), NonlinearSolverOptions::bHonorJacRequest, bKeepJac, bTrueNewtonRaphson, Solver::CheckTimeStepLimit(), MatrixHandler::ConditionNumber(), NonlinearSolver::CPU_JACOBIAN, NonlinearSolver::CPU_LINEAR_SOLVER, NonlinearSolver::CPU_RESIDUAL, NonlinearSolver::dGetCondAvg(), NonlinearSolver::dGetCondMax(), NonlinearSolver::dGetCondMin(), NonlinearSolver::dGetTimeCPU(), SolverDiagnostics::GetCondMatNorm(), VectorHandler::iGetSize(), iPerformedIterations, IterationBeforeAssembly, NonlinearProblem::Jacobian(), NonlinearSolver::MakeResTest(), NonlinearSolver::MakeSolTest(), SolutionManager::MatrInitialize(), SolutionManager::MatrReset(), mbdyn_clock_time(), MBDYN_EXCEPT_ARGS, mbdyn_stop_at_end_of_iteration(), SolverDiagnostics::outputBailout(), SolverDiagnostics::outputCPUTime(), SolverDiagnostics::outputIters(), SolverDiagnostics::outputJac(), SolverDiagnostics::outputMatrixConditionNumber(), SolverDiagnostics::outputRes(), SolverDiagnostics::outputSol(), SolverDiagnostics::outputSolverConditionNumber(), SolverDiagnostics::outputSolverConditionStat(), Solver::pGetSolutionManager(), SolutionManager::pMatHdl(), pPrevNLP, pRes, SolutionManager::pResHdl(), Solver::PrintResidual(), Solver::PrintSolution(), pSol, SolutionManager::pSolHdl(), VectorHandler::Reset(), NonlinearProblem::Residual(), NonlinearSolver::Size, SolutionManager::Solve(), NonlinearSolver::TotJac, and NonlinearProblem::Update().

{
        ASSERT(pS != NULL);
        SolutionManager *pSM = pS->pGetSolutionManager();
        
        iIterCnt = 0;
        if ((!bKeepJac) || (pNLP != pPrevNLP)) {
                iPerformedIterations = 0;
        }
        pPrevNLP = pNLP;
        dSolErr = 0.;

        doublereal dOldErr;
        doublereal dErrFactor = 1.;
        doublereal dErrDiff = 0.;
        bool bJacBuilt = false;
        doublereal dStartTimeCPU, dEndTimeCPU, dJacobianCPU, dResidualCPU = 0., dLinSolveCPU;

        while (true) {
                if (outputCPUTime()) {
                        dStartTimeCPU = mbdyn_clock_time();
                }
                
                pRes = pSM->pResHdl();
                pSol = pSM->pSolHdl();
                Size = pRes->iGetSize();

#ifdef USE_EXTERNAL
                SendExternal();
#endif /* USE_EXTERNAL */

                pRes->Reset();
                bool forceJacobian(false);
                try {
                        pNLP->Residual(pRes);
                }
                catch (SolutionDataManager::ChangedEquationStructure) {
                        if (bHonorJacRequest) {
                                forceJacobian = true;
                        }
                }

                /* FIXME: if Tol == 0., no convergence on residual
                 * is required, so we could simply don't compute
                 * the test; I'm leaving it in place so it appears
                 * in the output (maybe we could conditionally disable 
                 * it?) */

                bool bTest = MakeResTest(pS, pNLP, *pRes, Tol, dErr, dErrDiff);

                if (outputCPUTime()) {
                        dEndTimeCPU = mbdyn_clock_time();
                        dResidualCPU += dEndTimeCPU - dStartTimeCPU;
                        AddTimeCPU(dResidualCPU, CPU_RESIDUAL);
                }

                if (outputRes()) {
                        pS->PrintResidual(*pRes, iIterCnt);
                }

                if (iIterCnt > 0) {
                        dErrFactor *= dErr/dOldErr;
                }
                dOldErr = dErr;

#ifdef USE_MPI
                if (!bParallel || MBDynComm.Get_rank() == 0)
#endif /* USE_MPI */
                {
                        if (outputIters() || outputSolverConditionNumber()) {
                                if (outputIters()) {
                                        silent_cout("\tIteration(" << iIterCnt << ") " << dErr);

                                        if (bJacBuilt) {
                                                silent_cout(" J");
                                        }
                                }

                                if (outputSolverConditionNumber()) {
                                        silent_cout(" cond=");
                                        doublereal dCond;
                                        if (pSM->bGetConditionNumber(dCond)) {
                                                silent_cout(dCond);
                                                if (outputSolverConditionStat()) {
                                                        AddCond(dCond);
                                                        silent_cout(" " << dGetCondMin() << " " << dGetCondMax() << " " << dGetCondAvg());
                                                }
                                        } else {
                                                silent_cout("NA");
                                        }
                                }

                                if (outputCPUTime()) {
                                        silent_cout(" CPU:" << dResidualCPU << "/" << dGetTimeCPU(CPU_RESIDUAL)
                                                << "+" << dJacobianCPU << "/" << dGetTimeCPU(CPU_JACOBIAN)
                                                << "+" << dLinSolveCPU << "/" << dGetTimeCPU(CPU_LINEAR_SOLVER));
                                }

                                silent_cout(std::endl);
                        }
                }
                
                pS->CheckTimeStepLimit(dErr, dErrDiff);

                if (bTest) {
                        return;
                }
                
                if (iIterCnt >= std::abs(iMaxIter)) {
                        if (iMaxIter < 0 && dErrFactor < 1.) {
                                return;
                        }
                        if (outputBailout()) {
                                pS->PrintResidual(*pRes, iIterCnt);
                        }
                        throw NoConvergence(MBDYN_EXCEPT_ARGS);
                }
          
                iIterCnt++;
                bJacBuilt = false;

                if (outputCPUTime()) {
                        dStartTimeCPU = mbdyn_clock_time();
                }

                if (bTrueNewtonRaphson
                        || (iPerformedIterations%IterationBeforeAssembly == 0)
                        || forceJacobian)
                {
                        pSM->MatrReset();
rebuild_matrix:;
                        try {
                                pNLP->Jacobian(pSM->pMatHdl());
                        } catch (MatrixHandler::ErrRebuildMatrix) {
                                silent_cout("NewtonRaphsonSolver: "
                                                "rebuilding matrix..."
                                                << std::endl);

                                /* need to rebuild the matrix... */
                                pSM->MatrInitialize();
                                /* FIXME: could loop forever! */
                                goto rebuild_matrix;

                        } catch (...) {
                                throw;
                        }

                        TotJac++;
                        bJacBuilt = true;
                }

                if (outputCPUTime()) {
                        dEndTimeCPU = mbdyn_clock_time();
                        dJacobianCPU = dEndTimeCPU - dStartTimeCPU;
                        AddTimeCPU(dJacobianCPU, CPU_JACOBIAN);
                }

                iPerformedIterations++;

#ifdef USE_MPI
                if (!bParallel || MBDynComm.Get_rank() == 0)
#endif /* USE_MPI */
                {
                        if (outputJac()) {
                                if (bJacBuilt) {
                                        silent_cout("Jacobian:" << std::endl
                                                        << *(pSM->pMatHdl()));
                                } else {
                                        silent_cout("Jacobian: unchanged" << std::endl);
                                }
                        }

                        if (bJacBuilt && outputMatrixConditionNumber()) {
                                silent_cout("cond=" << pSM->pMatHdl()->ConditionNumber(GetCondMatNorm()) << std::endl);
                        }
                }

                if (outputCPUTime()) {
                        dStartTimeCPU = mbdyn_clock_time();
                }

                pSM->Solve();

                if (outputCPUTime()) {
                        dEndTimeCPU = mbdyn_clock_time();
                        dLinSolveCPU = dEndTimeCPU - dStartTimeCPU;
                        AddTimeCPU(dLinSolveCPU, CPU_LINEAR_SOLVER);
                }

                if (outputSol()) {
                        pS->PrintSolution(*pSol, iIterCnt);
                }               

                if (outputCPUTime()) {
                        dStartTimeCPU = mbdyn_clock_time();
                }

                pNLP->Update(pSol);
                
                bTest = MakeSolTest(pS, *pSol, SolTol, dSolErr);

                if (outputCPUTime()) {
                        dEndTimeCPU = mbdyn_clock_time();
                        dResidualCPU = dEndTimeCPU - dStartTimeCPU;
                }

                if (outputIters()) {
#ifdef USE_MPI
                        if (!bParallel || MBDynComm.Get_rank() == 0)
#endif /* USE_MPI */
                        {
                                silent_cout("\t\tSolErr "
                                        << dSolErr << std::endl);
                        }
                }

                if (bTest) {
                        throw ConvergenceOnSolution(MBDYN_EXCEPT_ARGS);
                }

                // allow to bail out in case of multiple CTRL^C
                if (mbdyn_stop_at_end_of_iteration()) {
                        throw ErrInterrupted(MBDYN_EXCEPT_ARGS);
                }
        }
}

Here is the call graph for this function:

Member Data Documentation

bool NewtonRaphsonSolver::bKeepJac

private

Definition at line 52 of file nr.h.

Referenced by Solve().

bool NewtonRaphsonSolver::bTrueNewtonRaphson

private

Definition at line 50 of file nr.h.

Referenced by Solve().

integer NewtonRaphsonSolver::iPerformedIterations

private

Definition at line 53 of file nr.h.

Referenced by Solve().

integer NewtonRaphsonSolver::IterationBeforeAssembly

private

Definition at line 51 of file nr.h.

Referenced by Solve().

const NonlinearProblem* NewtonRaphsonSolver::pPrevNLP

private

Definition at line 54 of file nr.h.

Referenced by Solve().

VectorHandler* NewtonRaphsonSolver::pRes

private

Definition at line 48 of file nr.h.

Referenced by Solve().

VectorHandler* NewtonRaphsonSolver::pSol

private

Definition at line 49 of file nr.h.

Referenced by Solve().

---

The documentation for this class was generated from the following files:

• nr.h
• nr.cc