research/mbdyn-1.7.3-doxy/stepsol_8h_source.html

 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/base/stepsol.h,v 1.51 2017/10/14 23:58:06 masarati Exp $ */

 /*

  * MBDyn (C) is a multibody analysis code.

  * http://www.mbdyn.org

  *

  * Copyright (C) 1996-2017

  *

  * Pierangelo Masarati  <masarati@aero.polimi.it>

  * Paolo Mantegazza     <mantegazza@aero.polimi.it>

  *

  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano

  * via La Masa, 34 - 20156 Milano, Italy

  * http://www.aero.polimi.it

  *

  * Changing this copyright notice is forbidden.

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation (version 2 of the License).

  *

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  */


  /*

   *

   * Copyright (C) 2003-2017

   * Giuseppe Quaranta   <quaranta@aero.polimi.it>

   *

   * Classe che gestisce l'integrazione di un passo temporale

   *

   * Classe di base virtuale pura: NonlinearProblem

   *

   *     metodi:

   *             - Residual, Jacobian e Update che vengono richiesti

   *               da nonlinear solver

   *

   * Classe derivata: StepIntegrator

   *      contiene:

   *             - un puntatore al data manager

   *             - le flag per il tipo di output da implementare

   *             - il numero di iterazioni

   *             - le tolleranze per la verifica della convergenza

   *

   *     metodi:

   *             - Predict e After Predict

   *

   */


 #ifndef STEPSOL_H

 #define STEPSOL_H


 #include <unistd.h>

 #include <cfloat>

 #include <cmath>

 #include <deque>


 /* per il debugging */

 #include "myassert.h"

 #include "mynewmem.h"

 #include "except.h"

 #include "solman.h"

 #include "dataman.h"

 #include "dofown.h"

 #include "drive.h"

 #include "nonlinpb.h"

 #include "nonlin.h"


 /* Needed for callback declaration; defined in <mbdyn/base/solver.h> */

 class Solver;

 class InverseSolver;


 class StepIntegrator

 {


 public:

         class ErrGeneric: public MBDynErrBase {

         public:

                 ErrGeneric(MBDYN_EXCEPT_ARGS_DECL) : MBDynErrBase(MBDYN_EXCEPT_ARGS_PASSTHRU) {};

         };


         enum { DIFFERENTIAL = 0, ALGEBRAIC = 1 };

         enum StepChange { NEWSTEP, REPEATSTEP };


 protected:

         DataManager* pDM;

         const DataManager::DofVecType *pDofs;   /* Dof array, passed by DM */


         bool outputPred;


         integer MaxIters;

         doublereal dTol, dSolTol;

         integer steps;

         integer unkstates;


         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;

 public:

         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);


         virtual doublereal

         Advance(Solver* pS,

                         const doublereal TStep,

                         const doublereal dAlph,

                         const StepChange StType,

                         std::deque<MyVectorHandler*>& qX,

                         std::deque<MyVectorHandler*>& qXPrime,

                         MyVectorHandler*const pX,

                         MyVectorHandler*const pXPrime,

                         integer& EffIter,

                         doublereal& Err,

                         doublereal& SolErr) = 0;

 };


 class ImplicitStepIntegrator:

         public StepIntegrator,

         public NonlinearProblem

 {

 private:

         /* needed by EvalProd */

         mutable MyVectorHandler XTau;

         mutable MyVectorHandler SavedState;

         mutable MyVectorHandler SavedDerState;

         mutable bool bEvalProdCalledFirstTime;


 protected:

         VectorHandler *pXCurr;

         VectorHandler *pXPrimeCurr;

         bool bModResTest;

 public:

         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;


         /* scale factor for tests */

         virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal& dCoef) const;


 };


 class DerivativeSolver:

         public ImplicitStepIntegrator{

 private:

         doublereal dCoef;

         const int iMaxIterCoef;

         const doublereal dFactorCoef;


 protected:

         void UpdateDof(const int DCount,

                 const DofOrder::Order Order,

                 const VectorHandler* const pSol = 0) const;

 public:

         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 /* dAph */,

                         const StepChange /* StType */,

                         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;


         /* scale factor for tests */

         virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal& dAlgebraicEqu) const;

 };


 /* classe di base per gli integratori di ordine qualsiasi */

 class StepNIntegrator :

         public ImplicitStepIntegrator

 {

 public:

         doublereal db0Differential;

         doublereal db0Algebraic;


 protected:

         void UpdateDof(const int DCount,

                 const DofOrder::Order Order,

                 const VectorHandler* const pSol = 0) const;

 public:

         StepNIntegrator(const integer MaxIt,

                         const doublereal dT,

                         const doublereal dSolutionTol,

                         const integer stp,

                         const bool bmod_res_test);


         virtual ~StepNIntegrator(void);


         virtual void Residual(VectorHandler* pRes) const;


         virtual void Jacobian(MatrixHandler* pJac) const;


         virtual void Update(const VectorHandler* pSol) const;


         virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal& dAlgebraicEqu) const;


 protected:

         virtual void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep) = 0;

 };


 /* classe di base per gli integratori del second'ordine */

 class Step1Integrator :

         public StepNIntegrator

 {

 protected:

         VectorHandler *pXPrev;

         VectorHandler *pXPrimePrev;


 public:

         Step1Integrator(const integer MaxIt,

                         const doublereal dT,

                         const doublereal dSolutionTol,

                         const bool bmod_res_test);


         virtual ~Step1Integrator(void);


         virtual doublereal

         Advance(Solver* pS,

                         const doublereal TStep,

                         const doublereal dAlph,

                         const StepChange StType,

                         std::deque<MyVectorHandler*>& qX,

                         std::deque<MyVectorHandler*>& qXPrime,

                         MyVectorHandler*const pX,

                         MyVectorHandler*const pXPrime,

                         integer& EffIter,

                         doublereal& Err,

                         doublereal& SolErr);


 protected:

         void PredictDof(const int DCount,

                 const DofOrder::Order Order,

                 const VectorHandler* const pSol = 0) const;

         virtual void Predict(void);


         /* Overridden by dedicated inline functions */

         virtual doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const = 0;


         /* Overridden by dedicated inline functions */

         virtual doublereal

         dPredictState(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1,

                    DofOrder::Order o = DofOrder::DIFFERENTIAL) const = 0;


         virtual doublereal

         dPredDer(const doublereal& dXm1,

               const doublereal& dXPm1) const = 0;


         virtual doublereal

         dPredState(const doublereal& dXm1,

                 const doublereal& dXP,

                 const doublereal& dXPm1) const = 0;


         virtual doublereal

         dPredDerAlg(const doublereal& dXm1,

                  const doublereal& dXPm1)  const = 0;


         virtual doublereal

         dPredStateAlg(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1) const = 0;

 };


 class CrankNicolsonIntegrator:

         public Step1Integrator

 {

 public:

         CrankNicolsonIntegrator(const doublereal Tl,

                         const doublereal dSolTl,

                         const integer iMaxIt,

                         const bool bmod_res_test);


         ~CrankNicolsonIntegrator(void);


 protected:

         void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep);


         doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         doublereal

         dPredictState(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1,

                    DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         /* Note: uses linear prediction for derivatives

          * (highest possible order) */

         doublereal

         dPredDer(const doublereal& dXm1,

               const doublereal& dXPm1) const;


         doublereal

         dPredState(const doublereal& dXm1,

                 const doublereal& dXP,

                 const doublereal& dXPm1) const;


         doublereal

         dPredDerAlg(const doublereal& dXm1,

                  const doublereal& dXPm1) const;


         doublereal

         dPredStateAlg(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1) const;

 };


 class ImplicitEulerIntegrator:

         public Step1Integrator

 {

 public:

         ImplicitEulerIntegrator(const doublereal Tl,

                         const doublereal dSolTl,

                         const integer iMaxIt,

                         const bool bmod_res_test);


         ~ImplicitEulerIntegrator(void);


 protected:

         void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep);


         doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         doublereal

         dPredictState(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1,

                    DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         /* Note: uses linear prediction for derivatives

          * (highest possible order) */

         doublereal

         dPredDer(const doublereal& dXm1,

               const doublereal& dXPm1) const;


         doublereal

         dPredState(const doublereal& dXm1,

                 const doublereal& dXP,

                 const doublereal& dXPm1) const;


         doublereal

         dPredDerAlg(const doublereal& dXm1,

                  const doublereal& dXPm1) const;


         doublereal

         dPredStateAlg(const doublereal& dXm1,

                    const doublereal& dXP,

                    const doublereal& dXPm1) const;

 };


 /* classe di base per gli integratori del second'ordine */

 class Step2Integrator :

         public StepNIntegrator

 {

 protected:

         VectorHandler *pXPrev, *pXPrev2;

         VectorHandler *pXPrimePrev, *pXPrimePrev2;


 public:

         Step2Integrator(const integer MaxIt,

                         const doublereal dT,

                         const doublereal dSolutionTol,

                         const bool bmod_res_test);


         virtual ~Step2Integrator(void);


         virtual doublereal

         Advance(Solver* pS,

                         const doublereal TStep,

                         const doublereal dAlph,

                         const StepChange StType,

                         std::deque<MyVectorHandler*>& qX,

                         std::deque<MyVectorHandler*>& qXPrime,

                         MyVectorHandler*const pX,

                         MyVectorHandler*const pXPrime,

                         integer& EffIter,

                         doublereal& Err,

                         doublereal& SolErr);


 protected:

         void PredictDof(const int DCount,

                 const DofOrder::Order Order,

                 const VectorHandler* const pSol = 0) const;

         virtual void Predict(void);


         /* Overridden by dedicated inline functions */

         virtual doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const = 0;


         /* Overridden by dedicated inline functions */

         virtual doublereal

         dPredictState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const = 0;


         virtual doublereal

         dPredDer(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const = 0;


         virtual doublereal

         dPredState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const = 0;

         virtual doublereal

         dPredDerAlg(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2)  const = 0;


         virtual doublereal

         dPredStateAlg(const doublereal& dXm1,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const = 0;


         virtual void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep) = 0;

 };


 /* NostroMetodo - begin */


 class MultistepSolver:

         public Step2Integrator

 {

 protected:

         DriveOwner Rho;

         DriveOwner AlgebraicRho;


         doublereal a[2][2];

         doublereal b[3][2];


         doublereal mp[2];

         doublereal np[2];


 public:

         MultistepSolver(const doublereal Tl,

                         const doublereal dSolTol,

                         const integer iMaxIt,

                         const DriveCaller* pRho,

                         const DriveCaller* pAlgRho,

                         const bool bmod_res_test);


         ~MultistepSolver(void);


 protected:

         void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep);


         void SetDriveHandler(const DriveHandler* pDH);


         doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         doublereal

         dPredictState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         /* Note: uses cubic prediction for derivatives

          * (highest possible order) */

         doublereal

         dPredDer(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredDerAlg(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredStateAlg(const doublereal& dXm1,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;

 };


 /* NostroMetodo - end */


 /* Hope - begin */


 class HopeSolver :

         public Step2Integrator

 {

 protected:

         DriveOwner Rho;

         DriveOwner AlgebraicRho;


         bool bStep;


         doublereal a[2][2];

         doublereal b[2][2];


         doublereal mp[2];

         doublereal np[2];


 public:

         HopeSolver(const doublereal Tl,

                         const doublereal dSolTol,

                         const integer iMaxIt,

                         const DriveCaller* pRho,

                         const DriveCaller* pAlgRho,

                         const bool bmod_res_test);


         ~HopeSolver(void);


 protected:

         void SetCoef(doublereal dT,

                         doublereal dAlpha,

                         enum StepChange NewStep);


         void SetDriveHandler(const DriveHandler* pDH);


         doublereal

         dPredictDerivative(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         doublereal

         dPredictState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2,

                         DofOrder::Order o = DofOrder::DIFFERENTIAL) const;


         /* Note: uses cubic prediction for derivatives

          * (highest possible order) */

         doublereal

         dPredDer(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredState(const doublereal& dXm1,

                         const doublereal& dXm2,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredDerAlg(const doublereal& dXm1,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;


         doublereal

         dPredStateAlg(const doublereal& dXm1,

                         const doublereal& dXP,

                         const doublereal& dXPm1,

                         const doublereal& dXPm2) const;

 };


 /* Hope - end */


 /* InverseDynamics - Begin*/


 class InverseDynamicsStepSolver:

         public StepIntegrator,

         public NonlinearProblem

 {

 private:

         /* needed by EvalProd */

         mutable MyVectorHandler XTau;

         mutable MyVectorHandler SavedState;


         /* FIXME: Need this? */

         mutable MyVectorHandler SavedDerState;

         mutable bool bEvalProdCalledFirstTime;


         InverseDynamics::Order iOrder;

         mutable bool m_bJacobian;


 protected:

         VectorHandler *pXCurr;

         VectorHandler *pXPrimeCurr;

         VectorHandler *pXPrimePrimeCurr;

         VectorHandler *pLambdaCurr;

         bool bModResTest;


 public:

         InverseDynamicsStepSolver(const integer MaxIt,

                         const doublereal dT,

                         const doublereal dSolutionTol,

                         const integer stp,

                         const integer sts,

                         const bool bmod_res_test);


         ~InverseDynamicsStepSolver(void);


         virtual void

         EvalProd(doublereal Tau, const VectorHandler& f0,

                         const VectorHandler& w, VectorHandler& z) const;


         /* scale factor for tests */

         virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal& dCoef) const;


         /* Needed for compatibility with class StepIntegrator */

         virtual doublereal

         Advance(Solver* pS,

                         const doublereal TStep,

                         const doublereal dAlph,

                         const StepChange StType,

                         std::deque<MyVectorHandler*>& qX,

                         std::deque<MyVectorHandler*>& qXPrime,

                         MyVectorHandler*const pX,

                         MyVectorHandler*const pXPrime,

                         integer& EffIter,

                         doublereal& Err,

                         doublereal& SolErr)

         {

                 silent_cerr("InverseDynamicsStepSolver::Advance()");

                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);

         };


         /* Real Advancer */

         virtual doublereal

         Advance(InverseSolver* pS,

                         const doublereal TStep,

                         const StepChange StType,

                         MyVectorHandler*const pX,

                         MyVectorHandler*const pXPrime,

                         MyVectorHandler*const pXPrimePrime,

                         MyVectorHandler*const pLambda,

                         integer& EffIter,

                         doublereal& Err,

                         doublereal& SolErr);


         void Residual(VectorHandler* pRes) const ;


         void Jacobian(MatrixHandler* pJac) const ;


         void Update(const VectorHandler* pSol) const  ;


         void SetOrder(InverseDynamics::Order iOrder);


         InverseDynamics::Order GetOrder(void) const;


         bool bJacobian(void) const;

 };


 /* InverseDynamics - End*/


 #endif /* STEPSOL_H */

DerivativeSolver::dFactorCoef
const doublereal dFactorCoef
Definition: stepsol.h:189

DerivativeSolver::dCoef
doublereal dCoef
Definition: stepsol.h:187

InverseDynamicsStepSolver::bModResTest
bool bModResTest
Definition: stepsol.h:687

CrankNicolsonIntegrator
Definition: stepsol.h:333

HopeSolver::dPredStateAlg
doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1352

Step1Integrator::Step1Integrator
Step1Integrator(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const bool bmod_res_test)
Definition: stepsol.cc:560

HopeSolver::np
doublereal np[2]
Definition: stepsol.h:601

CrankNicolsonIntegrator::SetCoef
void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)
Definition: stepsol.cc:851

HopeSolver::dPredDer
doublereal dPredDer(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1319

except.h

MultistepSolver::dPredStateAlg
doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1161

MultistepSolver::SetCoef
void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)
Definition: stepsol.cc:1018

mynewmem.h

MultistepSolver::dPredDerAlg
doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1153

StepIntegrator::outputPred
bool outputPred
Definition: stepsol.h:96

Step1Integrator::dPredDer
virtual doublereal dPredDer(const doublereal &dXm1, const doublereal &dXPm1) const =0

DerivativeSolver::UpdateDof
void UpdateDof(const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol=0) const
Definition: stepsol.cc:407

DofOrder::Order
Order
Definition: dofown.h:45

DriveHandler
Definition: drive.h:171

CrankNicolsonIntegrator::dPredictState
doublereal dPredictState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:868

StepIntegrator::unkstates
integer unkstates
Definition: stepsol.h:101

InverseSolver
Definition: invsolver.h:67

ImplicitStepIntegrator::EvalProd
virtual void EvalProd(doublereal Tau, const VectorHandler &f0, const VectorHandler &w, VectorHandler &z) const
Definition: stepsol.cc:145

CrankNicolsonIntegrator::dPredDer
doublereal dPredDer(const doublereal &dXm1, const doublereal &dXPm1) const
Definition: stepsol.cc:881

StepNIntegrator::SetCoef
virtual void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)=0

Step2Integrator::dPredDerAlg
virtual doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1, const doublereal &dXPm2) const =0

DerivativeSolver::~DerivativeSolver
~DerivativeSolver(void)
Definition: stepsol.cc:264

StepIntegrator::DIFFERENTIAL
Definition: stepsol.h:89

DerivativeSolver::Jacobian
void Jacobian(MatrixHandler *pJac) const
Definition: stepsol.cc:400

InverseDynamicsStepSolver::bEvalProdCalledFirstTime
bool bEvalProdCalledFirstTime
Definition: stepsol.h:677

nonlinpb.h

ImplicitStepIntegrator::ImplicitStepIntegrator
ImplicitStepIntegrator(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const integer sts, const bool bmod_res_test)
Definition: stepsol.cc:124

MBDYN_EXCEPT_ARGS
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63

StepIntegrator::StepIntegrator
StepIntegrator(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const integer sts)
Definition: stepsol.cc:51

InverseDynamicsStepSolver::pXPrimeCurr
VectorHandler * pXPrimeCurr
Definition: stepsol.h:684

DofOrder::DIFFERENTIAL
Definition: dofown.h:48

InverseDynamicsStepSolver::XTau
MyVectorHandler XTau
Definition: stepsol.h:672

DerivativeSolver::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: stepsol.cc:249

StepIntegrator::steps
integer steps
Definition: stepsol.h:100

InverseDynamicsStepSolver::Jacobian
void Jacobian(MatrixHandler *pJac) const
Definition: stepsol.cc:1698

MBDYN_EXCEPT_ARGS_PASSTHRU
#define MBDYN_EXCEPT_ARGS_PASSTHRU
Definition: except.h:55

ImplicitStepIntegrator::bEvalProdCalledFirstTime
bool bEvalProdCalledFirstTime
Definition: stepsol.h:160

CrankNicolsonIntegrator::dPredState
doublereal dPredState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const
Definition: stepsol.cc:888

NonlinearProblem
Definition: nonlinpb.h:47

f0
static double * f0
Definition: test_strext_socket_lib.c:99

DataManager::DofVecType
std::vector< Dof > DofVecType
Definition: dataman.h:801

StepIntegrator::OutputTypes
virtual void OutputTypes(const bool fpred)
Definition: stepsol.cc:111

Step1Integrator::Predict
virtual void Predict(void)
Definition: stepsol.cc:615

HopeSolver::dPredictState
doublereal dPredictState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:1294

ImplicitEulerIntegrator
Definition: stepsol.h:381

DriveCaller
Definition: drive.h:442

dofown.h

StepIntegrator::NEWSTEP
Definition: stepsol.h:90

StepIntegrator::dSolTol
doublereal dSolTol
Definition: stepsol.h:99

StepIntegrator::Advance
virtual doublereal Advance(Solver *pS, const doublereal TStep, const doublereal dAlph, const StepChange StType, std::deque< MyVectorHandler * > &qX, std::deque< MyVectorHandler * > &qXPrime, MyVectorHandler *const pX, MyVectorHandler *const pXPrime, integer &EffIter, doublereal &Err, doublereal &SolErr)=0

CrankNicolsonIntegrator::dPredDerAlg
doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1) const
Definition: stepsol.cc:896

