MBSim

Project Page
Public Member Functions | Protected Attributes
MBSim::AutoTimeSteppingSSCIntegrator Class Reference

Explicit and Implicit time-stepping integrator of first or higer order with StepSize Control (SSC) StepSizeControl, GapControl, Extrapolation und concept analogue to TimeSteppingSSCIntegrator. More...

#include <auto_time_stepping_ssc_integrator.h>

Inheritance diagram for MBSim::AutoTimeSteppingSSCIntegrator:
MBSim::Integrator MBSim::Solver

List of all members.

Public Member Functions

 AutoTimeSteppingSSCIntegrator ()
 ~AutoTimeSteppingSSCIntegrator ()
void setInitialStepSize (double dt_)
void setStepSizeMax (double dtMax_)
void setStepSizeMin (double dtMin_)
void setmaxGainSSC (double maxGain)
void setSafetyFactorSSC (double sfactor)
void setSafetyFactorGapControl (double s)
void setOutputInterpolation (bool flag=true)
void setFlagPlotIntegrator (bool flag=true)
void setGapControl (int strategy=1)
void setDriftCompensation (bool dc)
void setMaxOrder (int order_, int method_=0)
void deactivateSSC (bool flag=false)
void setFlagErrorTest (int Flag, bool alwaysValid=true)
void integrate (DynamicSystemSolver &system_)
void integrate (DynamicSystemSolver &system_, std::vector< DynamicSystemSolver * > systems)
void integrate (DynamicSystemSolver &systemT1_, DynamicSystemSolver &systemT2_, DynamicSystemSolver &systemT3_, DynamicSystemSolver &systemTP_, int Threads=0)
void integrate (DynamicSystemSolver &systemT1_, DynamicSystemSolver &systemT2_, DynamicSystemSolver &systemT3_, DynamicSystemSolver &systemTP_, std::vector< DynamicSystemSolver * > systems, int Threads=0)
void setAbsoluteTolerance (const fmatvec::Vec &aTol_)
 Tolerances for Integrator.
void setAbsoluteTolerance (double aTol_)
void setRelativeTolerance (const fmatvec::Vec &rTol_)
void setRelativeTolerance (double rTol_)
void setgapTolerance (double gTol)
void preIntegrate (DynamicSystemSolver &system)
 subroutines for integrate function
void subIntegrate (DynamicSystemSolver &system, double tStop)
void postIntegrate (DynamicSystemSolver &system)
void preIntegrate (DynamicSystemSolver &systemT1_, DynamicSystemSolver &systemT2_, DynamicSystemSolver &systemT3_, DynamicSystemSolver &systemTP_)
void getAllSetValuedla (fmatvec::Vec &la_, fmatvec::VecInt &la_Sizes, std::vector< MBSim::Link * > &SetValuedLinkList)
 internal subroutines
void setAllSetValuedla (const fmatvec::Vec &la_, const fmatvec::VecInt &la_Sizes, std::vector< MBSim::Link * > &SetValuedLinkList)
void getDataForGapControl ()
bool testTolerances ()
bool GapControl (double qUnsafe, bool SSCTestOK)
bool changedLinkStatus (const fmatvec::VecInt &L1, const fmatvec::VecInt &L2, int ex)
double calculatedtNewRel (const fmatvec::Vec &ErrorLocal, double H)
void plot ()
void plotPar ()
void doIntegPlot ()
virtual void initializeUsingXML (xercesc::DOMElement *element)
 initialize integrator
void update (DynamicSystemSolver &system, const fmatvec::Vec &z, double t, int nrSys_=1)
 special update of dynamic system for theta time stepping integrator
void doStep (DynamicSystemSolver &system_, fmatvec::Vec &z_, int nrSys_, double t_, double dt_, bool exp_)
void doExpStep (DynamicSystemSolver &system_, fmatvec::Vec &z_, int nrSys_, double t_, double dt_)
 Do One Explicit Time Integration Step.
void doImpStep (DynamicSystemSolver &system_, fmatvec::Vec &z_, int nrSys_, double t_, double dt_)
 Do One Implicit Time Integration Step.
void doLinImpStep (DynamicSystemSolver &system_, fmatvec::Vec &z_, int nrSys_, double t_, double dt_)
 Do One Linear Implicit Time Integration Step.
void setTheta (double theta_)
 set combination parameter between explicit (0) and implicit (1) Euler scheme
void getdhdqdhdu (fmatvec::Mat &dhdq_, fmatvec::Mat &dhdu_, const fmatvec::Vec z_, const double t_, const int nsys_)
 get Jabobians by parallel calculation
