MBSim |
Project Page |
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>
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. | |
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:
Constructor with dt(1e-5), driftCompensation(false)
| void MBSim::AutoTimeSteppingSSCIntegrator::doExpStep | ( | DynamicSystemSolver & | system_, |
| fmatvec::Vec & | z_, | ||
| int | nrSys_, | ||
| double | t_, | ||
| double | dt_ | ||
| ) |
Do One Explicit Time Integration Step.
| dynamic | system |
| Vector | z |
| Number | of Dynamic System |
| Current | Time |
| Current | TimeStepSize |
| void MBSim::AutoTimeSteppingSSCIntegrator::doImpStep | ( | DynamicSystemSolver & | system_, |
| fmatvec::Vec & | z_, | ||
| int | nrSys_, | ||
| double | t_, | ||
| double | dt_ | ||
| ) |
Do One Implicit Time Integration Step.
| dynamic | system |
| Vector | z |
| Number | of Dynamic System |
| Current | Time |
| Current | TimeStepSize |
| void MBSim::AutoTimeSteppingSSCIntegrator::doLinImpStep | ( | DynamicSystemSolver & | system_, |
| fmatvec::Vec & | z_, | ||
| int | nrSys_, | ||
| double | t_, | ||
| double | dt_ | ||
| ) |
Do One Linear Implicit Time Integration Step.
| dynamic | system |
| Vector | z |
| Number | of Dynamic System |
| Current | Time |
| Current | TimeStepSize |
| virtual void MBSim::AutoTimeSteppingSSCIntegrator::initializeUsingXML | ( | xercesc::DOMElement * | element | ) | [virtual] |
| void MBSim::AutoTimeSteppingSSCIntegrator::integrate | ( | DynamicSystemSolver & | system_ | ) | [virtual] |
Start the integration
Implements MBSim::Integrator.
| void MBSim::AutoTimeSteppingSSCIntegrator::setDriftCompensation | ( | bool | dc | ) | [inline] |
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
| void MBSim::AutoTimeSteppingSSCIntegrator::setFlagPlotIntegrator | ( | bool | flag = true | ) | [inline] |
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
| void MBSim::AutoTimeSteppingSSCIntegrator::setInitialStepSize | ( | double | dt_ | ) | [inline] |
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
| void MBSim::AutoTimeSteppingSSCIntegrator::setOutputInterpolation | ( | bool | flag = true | ) | [inline] |
Set Flag for output interpolation
| void MBSim::AutoTimeSteppingSSCIntegrator::setSafetyFactorSSC | ( | double | sfactor | ) | [inline] |
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
| dynamic | system |
| state | vector |
| time | |
| System | number |
bool MBSim::AutoTimeSteppingSSCIntegrator::FlagCoutInfo [protected] |
Flag: write integration info (integ.
summary) to cout (default true)
int MBSim::AutoTimeSteppingSSCIntegrator::maxOrder [protected] |
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
1.8.0