MatrixHandler
Definition: mh.h:60

Step2Integrator::~Step2Integrator
virtual ~Step2Integrator(void)
Definition: stepsol.cc:705

StepIntegrator::GetIntegratorMaxIters
virtual integer GetIntegratorMaxIters(void) const
Definition: stepsol.cc:93

ImplicitStepIntegrator::TestScale
virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal &dCoef) const
Definition: stepsol.cc:210

MBDYN_EXCEPT_ARGS_DECL
#define MBDYN_EXCEPT_ARGS_DECL
Definition: except.h:43

DerivativeSolver::Advance
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)
Definition: stepsol.cc:270

MultistepSolver::AlgebraicRho
DriveOwner AlgebraicRho
Definition: stepsol.h:516

Step1Integrator::pXPrev
VectorHandler * pXPrev
Definition: stepsol.h:270

Step2Integrator::dPredictState
virtual doublereal dPredictState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const =0

InverseDynamicsStepSolver::SetOrder
void SetOrder(InverseDynamics::Order iOrder)
Definition: stepsol.cc:1510

Step1Integrator::dPredictDerivative
virtual doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const =0

ImplicitEulerIntegrator::dPredictDerivative
doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:938

StepNIntegrator::StepNIntegrator
StepNIntegrator(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const bool bmod_res_test)
Definition: stepsol.cc:446