void setItMax (int itMax_)
 set maximum number of full implicit iterations
void setInexactJac (bool inexactJac_)
 set of exact or inexact Jabians should be used
void setItTol (double itTol_)
 Tolerance for Newton Iterations of full implicit iterations.
void setSetValuedForceLawsExplicit (bool SetValuedForceLawsExplicit_)
 Set-valued force laws with explicit or implicit discretization.
void setDebugOutput (bool debugOutput_)
 Flag if Debug-Output should be displayed.
void setPlotParallel (bool plotParallel_)
 Flag if Plotting should be done in Parallel.

Protected Attributes

DynamicSystemSolver * sysT1
DynamicSystemSolver * sysT2
DynamicSystemSolver * sysT3
DynamicSystemSolver * sysTP
double dt
double dtOld
double dte
double dtMin
double dtMax
double dt_SSC_vorGapControl
bool driftCompensation
double t
double tPlot
double tPlotP
int qSize
int xSize
int uSize
int zSize
fmatvec::Vec ze
fmatvec::Vec zeP
fmatvec::Vec zi
fmatvec::Vec ziP
fmatvec::Vec zT1
fmatvec::Vec zT2
fmatvec::Vec zT3
fmatvec::Vec zTP
fmatvec::Vec z1d
fmatvec::Vec z2d
fmatvec::Vec z2dRE
fmatvec::Vec z3d
fmatvec::Vec z4d
fmatvec::Vec z6d
fmatvec::Vec z2b
fmatvec::Vec z3b
fmatvec::Vec z4b
fmatvec::Vec z6b
fmatvec::Vec zStern
fmatvec::VecInt LS
fmatvec::VecInt LSe
fmatvec::VecInt LSA
fmatvec::VecInt LSB1
fmatvec::VecInt LSB2
fmatvec::VecInt LSC1
fmatvec::VecInt LSC2
fmatvec::VecInt LSC3
fmatvec::VecInt LSC4
fmatvec::VecInt LSD1
fmatvec::VecInt LSD2
fmatvec::VecInt LSD3
fmatvec::VecInt LSD4
fmatvec::VecInt LSD5
fmatvec::VecInt LSD6
fmatvec::VecInt LS_Reg
fmatvec::VecInt LSe_Reg
fmatvec::VecInt LSA_Reg
fmatvec::VecInt LSB1_Reg
fmatvec::VecInt LSB2_Reg
fmatvec::VecInt LSC1_Reg
fmatvec::VecInt LSC2_Reg
fmatvec::VecInt LSC3_Reg
fmatvec::VecInt LSC4_Reg
fmatvec::VecInt LSD1_Reg
fmatvec::VecInt LSD2_Reg
fmatvec::VecInt LSD3_Reg
fmatvec::VecInt LSD4_Reg
fmatvec::VecInt LSD5_Reg
fmatvec::VecInt LSD6_Reg
fmatvec::VecInt LS_Reg_T1
fmatvec::VecInt LS_Reg_T2
fmatvec::VecInt LS_Reg_T3
fmatvec::VecInt LS_Reg_z2b
fmatvec::VecInt S_Reg_z1d
fmatvec::VecInt LS_Reg_z4b
fmatvec::VecInt LS_Reg_z6b
fmatvec::VecInt LS_Reg_z1d
fmatvec::VecInt LS_Reg_z3b
fmatvec::VecInt LSB1_2_Reg
fmatvec::VecInt LS_tmp
fmatvec::Vec la
fmatvec::Vec laP
fmatvec::Vec lae
fmatvec::Vec laeP
fmatvec::Vec la1d
fmatvec::Vec la2b
fmatvec::VecInt laSizes
fmatvec::VecInt laSizesP
fmatvec::VecInt laeSizes
fmatvec::VecInt laeSizesP
fmatvec::VecInt la1dSizes
fmatvec::VecInt la2bSizes
fmatvec::Vec qT1
fmatvec::Vec qT2
fmatvec::Vec qT3
fmatvec::Vec qTP
fmatvec::Vec uT1
fmatvec::Vec uT2
fmatvec::Vec uT3
fmatvec::Vec uTP
fmatvec::Vec xT1
fmatvec::Vec xT2
fmatvec::Vec xT3
fmatvec::Vec xTP
fmatvec::Vec gInActive
fmatvec::Vec gdInActive
std::vector< MBSim::Link * > SetValuedLinkListT1
std::vector< MBSim::Link * > SetValuedLinkListT2
std::vector< MBSim::Link * > SetValuedLinkListT3
std::vector< MBSim::Link * > SetValuedLinkListTP
int StepsWithUnchangedConstraints
int FlagErrorTest
 Include (0) or Exclude (3) Variable u or Scale (2) with Stepsize for Error Test.
