Rigid Body Dynamics

The primary axiom of a rigid body is that the distance between any two points on the object remains constant over time. This simplifies the mathematical representation to tracking just two vectors: the position of the center of mass and the orientation (typically as a quaternion or rotation matrix). Unlike soft body or fluid simulations, internal stresses and deformations are ignored, allowing for highly efficient computation of motion for objects like robotic arms, vehicles, and manipulated tools.

Rigid body motion is computed by solving Newton-Euler equations, which combine translational and rotational dynamics.

• Translational Motion: Governed by Newton's second law: F = m * a, where the net force F on the center of mass causes linear acceleration a.
• Rotational Motion: Governed by the rotational analog: τ = I * α + ω × (I * ω). Here, the net torque τ causes angular acceleration α, but must account for the current angular velocity ω and the body's inertia tensor I. The inertia tensor, a 3x3 matrix, defines how mass is distributed, affecting rotational resistance.

Simulating realistic interactions requires detecting collisions and generating contact forces to prevent interpenetration. This is a multi-stage pipeline:

• Broadphase: Uses spatial structures like Bounding Volume Hierarchies (BVH) to quickly cull non-interacting object pairs.
• Narrowphase: Precisely tests remaining pairs using algorithms like GJK (Gilbert–Johnson–Keerthi) to compute contact points, normals, and penetration depth.
• Constraint Solving: Contact and friction are modeled as constraints. Solvers (e.g., Projected Gauss-Seidel) calculate impulses to satisfy non-penetration and Coulomb friction laws, often framed as a Linear Complementarity Problem (LCP).

Real-world mechanisms are built from connected parts. Simulation engines model these connections via constraints that restrict relative motion between bodies.

• Common Joint Types: Revolute (hinge), prismatic (slider), spherical (ball-and-socket), and fixed.
• Constraint Solvers: These algebraic or geometric restrictions (e.g., "these two points must coincide") are added to the system of equations solved each time step. Efficient algorithms like Featherstone's Articulated Body Algorithm (ABA) compute forward dynamics for complex kinematic chains in O(n) time.

The equations of motion are differential equations solved discretely over time. The choice of integrator balances accuracy, performance, and stability.

• Explicit Methods (e.g., Semi-Implicit Euler): Simple and fast but can become unstable with large time steps or stiff constraints.
• Implicit Methods: More computationally expensive per step but offer greater stability, allowing for larger time steps. They are often used for simulations with many constraints or high stiffness.
• Fixed vs. Variable Step: Simulations for robotics training often use a fixed time step (e.g., 1/60 s) to ensure deterministic and reproducible results, which is critical for reinforcement learning.

For training AI policies, a simulation must be a reliable, repeatable environment.

• Determinism: Given identical initial conditions and inputs, a deterministic physics engine will produce bit-identical results across runs. This is essential for debugging, replay, and consistent RL training. Non-determinism can arise from parallel processing order or certain numerical solvers.
• Performance: Sim-to-real training requires billions of simulated time steps. Engines achieve this through massive parallelization (simulating thousands of robot instances simultaneously), optimized low-level math kernels, and efficient collision and constraint algorithms. Performance is measured in millions of time steps per second per core.

Multibody dynamics extends rigid body dynamics to systems of multiple interconnected bodies, such as robotic arms, vehicle suspensions, or humanoid robots. It focuses on solving the coupled equations of motion for these assemblies.

• Key Challenge: Efficiently handling the complex constraints and interactions between linked bodies.
• Primary Use: Simulating articulated systems where joints (revolute, prismatic, spherical) define relative motion.
• Algorithmic Foundation: Often solved using Featherstone's algorithms (like the Articulated Body Algorithm) which provide O(n) computational complexity.

A constraint solver is the algorithmic core of a physics engine that resolves forces and impulses to satisfy physical limits. In rigid body dynamics, it ensures bodies do not interpenetrate and that joints behave correctly.

• Mathematical Formulation: Often framed as a Linear Complementarity Problem (LCP) to model contact and friction.
• Common Method: The Projected Gauss-Seidel (PGS) solver iteratively projects solutions to satisfy constraints like non-penetration.
• Critical Function: Translates collision detection data into physically plausible motion by calculating correct contact forces.

Collision detection is the computational process of identifying when and where simulated objects intersect. It is a prerequisite for the contact resolution handled by rigid body dynamics.

• Pipeline Stages: Consists of broadphase (fast pair culling), narrowphase (exact shape intersection), and contact generation.
• Key Algorithms: Gilbert–Johnson–Keerthi (GJK) for distance/comparison between convex shapes; Bounding Volume Hierarchies (BVH) for spatial acceleration.
• Advanced Technique: Continuous Collision Detection (CCD) prevents 'tunneling' of fast-moving objects by testing their swept volume.

These are the two fundamental problems in simulating motion for rigid and articulated bodies.

• Forward Dynamics: Calculates the resulting acceleration and motion of a system given the applied forces and torques. This is the core computation for simulation.
• Inverse Dynamics: Calculates the forces and torques required at a system's joints to achieve a desired motion or trajectory. This is crucial for robot control and motion planning.
• Relationship: Inverse dynamics is often used to compute reference torques for controllers, while forward dynamics simulates the actual physical response.

Time integration is the numerical method used to advance the state of a rigid body simulation forward in time by solving the equations of motion.

• Core Equation: Solves Newton's second law, F = ma, and its rotational analogue, τ = Iα, over discrete time steps (Δt).
• Common Schemes:
  • Explicit Euler: Simple but can be unstable.
  • Semi-Implicit Euler (Symplectic Euler): More stable, commonly used in real-time engines.
  • Runge-Kutta Methods (RK4): Higher accuracy for demanding simulations.
• Stability vs. Performance: The choice of integrator directly affects simulation fidelity, energy conservation, and computational cost.

Spatial vector algebra is a 6D mathematical framework that unifies linear and angular motion, simplifying the formulation and computation of rigid body and multibody dynamics.

• Core Idea: Represents velocity, acceleration, momentum, and force for a rigid body as a single 6D spatial vector, combining 3D linear and 3D angular components.
• Key Benefit: Dramatically cleans up notation and implementation of algorithms like the Articulated Body Algorithm (ABA), making them more efficient and less error-prone.
• Industry Standard: The foundational mathematics used in high-performance robotics simulators like MuJoCo and Drake.