HopeSolver::AlgebraicRho
DriveOwner AlgebraicRho
Definition: stepsol.h:593

nonlin.h

StepIntegrator::SetDataManager
void SetDataManager(DataManager *pDatMan)
Definition: stepsol.cc:74

StepNIntegrator::TestScale
virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal &dAlgebraicEqu) const
Definition: stepsol.cc:547

Step1Integrator::pXPrimePrev
VectorHandler * pXPrimePrev
Definition: stepsol.h:271

Step2Integrator::Step2Integrator
Step2Integrator(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const bool bmod_res_test)
Definition: stepsol.cc:692

ImplicitStepIntegrator::XTau
MyVectorHandler XTau
Definition: stepsol.h:157

StepIntegrator::ALGEBRAIC
Definition: stepsol.h:89

Step2Integrator::pXPrev2
VectorHandler * pXPrev2
Definition: stepsol.h:434

NonlinearSolverTest
Definition: nonlin.h:74

DataManager
Definition: dataman.h:85

MultistepSolver::Rho
DriveOwner Rho
Definition: stepsol.h:515

CrankNicolsonIntegrator::dPredictDerivative
doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:860

InverseDynamicsStepSolver::bJacobian
bool bJacobian(void) const
Definition: stepsol.cc:1522

InverseDynamicsStepSolver::InverseDynamicsStepSolver
InverseDynamicsStepSolver(const integer MaxIt, const doublereal dT, const doublereal dSolutionTol, const integer stp, const integer sts, const bool bmod_res_test)
Definition: stepsol.cc:1378

