Large Deformation Kinematics

In linear FEA, we assume small strains — the geometry barely changes. But in crash simulation, rubber seal analysis, and metal forming, deformations can exceed 50% strain. This requires large deformation kinematics — the mathematical framework for tracking material through significant shape changes.

Reference vs Current Configuration

The key insight of large deformation mechanics is distinguishing between two configurations:

The Deformation Mapping

The relationship between reference and current positions is the deformation mapping:

$$\mathbf{x} = \boldsymbol{\varphi}(\mathbf{X}, t)$$

This function tells us: "Given a material point originally at position $\mathbf{X}$, where is it located at time $t$?"

Example: Rubber Seal Compression

A door seal cross-section deforms when the door closes. A simple deformation mapping might be:

$$\varphi_1 = (1 - 0.3t) X_1 + t(X_2 - h)^2$$

$$\varphi_2 = (1 + 0.2t) X_2$$

This captures:

• Compression in $X_1$ direction (factor decreases with time)
• Extension in $X_2$ direction (factor increases with time)
• Nonlinear shear (quadratic term creates bulging)

Material Point Tracking

In the animation below, we track a specific material point through deformation:

• Reference position: $\mathbf{X} = (X_1, X_2)$ — where the point starts
• Current position: $\mathbf{x} = \boldsymbol{\varphi}(\mathbf{X}, t)$ — where it moves to
• Displacement: $\mathbf{u} = \mathbf{x} - \mathbf{X}$ — how far it moved

The Python code for tracking a material point:

def phi(X, t):
    """Deformation mapping for rubber seal compression."""
    x0 = (1 - 0.25*t) * X[0] + t * (X[1] - 2)**2 + 2.5*t
    x1 = (1 + 0.25*t) * X[1] + 0.25*t
    x2 = X[2]
    return (x0, x1, x2)

# Track a material point
X = np.array([0.75, 1.25, 0.0])  # Reference position

for t in np.linspace(0, 1, 50):
    x = phi(X, t)  # Current position at time t
    u = x - X      # Displacement
    print(f"t={t:.2f}: x={x}, displacement={u}")

Automotive Applications

Crash Simulation

In LS-DYNA crash analysis, every element tracks its nodes through massive deformation:

• Frontal crash: Hood crumples from 1m to 0.3m (70% compression)
• Pole impact: B-pillar bends inward, material stretches and compresses

The element formulation must handle this without locking or hourglassing.

Rubber Seals

Door seals, engine mounts, and bushings undergo cyclic large deformations:

• Compression set: Does the seal return to original shape?
• Stress-strain response: Nonlinear, path-dependent

Visualizing kinematics helps engineers understand local deformation patterns.

Sheet Metal Forming

When stamping a fender or door panel:

• Drawing: Material flows into the die cavity
• Stretching: Material thins in some regions
• Wrinkling risk: Excessive compression causes buckling

Deformation mapping animations show where material comes from and where it goes.

Key Properties of Valid Deformations

1. Invertibility

At any time $t$, the mapping must be one-to-one. Two different material points cannot occupy the same spatial position.

$$\det(\mathbf{F}) > 0$$

where $\mathbf{F} = \partial\boldsymbol{\varphi}/\partial\mathbf{X}$ is the deformation gradient (next lesson).

2. Continuity

The mapping should be smooth (at least $C^1$) to define strains and stresses. Fracture introduces discontinuities that require special treatment.

3. Material Volume

For incompressible materials (like rubber):

$$\det(\mathbf{F}) = 1$$

This constraint means volume is preserved during deformation.

Manim Animation Code

Here's how to create the kinematics animation using Manim:

from manim import *

class Kinematics2D(MovingCameraScene):
    def construct(self):
        # Time tracker
        time = ValueTracker(0.00)

        # Reference body (stays fixed as shadow)
        reference = Triangle().move_to(2*UP + 1.25*RIGHT)
        reference_shadow = reference.copy().set_opacity(0.2)

        # Deformation mapping
        def phi(X, t):
            x0 = (1 - 0.25*t)*X[0] + t*(X[1]-2)**2 + 2.5*t
            x1 = (1 + 0.25*t)*X[1] + 0.25*t
            return (x0, x1, X[2])

        # Current body (updates with time)
        current = always_redraw(
            lambda: reference.copy().apply_function(
                lambda X: phi(X, time.get_value())
            )
        )

        self.add(reference_shadow, current)

        # Animate deformation
        self.play(time.animate.set_value(1.0), run_time=2)
        self.play(time.animate.set_value(0.0), run_time=2)

To run: manim -pql kinematics_2d.py Kinematics2D

Exercises

Exercise 1: Simple Shear

Implement the deformation mapping for simple shear:

$$\varphi_1 = X_1 + \gamma t \cdot X_2, \quad \varphi_2 = X_2$$

Visualize how horizontal layers slide over each other.

Exercise 2: Pure Stretch

Implement incompressible stretching:

$$\varphi_1 = \lambda X_1, \quad \varphi_2 = X_2 / \lambda$$

The product $\lambda \cdot (1/\lambda) = 1$ preserves area.

Exercise 3: Rotation

Implement pure rotation:

$$\varphi_1 = \cos\theta \cdot X_1 - \sin\theta \cdot X_2$$

$$\varphi_2 = \sin\theta \cdot X_1 + \cos\theta \cdot X_2$$

This should change shape (no stretching, no volume change).

Key Takeaways

• Reference configuration $\Omega_0$ is the undeformed state; current configuration $\Omega_t$ is deformed
• Deformation mapping $\mathbf{x} = \boldsymbol{\varphi}(\mathbf{X}, t)$ tracks where material points go
• Displacement $\mathbf{u} = \mathbf{x} - \mathbf{X}$ measures how far points move
• Valid deformations must be invertible ($\det\mathbf{F} > 0$)
• Visualizing kinematics builds intuition for crash, rubber, and forming simulations

What's Next

In the next lesson, we'll examine the deformation gradient tensor $\mathbf{F}$ — the key quantity that describes local stretching and rotation at every material point.