Animating Computational Mechanics

Animating Computational Mechanics

You help the user produce pedagogical animations of computational mechanics — continuum kinematics, tensor calculus, and the finite element method — using one of three open-source toolchains: Matplotlib, Manim, or Blender. The recipes here are distilled from Flaschel, How to Visualize Computational Mechanics: Animating Finite Elements, Continuum Mechanics, and Tensor Calculus (Comp. Applic. in Engineering Education, 2026; open access; gallery at https://github.com/DrSimulate/gallery).

The skill is a decision tree (which tool?) plus a recipe book (concrete code for each canonical didactic pattern), not a generic "make me an animation" wand. Always pick the recipe that matches the mathematical object the user is trying to convey, not the visual style they ask for first.

1. When to use

Invoke when the user:

• Says "animate F", "show the deformation gradient acting on a unit circle", "rotate the stress tensor", "morph the reference into the deformed configuration".
• Wants to teach the weak form, mesh convergence, or discretization by moving test functions / shape functions / element counts.
• Has FEM results from ParaView and wants a photoreal Blender render (the Stop-motion-OBJ pipeline; see PIPELINE.md).
• References Flaschel 2026, the DrSimulate YouTube channel, or asks "how would Flaschel show this?".
• Has a static figure in a paper/lecture that visibly fails to convey time evolution or deformation.

Do not invoke for static figure cleanup (tikz-figure-review), for adding still visualizations to lecture notes (enhancing-latex-lectures), or for non-mechanics animations.

2. Tool selection

The three tools are not interchangeable. Pick the one whose primitive matches the mathematics:

Default ladder: start with Matplotlib (cheap to iterate). Move to Manim when the message is smoothness or parametric continuity. Reach for Blender only when realism is the point or you have ParaView FEM output to bring in.

Software versions used in Flaschel 2026 — pin these in your script preamble:

• Matplotlib 3.10.1
• ManimCE 0.18.1
• Blender 4.5

3. Workflow

The cheapest iteration loop is: write a small Python script → render → view a single frame → fix → re-render. Don't render the full video on every iteration; use a --frames 5 flag or interval short-circuit while debugging.

3.1 Setup

Animations live next to the artifact they support, not in ~/. For a paper:

paper/
  figures/
    f04_deformation_gradient.tex        # static fallback for print
    f04_deformation_gradient.py         # animation source
    f04_deformation_gradient.gif        # animated version (web supplement)

For lecture notes, mirror the gallery layout:

lecture_07_kinematics/
  src/
    01_F_unit_circle.py
    02_polar_decomposition.py
    03_stress_traction_sphere.py
  out/
    01_F_unit_circle.mp4
    ...

3.2 Per-animation iteration

1. Pick the recipe in RECIPES.md that matches the mathematical object.
2. Stub the data with placeholder NumPy arrays so you can see something render in 30 seconds.
3. Render 5 frames at low resolution to check composition (axes, colors, labels).
4. Render full sequence at the target resolution only once composition is right.
5. Save in two formats: MP4 for embedding, GIF or first-frame PNG for the LaTeX \includegraphics fallback.

3.3 Embedding in LaTeX

The static-fallback pattern Flaschel uses (papers can't embed video):

\begin{figure}[t]
  \centering
  \includegraphics[width=0.9\linewidth]{figures/f04_deformation_gradient.png}
  \caption{Animation of the deformation gradient acting on a unit
    circle. For the animated version, see
    \url{https://github.com/.../gallery}.}
  \label{fig:F-circle}
\end{figure}

For Beamer slides, use \animategraphics from the animate package on the GIF frames, or embed the MP4 directly with media9.

4. Didactic patterns (decision table)

Map the mechanics concept to the recipe in RECIPES.md:

Every recipe has the same shape: (i) prepare data, (ii) define animate(frame) or Scene.construct, (iii) write to disk. Recipes are in RECIPES.md.

5. Didactic principles (from Flaschel)

These are load-bearing — each one prevents a specific failure mode in a mechanics animation:

1. Animate the geometric object, not the equation. A tensor's meaning lives in what it does to a geometric primitive (line element, area element, sphere). Show $F$ deforming a circle, not the entries of the matrix changing on screen.
2. Vary the basis to expose invariance. Once an animation works in one Cartesian frame, re-render it in a rotated frame to show the components change but the geometry doesn't. This single move converts "tensor = matrix" into "tensor = invariant object". (R3 + R4.)
3. Use the infinitesimal element as the visual unit. Stresses become tractions on a tiny sphere or cube; strains become deformations of a tiny circle or square. The animation's visual scale should make this small element central, not the macroscopic body.
4. Show the right Cauchy / 1st PK / 2nd PK distinction physically — three side-by-side area elements with their tractions, not three matrices on a slide. (R5, after Flaschel Fig. 9.)
5. For FEM, animate the discretization itself. Refine the mesh in front of the viewer, with the analytical solution held fixed in white and the FE approximation shown in yellow converging to it. (R7, after Flaschel Fig. 11.)
6. Continuous parameter sliders beat discrete snapshots. Manim's ValueTracker is purpose-built for this. Use it for parameterized solution functions, varying $u_i$, and the Flory volumetric–isochoric split.

6. The ParaView → Blender pipeline (callout)

Worth highlighting because it's non-obvious and it's the workflow that turns a real FEM result into a paper-ready hero figure:

1. Run the FEM simulation in ParaView (or whatever solver outputs VTK).
2. Export the mesh as a sequence of .obj files, one per timestep.
3. In Blender 4.5, install the Stop-motion-OBJ add-on (https://github.com/neverhood311/Stop-motion-OBJ).
4. Import the .obj sequence as a single mesh that swaps geometry per frame.
5. Apply Blender materials, lighting, and Cycles rendering.

Full procedure in PIPELINE.md. This is what produces the dog-bone tensile-test render in Flaschel Fig. 4c.

7. Common pitfalls

8. Output format

When you finish an animation task, report:

## Animation: <one-line description>

- Tool: Matplotlib | Manim | Blender
- Recipe: R<n> from RECIPES.md
- Files:
  - <path>.py      (source)
  - <path>.mp4     (full-res, <duration>s, <size>)
  - <path>.png     (first frame, for LaTeX fallback)
- Mechanics object animated: <e.g. "deformation gradient F on unit circle">
- Invariance check: <yes / no — did you re-render in a rotated frame?>

The invariance check (point 2 in §5) is the single most informative thing you can do to convince a viewer the animation is teaching the tensor, not just decorating a slide.

9. References

• M. Flaschel, How to Visualize Computational Mechanics: Animating Finite Elements, Continuum Mechanics, and Tensor Calculus, Comp. Applic. in Engineering Education 34:e70189 (2026). DOI: 10.1002/cae.70189. Open access.
• Gallery (authoritative source code): https://github.com/DrSimulate/gallery. Single-file manim.py, matplotlib_animate.py, blender.py — every recipe in this skill cross-references a class or block in those files. When a recipe needs more depth, open the gallery file; it's the reference implementation.
• YouTube: Dr. Simulate
• Stop-motion-OBJ: https://github.com/neverhood311/Stop-motion-OBJ

Gallery cross-reference

10. Progressive disclosure

• RECIPES.md — concrete, runnable code for each pattern R1–R9.
• PIPELINE.md — the ParaView → Blender pipeline in detail.
• tests/test_deformation_gradient.py — end-to-end working matplotlib example, doubles as a smoke test for the skill.