DriveOwner
Definition: drive.h:130

MultistepSolver::dPredictDerivative
doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:1102

StepIntegrator::ErrGeneric
Definition: stepsol.h:84

CrankNicolsonIntegrator::CrankNicolsonIntegrator
CrankNicolsonIntegrator(const doublereal Tl, const doublereal dSolTl, const integer iMaxIt, const bool bmod_res_test)
Definition: stepsol.cc:836

Step2Integrator::dPredState
virtual doublereal dPredState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const =0

Step2Integrator::dPredictDerivative
virtual doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const =0

InverseDynamicsStepSolver::iOrder
InverseDynamics::Order iOrder
Definition: stepsol.h:679

HopeSolver::a
doublereal a[2][2]
Definition: stepsol.h:597

DerivativeSolver::Residual
void Residual(VectorHandler *pRes) const
Definition: stepsol.cc:393

MultistepSolver::mp
doublereal mp[2]
Definition: stepsol.h:521

Step1Integrator::dPredStateAlg
virtual doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const =0

InverseDynamicsStepSolver::GetOrder
InverseDynamics::Order GetOrder(void) const
Definition: stepsol.cc:1516

StepIntegrator::pDofs
const DataManager::DofVecType * pDofs
Definition: stepsol.h:94

HopeSolver::b
doublereal b[2][2]
Definition: stepsol.h:598

