Solution

With the co-simulation between a highly dynamic process such as the particle motion, and much slower processes from the continuum mechanical world, the main question is about the different time-scales and how to deal with this issue.

The DEM repulsion dominates essentially the time increment of the system. An elastic collision between particles and other elastic structures during the contact time is broken up into about 50 time steps.

The animation below shows the time track of the nodal forces acting on the elastic membrane over a period of about 50 microseconds and 420 time steps.

The structure appears to solidify, although the forces vary greatly. The effect is due to the small time increment and the time interval, and illustrates the different time scales on which to run the particle and structural dynamics.

In addition to the time-scale issue, there are practical applications (for example, from mining), in which the dynamics of the structure is of no interest, but only a mean load or deformation.

One such case is the co-simulation of a transient particle code with a purely static structural model. The target values of the simulations of this special case are time-averaged forces and deformations.

For the different types of co-simulations various coupling algorithms are available:

Event based
A transient particle code is coupled to a static structure model. The forces are time integrals or time averages and weigh a static structural model.

Synchronous time increment:
Both partners of the co-simulation use the identical time increment. Here, two methods can be distinguished.

1. Minimal time step:
   Both partner-codes accept a minimum time increment, which is continuously determined and synchronized between the codes.
2. Master-slave concept:
   The time increment is defined by only one of the partner-codes. The method may indeed lead to numerical instabilities in explicit codes, on the other they hand significantly reduce the computation time for implicit codes.

Asynchronous time increment
Each code uses the best, perhaps the largest time increment. This requires storing a time history, time interpolations and time integrations.

Also in this case, two variants are possible.

1. Indiviual:
   Each code is working at the optimum time for him increment.
2. Adaptive:
   The time increment of the slower code is adaptively adjusted by the computation time requirement of the faster solver in order to minimize interpolation errors with optimal utilization of the computer.