bool FlagErrorTestAlwaysValid
 FlagErrorTest is Always Valid or Only During Nonsmooth Steps.
fmatvec::Vec aTol
 Absolute Tolerance.
fmatvec::Vec rTol
 Relative Tolerance.
bool FlagSSC
 Stepsize Control activated or Deactivated.
int maxOrder
 Maximum order of Integration Scheme SSC by extrapolation (steps with differnt dt are compared): 1, 2, 3 SSC with embedded methods (differnt orders are compared): 1 to 4 [ 1= 1(2), ...
int method
 method for intrgration and step size control method=0 step size control by extrapolation (steps wit dt and dt/2 are compared) DEFAULT method=1 embedded method for step size control (maxOrder and maxOrder+1 are compared); proceed with maxOrder (recommended) method=2 embedded method for SSC with -local extrapolation- (integration is continued with maxOrder+1)
bool FlagGapControl
double gapTol
 Toleranz for closing gaps.
double maxGainSSC
 maximal gain factor for increasing dt by stepsize control (default 2.5; maxGain * safetyFactor must be GT 1)
double safetyFactorSSC
 safety factor for stepsize estimation: dt = dt_estimate * safetyFactorSSC (]0;1]; default 0.6)
std::ofstream integPlot
 filestream for integrator info at each step
bool FlagPlotIntegrator
 Flag: write integrator info at each step to a file (default true)
bool FlagPlotIntegrationSum
 Flag: write integration summary to a file (default true)