MyVectorHandler
Definition: vh.h:149

StepIntegrator::StepChange
StepChange
Definition: stepsol.h:90

MultistepSolver::dPredState
doublereal dPredState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1142

Step1Integrator
Definition: stepsol.h:266

CrankNicolsonIntegrator::dPredStateAlg
doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const
Definition: stepsol.cc:903

HopeSolver::~HopeSolver
~HopeSolver(void)
Definition: stepsol.cc:1188

Step1Integrator::dPredState
virtual doublereal dPredState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const =0

ImplicitEulerIntegrator::dPredState
doublereal dPredState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const
Definition: stepsol.cc:966

Step1Integrator::Advance
virtual doublereal Advance(Solver *pS, const doublereal TStep, const doublereal dAlph, const StepChange StType, std::deque< MyVectorHandler * > &qX, std::deque< MyVectorHandler * > &qXPrime, MyVectorHandler *const pX, MyVectorHandler *const pXPrime, integer &EffIter, doublereal &Err, doublereal &SolErr)
Definition: stepsol.cc:623

HopeSolver::dPredDerAlg
doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1344

StepIntegrator::REPEATSTEP
Definition: stepsol.h:90

StepIntegrator::pDM
DataManager * pDM
Definition: stepsol.h:93

HopeSolver::HopeSolver
HopeSolver(const doublereal Tl, const doublereal dSolTol, const integer iMaxIt, const DriveCaller *pRho, const DriveCaller *pAlgRho, const bool bmod_res_test)
Definition: stepsol.cc:1175

