Central Difference Method (Explicit Method)
Central Difference Method (Explicit Method): Theoretical Foundations
What is the Explicit Method?
Professor, what is the difference between the "Explicit Method" and the "Implicit Method"?
The Implicit Method solves a system of equations at each time step (with equilibrium iterations). The Explicit Method directly calculates the displacement at the next time step using only the inverse of the mass matrix (or its reciprocal if diagonal), without solving a system of equations.
Without solving a system of equations? That sounds fast.
The calculation per step is orders of magnitude faster. However, there is a stability condition, requiring a very small time step ($\Delta t \propto L_{min} / c$, where $c$ is the speed of sound). It is optimal for short-duration phenomena like impact.
Central Difference Method Algorithm
For the equation of motion $[M]\{\ddot{u}\} = \{F\} - [K]\{u\} - [C]\{\dot{u}\}$:
1. Acceleration Calculation: $\{\ddot{u}_n\} = [M]^{-1}(\{F_n\} - \{F_{int,n}\})$
2. Velocity Update: $\{\dot{u}_{n+1/2}\} = \{\dot{u}_{n-1/2}\} + \Delta t_n \{\ddot{u}_n\}$
3. Displacement Update: $\{u_{n+1}\} = \{u_n\} + \Delta t_{n+1/2} \{\dot{u}_{n+1/2}\}$
If $[M]^{-1}$ is a diagonal matrix, the inverse is just taking the reciprocal of each diagonal component... super fast computation!
That's why the Lumped Mass Matrix (diagonal) is essential in explicit methods. Using a consistent mass matrix (non-diagonal) makes the inverse calculation costly, negating the advantage of the explicit method.
Stability Condition (CFL Condition)
Stable time increment for explicit methods:
$L_{min}$ is the minimum element size, $c$ is the material's speed of sound (elastic wave speed).
For steel ($c \approx 5000$ m/s) with $L_{min} = 5$ mm, then $\Delta t \leq 1 \mu s$... that's extremely small!
That's why analyzing one second requires over 1 million steps. An impact (a few ms) can be done in a few thousand steps, but a quasi-static analysis (several seconds) becomes enormous. Explicit methods are suitable for short-duration dynamic phenomena.
Explicit Method vs. Implicit Method
| Characteristic | Explicit Method | Implicit Method |
|---|---|---|
| Computation per step | Very light | Heavy (system of equations) |
| Time Step | Very small (order of $\mu s$) | Large ($ms \sim s$) |
| Stability Condition | Yes (CFL Condition) | No (unconditionally stable) |
| Application | Impact, explosion, collision | Quasi-static, vibration |
| Contact | Easy | Difficult |
| Nonlinearity | Handled naturally | Requires iteration |
Ease of handling contact is a big advantage.
In explicit methods, contact detection and force calculation are performed independently at each step, with no convergence issues. For problems with many simultaneous contacts, like car crashes, explicit methods are overwhelmingly advantageous.
Summary
Let me organize the Central Difference Method (Explicit Method).
Key points:
- Does not solve a system of equations — If $[M]^{-1}$ is diagonal, it's just reciprocals.
- $\Delta t \leq L_{min} / c$ — CFL Condition. Determined by the smallest element.
- Optimal for short-duration dynamic phenomena — Impact, explosion, collision.
- Contact is easy — No convergence problems.
- Lumped mass matrix is essential — Not fast if not a diagonal matrix.
So the explicit method is an algorithm for "short-duration, intense phenomena".
All LS-DYNA analyses use the explicit method. Abaqus/Explicit also uses the explicit method. Automotive crash safety wouldn't be possible without this technique.
The Central Difference Method was born from 1695 calculus
The central difference method, which applies the finite difference concept published by Leibniz in 1695 to dynamics, approximates acceleration as a(t)=[u(t+Δt)−2u(t)+u(t−Δt)]/Δt². This second-order accurate scheme leads to the critical time step Δtcr=2/ωmax from von Neumann stability analysis, constrained not to exceed the natural frequency of the smallest element. This algorithm was first implemented on a large scale in FEM in the 1970s in DYNA3D, the predecessor code of LS-DYNA.
Computational Methods for Central Difference Method (Explicit Method)
Explicit Method Implementation
How is the FEM code for the explicit method implemented?
The main loop is extremely simple:
```
for each time step:
1. Internal force calculation: F_int = assemble(sigma B V) $ Element loop
2. External force calculation: F_ext = boundary_conditions()
3. Acceleration: a = (F_ext - F_int) / M_diag $ Diagonal division
4. Velocity update: v = v + dt * a
5. Displacement update: u = u + dt * v
6. Contact check: contact_detection_and_force()
7. Time increment update: dt = CFL * L_min / c
```
Step 3, "diagonal division", is the key point.
Yes. That's the source of the explicit method's speed. In implicit methods, step 3 becomes "solving an $n \times n$ system of equations", with orders of magnitude more computational cost.
Stable Time Increment Management
The stable time increment is determined by the smallest value among all elements:
If just one element is small, the overall $\Delta t$ becomes small.
The whole thing slows down because of one bad element?
Mesh quality directly affects computation speed. Elements with poor aspect ratios or collapsed elements have a very small $L_e$, reducing $\Delta t$. In explicit methods, mesh quality is key to computational efficiency.
Mass Scaling
Mass scaling artificially increases the mass of small elements to enlarge $\Delta t$:
Increasing $\rho$ decreases $c$ and increases $\Delta t$. An essential technique for quasi-static problems using explicit methods.
Doesn't increasing the mass change the inertial effects?
It does. Therefore, it's necessary to verify that kinetic energy / internal energy < 5%. If this condition is met, it can be considered "quasi-static".
Solver
| Solver Type | Characteristics | Explicit Method |
|---|---|---|
| Direct Method | Matrix factorization (LU, Cholesky) | NOT used (too slow) |
| Iterative Method | Conjugate gradient, GMRES | NOT used (not necessary) |
| Diagonal Inversion | Reciprocal of diagonal components | Standard |
In explicit methods, we don't need sophisticated solvers at all.
Exactly. That's the defining feature. Explicit methods achieve speed by avoiding the solver entirely. This is why explicit methods can scale extremely well on GPU and parallel computing.
Summary
I understand the computational methods for explicit methods now.
Key implementation points:
- Main loop is simple: Internal force → External force → Diagonal division → Update.
- Mesh quality matters: The time step is limited by the smallest element.
- Mass scaling: Artificially increase mass to reduce computation time (verify quasi-static assumption).
- No solver needed: Only diagonal inversion required — this is the speed advantage.
- Naturally parallel: Excellent for GPU and distributed computing.