DerivativeSolver Class Reference

#include <stepsol.h>

Inheritance diagram for DerivativeSolver:

Collaboration diagram for DerivativeSolver:

Public Member Functions
	DerivativeSolver (const doublereal Tl, const doublereal dSolTl, const doublereal dC, const integer iMaxIt, const bool bmod_res_test, const integer iMaxIterCoef, const doublereal dFactorCoef)
	~DerivativeSolver (void)
doublereal	Advance (Solver *pS, const doublereal TStep, const doublereal, const StepChange, std::deque< MyVectorHandler * > &qX, std::deque< MyVectorHandler * > &qXPrime, MyVectorHandler *const pX, MyVectorHandler *const pXPrime, integer &EffIter, doublereal &Err, doublereal &SolErr)
void	Residual (VectorHandler *pRes) const
void	Jacobian (MatrixHandler *pJac) const
void	Update (const VectorHandler *pSol) const
virtual doublereal	TestScale (const NonlinearSolverTest *pTest, doublereal &dAlgebraicEqu) const
Public Member Functions inherited from ImplicitStepIntegrator
	ImplicitStepIntegrator (const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const integer sts, const bool bmod_res_test)
virtual	~ImplicitStepIntegrator (void)
virtual void	EvalProd (doublereal Tau, const VectorHandler &f0, const VectorHandler &w, VectorHandler &z) const
Public Member Functions inherited from StepIntegrator
	StepIntegrator (const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const integer sts)
virtual	~StepIntegrator (void)
void	SetDataManager (DataManager *pDatMan)
virtual integer	GetIntegratorNumPreviousStates (void) const
virtual integer	GetIntegratorNumUnknownStates (void) const
virtual integer	GetIntegratorMaxIters (void) const
virtual doublereal	GetIntegratorDTol (void) const
virtual doublereal	GetIntegratorDSolTol (void) const
virtual void	OutputTypes (const bool fpred)
virtual void	SetDriveHandler (const DriveHandler *pDH)
Public Member Functions inherited from NonlinearProblem
virtual	~NonlinearProblem (void)

Protected Member Functions
void	UpdateDof (const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol=0) const
Protected Member Functions inherited from StepIntegrator
template<class T >
void	UpdateLoop (const T *const t, void(T::*pUpd)(const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol) const, const VectorHandler *const pSol=0) const

Private Attributes
doublereal	dCoef
const int	iMaxIterCoef
const doublereal	dFactorCoef

Additional Inherited Members
Public Types inherited from StepIntegrator
enum	{ DIFFERENTIAL = 0, ALGEBRAIC = 1 }
enum	StepChange { NEWSTEP, REPEATSTEP }
Protected Attributes inherited from ImplicitStepIntegrator
VectorHandler *	pXCurr
VectorHandler *	pXPrimeCurr
bool	bModResTest
Protected Attributes inherited from StepIntegrator
DataManager *	pDM
const DataManager::DofVecType *	pDofs
bool	outputPred
integer	MaxIters
doublereal	dTol
doublereal	dSolTol
integer	steps
integer	unkstates

Detailed Description

Definition at line 184 of file stepsol.h.

Constructor & Destructor Documentation

DerivativeSolver::DerivativeSolver	(	const doublereal	Tl,
		const doublereal	dSolTl,
		const doublereal	dC,
		const integer	iMaxIt,
		const bool	bmod_res_test,
		const integer	iMaxIterCoef,
		const doublereal	dFactorCoef
	)

Definition at line 249 of file stepsol.cc.

References NO_OP.

: ImplicitStepIntegrator(iMaxIt, Tl, dSolTl, 1, 1, bmod_res_test),
dCoef(dC),
iMaxIterCoef(iMaxIterCoef),
dFactorCoef(dFactorCoef)
{
        NO_OP;
}

DerivativeSolver::~DerivativeSolver

(

void

)

Definition at line 264 of file stepsol.cc.

References NO_OP.

{
        NO_OP;
}