bool FlagCoutInfo
 Flag: write integration info (integ.
bool FlagPlotEveryStep
 every successful integration step is ploted (set dtPlot=0 to activate FlagPlotEveryStep) (default false)
bool outputInterpolation
 Flag interpolate z and la for plotting (default true)
double safetyFactorGapControl
 Safety factor for GapControl (dtNew = dt_gapcontrol*safetyFactor; default min(1+RTol,1.001)
int GapControlStrategy
 choose strategy for Gap Control (1:maximal Stepsize to 4:minimal Penetration) 1: uses biggest root (maximal dt) 2: score for all roots are evaluated 3: gapTol is used 4: uses smallest root (minimal penetration) 0: gap control deactivated
int numThreads
 Number of Threads.
int numThreadsB1
double time
 computaional time
double dhdztime
double timeB1
double timeB2
double timePlot
double timePlotPar
StopWatch Timer
 for internal use (start clock, integration info ...)
StopWatch dhdzTimer
StopWatch TimerB1
StopWatch TimerB2
StopWatch TimerPlot
StopWatch TimerPlotPar
int iter
 Iterations for solving set-valued laws of different systems.
int iterA
int iterB1
int iterB2
int iterC1
int iterC2
int iterC3
int iterC4
int iterB2RE
int maxIterUsed
int maxIter
int sumIter
int integrationSteps
 Counter for Integrations steps.
int integrationStepswithChange
int refusedSteps
int refusedStepsWithImpact
int JacUpdateT1
 Counter for Jacobi updates.
int JacUpdateT2
int JacUpdateT3
int wrongAlertGapControl
 Variables for GapControl.
int stepsOkAfterGapControl
int stepsRefusedAfterGapControl
int statusGapControl
int singleStepsT1
 Single steps of different systems.
int singleStepsT2
int singleStepsT3
double dtRelGapControl
 Other internal variables.
double qUncertaintyByExtrapolation
int indexLSException
fmatvec::Vec gUniActive
double Penetration
double PenetrationCounter
double PenetrationLog
double PenetrationMin
double PenetrationMax
double maxdtUsed
double mindtUsed
bool ChangeByGapControl
bool calcBlock2
bool IterConvergence
bool ConstraintsChanged
bool ConstraintsChangedBlock1
bool ConstraintsChangedBlock2
bool ConstraintsChanged_B1_A
int integrationStepsOrder1
int integrationStepsOrder2
int order
int StepTrials
int AnzahlAktiverKontakte
double gNDurchschnittprostep
int iter_T1
 iteration counters
int iter_T2
int iter_T3
int step
fmatvec::Index Iq
fmatvec::Index Iu
fmatvec::Index Ix
bool expInt
 Flag for Explicit or Implicit Integration.
int it_T1
 Number of Iterations for Full-Implicit Integration.
int it_T2
int it_T3
bool gAC_T1
 Flag if gActiveChanged (set-valued)
bool gAC_T2
bool gAC_T3
bool gAC_reg_T1
bool gAC_reg_T2
bool gAC_reg_T3
bool upgedated_T1
 Flag if System has already been updated.
bool upgedated_T2
bool upgedated_T3
bool JacUpdate_B1_T1
 Flag if Jabobis of different Systems were updated in B1 or B2.
bool JacUpdate_B2_T1
bool JacUpdate_B1_T2
bool JacUpdate_B2_T2
bool JacUpdate_T1
bool JacUpdate_T2
int itMax
 Maximal number of Iterations for Full-Implicit Integration.
double itTol
 Tolerance for Full-Implicit Integration.
fmatvec::Mat dhdq_n_T1
 Jacobi-Matrices for implicit integration.
fmatvec::Mat dhdu_n_T1
fmatvec::Mat dhdq_n_T2
fmatvec::Mat dhdu_n_T2
fmatvec::Mat dhdq_n_T3
fmatvec::Mat dhdu_n_T3
fmatvec::Mat dhdq_T1
fmatvec::Mat dhdu_T1
fmatvec::Mat dhdq_T2
fmatvec::Mat dhdu_T2
fmatvec::Mat dhdq_T3
fmatvec::Mat dhdu_T3
fmatvec::Mat dhdq_z1d
fmatvec::Mat dhdu_z1d
fmatvec::Mat dhdq_z2b
fmatvec::Mat dhdq_z3b
fmatvec::Mat dhdq_z4b
fmatvec::Mat dhdq_z6b
fmatvec::Mat dhdu_z2b
fmatvec::Mat dhdu_z3b
fmatvec::Mat dhdu_z4b
fmatvec::Mat dhdu_z6b
fmatvec::Mat dhdq_end
fmatvec::Mat dhdu_end
fmatvec::Mat dhdq_z2d
fmatvec::Mat dhdu_z2d
fmatvec::Mat dhdq_z2dRE
fmatvec::Mat dhdu_z2dRE
fmatvec::Mat dhdq_z3d
fmatvec::Mat dhdu_z3d
fmatvec::Mat dhdq_z4d
fmatvec::Mat dhdu_z4d
fmatvec::Mat dhdq_z6d
fmatvec::Mat dhdu_z6d
double theta
 combination parameter between explicit (0) and implicit (1) Euler scheme
bool parJac
bool parInt
std::vector
< DynamicSystemSolver * > * 
psystems
bool inexactJac
 Flag of Exact or Inexact Jacobians should be uses.
int maxImpIter
int JacConstSteps
bool SetValuedForceLawsExplicit
 Set-valued force laws with explicit or implicit discretization.
bool debugOutput
 Flag if Debug-Output should be displayed.
bool plotParallel
 Flag if Plotting should be done in Parallel.
fmatvec::Mat JacVgl
fmatvec::Mat JacVgl2
fmatvec::Mat JacVgl3
int JacCounter
 Counter for all Jacobian Updates.

Detailed Description

Explicit and Implicit time-stepping integrator of first or higer order with StepSize Control (SSC) StepSizeControl, GapControl, Extrapolation und concept analogue to TimeSteppingSSCIntegrator.

important options / settings :

a) setMaxOrder(int order, int method=0) order: maximum order of integration scheme 1 to 3 with SSC by extrapolation (method=0) (order=4 without SSC) 1 to 4 with embedded SSC (1=1(2), ... 4=4(5)) (method=1 or 2) method: method used for error estimation and Stepsize control 0: step size control by extrapolation (steps wit dt and dt/2 are compared) DEFAULT 1: embedded method (compare maxOrder maxOrder+1); proceed with maxOrder (recommended) 2: embedded method with local extrapolation (integration is continued with maxOrder+1)

b) setFlagErrorTest(int Flag, bool alwaysValid= true) Flag: for scaling variables for the purpose of error estimation 0: include velocities u for error test 2: scale velocities u with stepsize for error test 3: exclude velocities u for error test alwaysValid: true : u is scaled resp. exluded during smooth and nonsmooth steps alwaysValid: false : u is scaled resp. exluded only during nonsmooth steps

c) deactivateSSC(bool flag=false) : maximum order: 1 to 4

d) setGapControl(bool FlagGapControl=true, int GapControlStrategy=0) FlagGapControl activate / deactivate gap control GapControlStrategy choose strategy for Gap Control (1:maximal Stepsize to 4:minimal Penetration) 1: uses biggest root (maximal dt) 2: score for all roots are evaluated 3: gapTol is used 4: uses smallest root (minimal penetration) 0: gap control deactivated

e) Basic Implicit Integration Implicit Integration only possible with:

f) setInexactJac(bool inexactJac_=false) inexactJac_: true: - Linear Implicit Integration: Jacobis are updated if time step size changes,

e) Parallel Computation: The concept allows the following parallel computation methods:

Usage:

Author:
Jan Clauberg

Constructor & Destructor Documentation

Constructor with dt(1e-5), driftCompensation(false)

Destructor


Member Function Documentation

void MBSim::AutoTimeSteppingSSCIntegrator::doExpStep ( DynamicSystemSolver &  system_,
fmatvec::Vec &  z_,
int  nrSys_,
double  t_,
double  dt_ 
)

Do One Explicit Time Integration Step.

Parameters:
dynamicsystem
Vectorz
Numberof Dynamic System
CurrentTime
CurrentTimeStepSize
void MBSim::AutoTimeSteppingSSCIntegrator::doImpStep ( DynamicSystemSolver &  system_,
fmatvec::Vec &  z_,
int  nrSys_,
double  t_,
double  dt_ 
)

Do One Implicit Time Integration Step.

Parameters:
dynamicsystem
Vectorz
Numberof Dynamic System
CurrentTime
CurrentTimeStepSize
void MBSim::AutoTimeSteppingSSCIntegrator::doLinImpStep ( DynamicSystemSolver &  system_,
fmatvec::Vec &  z_,
int  nrSys_,
double  t_,
double  dt_ 
)

Do One Linear Implicit Time Integration Step.

Parameters:
dynamicsystem
Vectorz
Numberof Dynamic System
CurrentTime
CurrentTimeStepSize
virtual void MBSim::AutoTimeSteppingSSCIntegrator::initializeUsingXML ( xercesc::DOMElement *  element) [virtual]

initialize integrator

Parameters:
XMLdescription

Reimplemented from MBSim::Integrator.

Start the integration

Implements MBSim::Integrator.

Set drift compensation

void MBSim::AutoTimeSteppingSSCIntegrator::setFlagErrorTest ( int  Flag,
bool  alwaysValid = true 
)

Set Flag vor ErrorTest (default 0: all variables ae tested; 2: u is scaled with dt; 3: exclude u alwaysValid = true : u is scaled resp. exluded during the smooth and nonsmooth part alwaysValid = false : u is scaled resp. exluded only during nonsmooth steps

set Flag for writing integrator info at each step to a file (default true)

void MBSim::AutoTimeSteppingSSCIntegrator::setGapControl ( int  strategy = 1) [inline]

Set Flag to optimise dt for minmal penetration of unilateral links; choose strategy for Gap Control (1:maximal Stepsize to 4:minimal Penetration) 1: uses biggest root (maximal dt) 2: score for all roots are evaluated 3: gapTol is used 4: uses smallest root (minimal penetration) 0: gap control deactivated with statistic calculations -1: gap control deactivated without statistic calculations

Set initial step size

void MBSim::AutoTimeSteppingSSCIntegrator::setmaxGainSSC ( double  maxGain) [inline]

Set maximal gain for increasing dt by stepsize control

void MBSim::AutoTimeSteppingSSCIntegrator::setMaxOrder ( int  order_,
int  method_ = 0 
)

set maximum order (1,2,3 (method=0) or 1 to 4 (method=1,2) and method 0: SSC by extrapolation (recommended!!); 1,2: embedded SSC; proceed with maxOrder [1] (recommended if you don't want to use 0) or with maxOrder+1 [2] without SSC maximum order from 1 to 4 is possible

Set Flag for output interpolation

safety factor for stepsize estimation: dt = dt_estimate * safetyFactorSSC (]0;1]; default 0.6)

void MBSim::AutoTimeSteppingSSCIntegrator::setStepSizeMax ( double  dtMax_) [inline]

Set maximal step size

void MBSim::AutoTimeSteppingSSCIntegrator::setStepSizeMin ( double  dtMin_) [inline]

Set minimal step size (default 2*maxOrder*epsroot()

void MBSim::AutoTimeSteppingSSCIntegrator::update ( DynamicSystemSolver &  system,
const fmatvec::Vec &  z,
double  t,
int  nrSys_ = 1 
)

special update of dynamic system for theta time stepping integrator

Parameters:
dynamicsystem
statevector
time
Systemnumber

Member Data Documentation

Flag: write integration info (integ.

summary) to cout (default true)

Maximum order of Integration Scheme SSC by extrapolation (steps with differnt dt are compared): 1, 2, 3 SSC with embedded methods (differnt orders are compared): 1 to 4 [ 1= 1(2), ...

4= 4(5) ] maxOrder(maxOrder+1) - not available for implicit integration


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