DerivativeSolver::Update
void Update(const VectorHandler *pSol) const
Definition: stepsol.cc:428

ImplicitStepIntegrator::SavedState
MyVectorHandler SavedState
Definition: stepsol.h:158

InverseDynamicsStepSolver::pXPrimePrimeCurr
VectorHandler * pXPrimePrimeCurr
Definition: stepsol.h:685

dataman.h

StepIntegrator::GetIntegratorDTol
virtual doublereal GetIntegratorDTol(void) const
Definition: stepsol.cc:99

ImplicitStepIntegrator::pXPrimeCurr
VectorHandler * pXPrimeCurr
Definition: stepsol.h:164

StepIntegrator::~StepIntegrator
virtual ~StepIntegrator(void)
Definition: stepsol.cc:68

Step2Integrator::Predict
virtual void Predict(void)
Definition: stepsol.cc:757

ImplicitStepIntegrator::pXCurr
VectorHandler * pXCurr
Definition: stepsol.h:163

HopeSolver::bStep
bool bStep
Definition: stepsol.h:595

StepIntegrator::MaxIters
integer MaxIters
Definition: stepsol.h:98

StepNIntegrator::UpdateDof
void UpdateDof(const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol=0) const
Definition: stepsol.cc:516

HopeSolver
Definition: stepsol.h:588

Step2Integrator::PredictDof
void PredictDof(const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol=0) const
Definition: stepsol.cc:714

StepIntegrator
Definition: stepsol.h:80