Member Function Documentation

doublereal DerivativeSolver::Advance ( Solver *  pS, const doublereal  TStep, const doublereal  , const StepChange  , std::deque< MyVectorHandler * > &  qX, std::deque< MyVectorHandler * > &  qXPrime, MyVectorHandler *const  pX, MyVectorHandler *const  pXPrime, integer &  EffIter, doublereal &  Err, doublereal &  SolErr  )

virtual

Implements StepIntegrator.

Definition at line 270 of file stepsol.cc.

References DataManager::AfterConvergence(), DataManager::AfterPredict(), ASSERT, dCoef, dFactorCoef, DataManager::dGetTime(), StepIntegrator::dSolTol, StepIntegrator::dTol, iMaxIterCoef, DataManager::LinkToSolution(), StepIntegrator::MaxIters, StepIntegrator::pDM, Solver::pGetNonlinearSolver(), ImplicitStepIntegrator::pXCurr, ImplicitStepIntegrator::pXPrimeCurr, and NonlinearSolver::Solve().

{
        /* no predizione */
        ASSERT(pDM != NULL);

        /* Make a deep copy of the current state in order to restore it later */
        MyVectorHandler X(*pX);
        MyVectorHandler XPrime(*pXPrime);

        pXCurr = &X;
        pXPrimeCurr = &XPrime;

        try {
                pDM->LinkToSolution(*pXCurr, *pXPrimeCurr);

                bool bConverged = false;
                const doublereal dInitialCoef = dCoef;
                doublereal dCoefBest = dCoef;
                doublereal dResErrMin = std::numeric_limits<doublereal>::max();
                doublereal dSolErrMin = dResErrMin;
                const integer iMaxPowerCoef = iMaxIterCoef > 0 ? 2 * iMaxIterCoef + 1 : 0;

                for (int i = 0; i <= iMaxPowerCoef; ++i) {
                        const bool bLastChance = i == iMaxPowerCoef;

                        try {
                                Err = 0.;
                                pS->pGetNonlinearSolver()->Solve(this,
                                        pS,
                                        MaxIters,
                                        dTol,
                                        EffIter,
                                        Err,
                                        dSolTol,
                                        SolErr);
                                bConverged = true;
                        } catch (NonlinearSolver::NoConvergence) {
                                if (bLastChance) {
                                        throw;
                                }
                        } catch (NonlinearSolver::ErrSimulationDiverged) {
                                if (bLastChance) {
                                        throw;
                                }
                        } catch (LinearSolver::ErrFactor) {
                                if (bLastChance) {
                                        throw;
                                }
                        }

                        if (bConverged) {
                                break;
                        }

                        /* Save smallest residual error and corresponding derivative coefficient. */
                        if (Err < dResErrMin) {
                                dResErrMin = Err;
                                dSolErrMin = SolErr;
                                dCoefBest = dCoef;
                        }

                        /* Restore the state after assembly. */
                        *pXCurr = *pX;
                        *pXPrimeCurr = *pXPrime;

                        pDM->LinkToSolution(*pXCurr, *pXPrimeCurr);

                        /* Reset reference rotation parameters and angular velocities */
                        pDM->AfterPredict();

                        /* Try different values for derivatives coefficient. */
                        if (i < iMaxIterCoef) {
                                dCoef *= dFactorCoef;
                        } else if (i == iMaxIterCoef) {
                                dCoef = dInitialCoef / dFactorCoef;
                        } else if (i < 2 * iMaxIterCoef) {
                                dCoef /= dFactorCoef;
                        } else {
                                /* Convergence could not be achieved with any coefficient.
                                 * Choose those coefficient with smallest residual error 
                                 * and increase the tolerance, so it will converge in any case. */
                                const doublereal dSafetyFactor = 1.01;

                                dCoef = dCoefBest;
                                dTol = dSafetyFactor * dResErrMin;
                                dSolTol = dSafetyFactor * dSolErrMin;
                        }

                        silent_cout("Derivatives(" << i + 1  << '/' << 2 * iMaxIterCoef + 1
                                << ") t=" << pDM->dGetTime()
                                << " coef=" << dCoef / TStep
                                << " tol=" << dTol
                                << std::endl);
                }
                /* if it gets here, it surely converged */
                pDM->AfterConvergence();

                *pX = *pXCurr;
                *pXPrime = *pXPrimeCurr;

                pXCurr = 0;
                pXPrimeCurr = 0;
        } catch (...) {
                /* Clean up pointers to local variables */
                pXCurr = 0;
                pXPrimeCurr = 0;
                throw;
        }

        return Err;
}

