Time Stepping

The choice between a constant or adaptive time increment is a primary design decision.

• Fixed Step: Uses a constant Δt (e.g., 1/60 sec). It is deterministic, easier to debug, and standard for real-time applications and reinforcement learning. However, it can become unstable if the step is too large for fast dynamics.
• Variable Step: Dynamically adjusts Δt based on the rate of change in the system (e.g., during high-velocity collisions). It maintains accuracy for stiff systems but sacrifices determinism and makes synchronization with control loops more complex.

The algorithm used to update positions and velocities from accelerations. Common schemes include:

• Explicit Euler (Forward Euler): Simple and fast (v_new = v_old + a * Δt; x_new = x_old + v_new * Δt). Prone to energy gain and instability.
• Semi-Implicit Euler (Symplectic Euler): More stable than explicit Euler. Updates velocity first, then uses the new velocity to update position. Commonly used in real-time engines.
• Runge-Kutta Methods (RK4): Higher-order, multi-stage methods that offer excellent accuracy for smooth systems but are computationally expensive. Often used for off-line, high-fidelity simulation.
• Verlet Integration: Excellent energy conservation for oscillatory systems, often used in molecular dynamics and particle systems.

Within each time step, the engine must resolve constraints like contact non-penetration and joint limits. This is often the most computationally intensive part of the step.

• Sequential Impulses: An iterative method that applies corrective impulses at contacts and joints each iteration, converging toward a valid solution. Used in engines like Box2D and Bullet.
• Projected Gauss-Seidel (PGS): A popular iterative solver for Linear Complementarity Problems (LCPs) arising from contact dynamics.
• Baumgarte Stabilization: A technique to add penalty forces for constraint drift (e.g., a joint becoming slightly loose over time), trading strict accuracy for stability.

Critical parameters that control quality and performance.

• Solver Iterations: The number of times the constraint solver loops within a single time step. Higher iterations produce more accurate contact and joint resolution but increase cost. Typical values range from 10 to 100.
• Substepping: Performing multiple smaller physics steps per rendered frame. For example, a 60 Hz graphics update might use 120 Hz or 240 Hz physics sub-steps. This is essential for stability when simulating fast-moving objects or stiff springs, as it effectively reduces the per-step Δt for the physics engine.

A deterministic simulation produces identical results from identical initial conditions, which is crucial for debugging and reinforcement learning.

• Sources of Non-Determinism: Floating-point non-associativity on parallel hardware, random seed usage in domain randomization, variable step sizes, and certain parallel solver implementations.
• Achieving Determinism: Requires fixed-step integration, ordered constraint processing, and careful management of floating-point operations (e.g., using fused multiply-add). Engines like MuJoCo and DART are designed to be deterministic.

The relationship between simulation time and wall-clock time defines the simulation's use case.

• Real-Time Simulation: One second of simulation takes one second of compute. This is mandatory for Hardware-in-the-Loop (HIL) testing and interactive applications. It imposes a hard deadline on the time step computation.
• Faster-Than-Real-Time (FTRT) Simulation: The primary mode for training AI/ML policies. The simulation runs as fast as possible, often leveraging GPU acceleration (e.g., in NVIDIA Isaac Sim). Throughput (environments/second) is the key metric, enabling the collection of millions of training steps in hours.

A physics engine is the core software library that implements the time stepping algorithm to simulate Newtonian mechanics. It provides the computational framework for:

• Rigid-body dynamics and soft-body dynamics
• Collision detection and contact resolution
• Constraint-based solvers for joints and contacts Popular engines used in robotics include MuJoCo, PyBullet/Bullet, NVIDIA Isaac Sim, and Gazebo (which integrates ODE, Bullet, or Simbody).

Rigid-body dynamics is the branch of mechanics that models the motion of non-deformable objects under forces and torques. It is the primary computational model solved by the time stepper at each simulation step. Core calculations include:

• Forward dynamics: Computing acceleration from applied forces.
• Inverse dynamics: Computing forces required for a desired motion.
• Articulated Body Algorithm (Featherstone): An O(n) algorithm for efficient dynamics of serial chains. The time stepper integrates the accelerations from these calculations to update positions and velocities.

A constraint-based solver is the algorithm that resolves interactions like contact and joints within a time step. It calculates the impulses or forces needed to satisfy physical constraints, such as:

• Non-penetration (objects cannot occupy the same space)
• Friction models (Coulomb friction)
• Joint limits and motor controls These solvers often frame the problem as a Linear Complementarity Problem (LCP) or a convex optimization. The solver's output directly influences the forces integrated by the time stepping routine.

Collision detection is the computational geometry process that identifies intersecting objects before forces are calculated by the constraint solver. It is a prerequisite for accurate contact dynamics. The process is typically two-phase:

• Broad phase: Uses spatial partitioning (e.g., bounding volume hierarchies) to quickly cull non-intersecting object pairs.
• Narrow phase: Performs precise geometric intersection tests on candidate pairs to generate contact manifolds (points, normals, penetration depth). This data is passed to the solver within each time step.

Simulation fidelity measures how accurately a virtual environment replicates real-world physics. The choice of time stepping method is a primary determinant of fidelity. Key factors include:

• Integration method: Simplectic Euler vs. Runge-Kutta methods.
• Time step size: Smaller steps increase accuracy but cost more compute.
• Constraint solver iterations: More iterations lead to more accurate contact resolution. High fidelity reduces the reality gap, but engineers must balance it against computational cost for real-time applications.

A deterministic simulation produces bit-identical results given the same initial conditions and inputs on every run. This is critical for:

• Reproducible robotics research and debugging
• Regression testing of controllers and policies
• Hardware-in-the-Loop (HIL) testing consistency Determinism is heavily influenced by the time stepping integrator and the constraint solver. Non-deterministic artifacts can arise from floating-point non-associativity, variable-step solvers, or randomizations within the physics engine.