BDF and MEBDF Solver

Both solvers are well suited for following models:

  • Non stiff or stiff models (systems having eigenfrequencies and/or time constants in a wide range).
  • Models with discontinuities. Event handling is done as shown in section Events.
  • The MEBDF‑solver is especially designed for models with higher index (e.g. MBS-models with closed loops). The results for such models are more accurate and the simulation speed is often faster.

The solvers use either a SimulationX internal representation of the model for

the RHS calculation or a compiled form. Without C code the preparation of the calculation goes faster, but the RHS calculation is slightly slower.

Figure 1: Predictor-corrector method

Both algorithms are predictor-corrector methods with automatic control of step size and order (k). With this kind of implicit multistep method the current value is extrapolated from (k + 1) already computed values for every state variable (predictor). This value is improved iteratively until the desired accuracy is obtained and certain convergence criteria are fulfilled (corrector).

If the corrector value is accepted, the next time step can be dealt with. To this end, a new step size and/or order is computed from the iteration curve.

If after a certain number of iterations no corrector value is obtained which fulfils the accuracy requirements, step size and/or order are decreased and the complete time step is repeated. 

The Maximum Order can be changed in the dialog "Simulation Control", tab "More". It indicates how many of the time steps which have been computed already may be included in the computation. During a simulation the system performs an automatic control of the order. When the maximum order selected is 1, the method corresponds to the implicit Euler method.

When the minimum step size is reached and convergence has still not been obtained, we get a hint. You should always reduce the minimum step size first then. Only if this does not help, the error bounds may be relaxed. A reduction of the maximum order is only required with strongly non-linear models where the methods with the default settings compute slowly or do not find any solution at all. The automatic control usually ensures that always the optimum order is used for computation.

During each corrector iteration a linear equation system must be solved:

where:

Residuals
State variables
Jacobian matrix
Number of iteration

The following methods are available for this:

  • Sparse Matrix Solver,
  • Gauss method,
  • Scaled Gauss method.

Select one of the methods by means of the dialog "Simulation Transient  Settings…", tab card "More". By default the "Sparse Matrix Solver" is selected. This solver takes advantage of the fact that mostly only local dependencies exist with the equation system to be solved. For example, with a drive line the state variables at the engine depend only indirectly via other state variables on those at the wheel. This causes many zero entries in the Jacobian matrix which need not be considered in the solution. This leads to a considerable faster computation as compared with the Gauss solver.

The "Gauss Method" is recommended for extremely strongly meshed models where no sparse Jacobian matrices are found. However, this case is very rare. Models with strongly differing time constants or high changes of the magnitude of the state variables can feature badly conditioned Jacobian matrices. The above mentioned methods will no longer be suitable then to compute an exact solution. This can lead to a bad convergence in the corrector steps (many corrector iterations, small step sizes) or even to the cancellation of the simulation. The "Scaled Gauss Method" attempts to improve the condition number and thus to yield a better solution.

Every model contains the variable Solver Debug Info solverInfo which is filled by the solver. The BDF or MEBDF solver writes the following nine components to this vector:

  1. Order.
  1. No. of corrector steps for predictor-corrector iterations.
  1. No. of discarded steps (invalid or discarded because of an event) between the last successful and the current step.
  1. No. of steps with too big error estimation between the last successful and the current step.
  1. No. of discarded steps because of lack of convergence between the last successful and the actual step.
  1. Recommended change of the step size (interesting in the context of event steps and discarded steps).
  1. No. of RHS calculations in invalid and valid steps (not during event iterations)
  1. No. of discontinuities (Event iterations)
  1. No. of Jacobian matrix computations.
  1. No. of event-steps, including internal event iterations, at the equilibrium calculation and embedding
  1. Number of substitute event steps in event iterations: for example, for collisions with end-stops, a numeric integration of (motion) equations (to maintain the conservation law of momentum) is required; in this case the substitute event steps during the event iteration are checked for changes in the discrete state of the system; if changes are found, the next step is suppressed and the equation system is re-calculated.