InverseDynamicsStepSolver::Advance
virtual doublereal Advance(Solver *pS, const doublereal TStep, const doublereal dAlph, const StepChange StType, std::deque< MyVectorHandler * > &qX, std::deque< MyVectorHandler * > &qXPrime, MyVectorHandler *const pX, MyVectorHandler *const pXPrime, integer &EffIter, doublereal &Err, doublereal &SolErr)
Definition: stepsol.h:708

ImplicitStepIntegrator::bModResTest
bool bModResTest
Definition: stepsol.h:165

InverseDynamics::Order
Order
Definition: invdyn.h:36

StepNIntegrator::Jacobian
virtual void Jacobian(MatrixHandler *pJac) const
Definition: stepsol.cc:472

VectorHandler
Definition: vh.h:63

MultistepSolver::SetDriveHandler
void SetDriveHandler(const DriveHandler *pDH)
Definition: stepsol.cc:1011

InverseDynamicsStepSolver::TestScale
virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal &dCoef) const
Definition: stepsol.cc:1471

ImplicitEulerIntegrator::dPredictState
doublereal dPredictState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:946

ImplicitEulerIntegrator::dPredDerAlg
doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1) const
Definition: stepsol.cc:974

StepNIntegrator::~StepNIntegrator
virtual ~StepNIntegrator(void)
Definition: stepsol.cc:458

ImplicitStepIntegrator::SavedDerState
MyVectorHandler SavedDerState
Definition: stepsol.h:159

MultistepSolver
Definition: stepsol.h:511

MultistepSolver::dPredictState
doublereal dPredictState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:1115

HopeSolver::SetCoef
void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)
Definition: stepsol.cc:1201

ImplicitEulerIntegrator::~ImplicitEulerIntegrator
~ImplicitEulerIntegrator(void)
Definition: stepsol.cc:923

MultistepSolver::dPredDer
doublereal dPredDer(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1133

Step1Integrator::dPredictState
virtual doublereal dPredictState(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, DofOrder::Order o=DofOrder::DIFFERENTIAL) const =0

Order
Order
Definition: shapefnc.h:42

StepNIntegrator
Definition: stepsol.h:231

InverseDynamicsStepSolver::EvalProd
virtual void EvalProd(doublereal Tau, const VectorHandler &f0, const VectorHandler &w, VectorHandler &z) const
Definition: stepsol.cc:1406

MultistepSolver::~MultistepSolver
~MultistepSolver(void)
Definition: stepsol.cc:1005

Step2Integrator::dPredStateAlg
virtual doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const =0

InverseDynamicsStepSolver::m_bJacobian
bool m_bJacobian
Definition: stepsol.h:680

StepNIntegrator::db0Differential
doublereal db0Differential
Definition: stepsol.h:235

drive.h

Step2Integrator::SetCoef
virtual void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)=0

InverseDynamicsStepSolver::SavedState
MyVectorHandler SavedState
Definition: stepsol.h:673

Solver
Definition: solver.h:78

MBDynErrBase
Definition: except.h:67

InverseDynamicsStepSolver::Residual
void Residual(VectorHandler *pRes) const
Definition: stepsol.cc:1683

StepIntegrator::SetDriveHandler
virtual void SetDriveHandler(const DriveHandler *pDH)
Definition: stepsol.cc:117

MultistepSolver::MultistepSolver
MultistepSolver(const doublereal Tl, const doublereal dSolTol, const integer iMaxIt, const DriveCaller *pRho, const DriveCaller *pAlgRho, const bool bmod_res_test)
Definition: stepsol.cc:992

InverseDynamicsStepSolver::SavedDerState
MyVectorHandler SavedDerState
Definition: stepsol.h:676

InverseDynamicsStepSolver
Definition: stepsol.h:666

DerivativeSolver::iMaxIterCoef
const int iMaxIterCoef
Definition: stepsol.h:188

Step2Integrator
Definition: stepsol.h:430

ImplicitEulerIntegrator::ImplicitEulerIntegrator
ImplicitEulerIntegrator(const doublereal Tl, const doublereal dSolTl, const integer iMaxIt, const bool bmod_res_test)
Definition: stepsol.cc:914

DerivativeSolver
Definition: stepsol.h:184

Step2Integrator::pXPrimePrev
VectorHandler * pXPrimePrev
Definition: stepsol.h:435

solman.h

InverseDynamicsStepSolver::~InverseDynamicsStepSolver
~InverseDynamicsStepSolver(void)
Definition: stepsol.cc:1400

HopeSolver::dPredState
doublereal dPredState(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXP, const doublereal &dXPm1, const doublereal &dXPm2) const
Definition: stepsol.cc:1328