Here is the call graph for this function:

void DerivativeSolver::Jacobian ( MatrixHandler *  pJac ) const

virtual

Implements NonlinearProblem.

Definition at line 400 of file stepsol.cc.

References ASSERT, DataManager::AssJac(), dCoef, and StepIntegrator::pDM.

{
        ASSERT(pDM != NULL);
        pDM->AssJac(*pJac, dCoef);
}

Here is the call graph for this function:

void DerivativeSolver::Residual ( VectorHandler *  pRes ) const

virtual

Implements NonlinearProblem.

Definition at line 393 of file stepsol.cc.

References ASSERT, DataManager::AssRes(), dCoef, and StepIntegrator::pDM.

{
        ASSERT(pDM != NULL);
        pDM->AssRes(*pRes, dCoef);
}

Here is the call graph for this function:

doublereal DerivativeSolver::TestScale ( const NonlinearSolverTest *  pTest, doublereal &  dAlgebraicEqu  ) const

virtual

Reimplemented from ImplicitStepIntegrator.

Definition at line 439 of file stepsol.cc.

References dCoef.

{
        dAlgebraicEqu = dCoef;
        return 1.;
}

void DerivativeSolver::Update ( const VectorHandler *  pSol ) const

virtual

Implements NonlinearProblem.

Definition at line 428 of file stepsol.cc.

References ASSERT, DEBUGCOUTFNAME, DataManager::DerivativesUpdate(), StepIntegrator::pDM, UpdateDof(), and StepIntegrator::UpdateLoop().

{
        DEBUGCOUTFNAME("DerivativeSolver::Update");
        ASSERT(pDM != NULL);

        UpdateLoop(this, &DerivativeSolver::UpdateDof, pSol);
        pDM->DerivativesUpdate();
}

Here is the call graph for this function:

void DerivativeSolver::UpdateDof ( const int  DCount, const DofOrder::Order  Order, const VectorHandler *const  pSol = 0  ) const

protected

Definition at line 407 of file stepsol.cc.

References dCoef, DofOrder::DIFFERENTIAL, VectorHandler::IncCoef(), ImplicitStepIntegrator::pXCurr, and ImplicitStepIntegrator::pXPrimeCurr.

Referenced by Update().

{
        doublereal d = pSol->operator()(DCount);
        if (Order == DofOrder::DIFFERENTIAL) {
                pXPrimeCurr->IncCoef(DCount, d);

#if 1 /* FIXME: update state derivatives only */
                pXCurr->IncCoef(DCount, dCoef*d);
#endif

        } else {
                pXCurr->IncCoef(DCount, d);
#if 1 /* FIXME: update state only */
                pXPrimeCurr->IncCoef(DCount, dCoef*d);
#endif
        }
}

Here is the call graph for this function:

Member Data Documentation

doublereal DerivativeSolver::dCoef

private

Definition at line 187 of file stepsol.h.

Referenced by Advance(), Jacobian(), Residual(), TestScale(), and UpdateDof().

const doublereal DerivativeSolver::dFactorCoef

private

Definition at line 189 of file stepsol.h.

Referenced by Advance().

const int DerivativeSolver::iMaxIterCoef

private

Definition at line 188 of file stepsol.h.

Referenced by Advance().

---

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

• stepsol.h
• stepsol.cc