ImplicitEulerIntegrator::dPredStateAlg
doublereal dPredStateAlg(const doublereal &dXm1, const doublereal &dXP, const doublereal &dXPm1) const
Definition: stepsol.cc:981

InverseDynamicsStepSolver::pXCurr
VectorHandler * pXCurr
Definition: stepsol.h:683

Step2Integrator::Advance
virtual doublereal Advance(Solver *pS, const doublereal TStep, const doublereal dAlph, const StepChange StType, std::deque< MyVectorHandler * > &qX, std::deque< MyVectorHandler * > &qXPrime, MyVectorHandler *const pX, MyVectorHandler *const pXPrime, integer &EffIter, doublereal &Err, doublereal &SolErr)
Definition: stepsol.cc:765

InverseDynamicsStepSolver::Update
void Update(const VectorHandler *pSol) const
Definition: stepsol.cc:1705

StepIntegrator::GetIntegratorNumPreviousStates
virtual integer GetIntegratorNumPreviousStates(void) const
Definition: stepsol.cc:81

ImplicitEulerIntegrator::dPredDer
doublereal dPredDer(const doublereal &dXm1, const doublereal &dXPm1) const
Definition: stepsol.cc:959

StepIntegrator::ErrGeneric::ErrGeneric
ErrGeneric(MBDYN_EXCEPT_ARGS_DECL)
Definition: stepsol.h:86

Step1Integrator::~Step1Integrator
virtual ~Step1Integrator(void)
Definition: stepsol.cc:571

StepNIntegrator::Update
virtual void Update(const VectorHandler *pSol) const
Definition: stepsol.cc:538

StepNIntegrator::db0Algebraic
doublereal db0Algebraic
Definition: stepsol.h:236

HopeSolver::Rho
DriveOwner Rho
Definition: stepsol.h:592

DerivativeSolver::TestScale
virtual doublereal TestScale(const NonlinearSolverTest *pTest, doublereal &dAlgebraicEqu) const
Definition: stepsol.cc:439

MultistepSolver::a
doublereal a[2][2]
Definition: stepsol.h:518

Step1Integrator::PredictDof
void PredictDof(const int DCount, const DofOrder::Order Order, const VectorHandler *const pSol=0) const
Definition: stepsol.cc:581

StepIntegrator::UpdateLoop
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

MultistepSolver::b
doublereal b[3][2]
Definition: stepsol.h:519

HopeSolver::SetDriveHandler
void SetDriveHandler(const DriveHandler *pDH)
Definition: stepsol.cc:1194

Step2Integrator::dPredDer
virtual doublereal dPredDer(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2) const =0

doublereal
double doublereal
Definition: colamd.c:52

HopeSolver::mp
doublereal mp[2]
Definition: stepsol.h:600

integer
long int integer
Definition: colamd.c:51

StepNIntegrator::Residual
virtual void Residual(VectorHandler *pRes) const
Definition: stepsol.cc:464

InverseDynamicsStepSolver::pLambdaCurr
VectorHandler * pLambdaCurr
Definition: stepsol.h:686

ImplicitEulerIntegrator::SetCoef
void SetCoef(doublereal dT, doublereal dAlpha, enum StepChange NewStep)
Definition: stepsol.cc:929

MultistepSolver::np
doublereal np[2]
Definition: stepsol.h:522

CrankNicolsonIntegrator::~CrankNicolsonIntegrator
~CrankNicolsonIntegrator(void)
Definition: stepsol.cc:845

StepIntegrator::dTol
doublereal dTol
Definition: stepsol.h:99

Step2Integrator::pXPrimePrev2
VectorHandler * pXPrimePrev2
Definition: stepsol.h:435

HopeSolver::dPredictDerivative
doublereal dPredictDerivative(const doublereal &dXm1, const doublereal &dXm2, const doublereal &dXPm1, const doublereal &dXPm2, DofOrder::Order o=DofOrder::DIFFERENTIAL) const
Definition: stepsol.cc:1281

Step2Integrator::pXPrev
VectorHandler * pXPrev
Definition: stepsol.h:434

StepIntegrator::GetIntegratorNumUnknownStates
virtual integer GetIntegratorNumUnknownStates(void) const
Definition: stepsol.cc:87

StepIntegrator::GetIntegratorDSolTol
virtual doublereal GetIntegratorDSolTol(void) const
Definition: stepsol.cc:105

Step1Integrator::dPredDerAlg
virtual doublereal dPredDerAlg(const doublereal &dXm1, const doublereal &dXPm1) const =0

myassert.h

ImplicitStepIntegrator
Definition: stepsol.h:151

ImplicitStepIntegrator::~ImplicitStepIntegrator
virtual ~ImplicitStepIntegrator(void)
Definition: stepsol.cc:139