Forward Dynamics

Forward dynamics solves the equations of motion for a rigid body system. Given the system's mass/inertia properties, its current kinematic state (position, orientation, velocity), and the applied forces/torques, it computes the resulting linear and angular accelerations. This is the fundamental physics engine operation: Acceleration = f(State, Forces).

The computation is built upon the Newton-Euler equations:

• Newton's Second Law (Linear): F = m * a (Force equals mass times linear acceleration).
• Euler's Equation (Rotational): τ = I * α + ω × (I * ω) (Torque equals inertia tensor times angular acceleration plus gyroscopic terms). These coupled equations are solved simultaneously for each body in the system.

Inputs Required:

• System Model: Mass, center of mass, inertia tensor for each body.
• Kinematic State: Position, orientation, linear velocity, angular velocity.
• Applied Loads: All external forces and torques (e.g., gravity, propulsion, contact forces from the constraint solver).
• Constraints: Joint definitions and active contact constraints.

Primary Output:

• Acceleration Vector: The computed linear (a) and angular (α) acceleration for every body, which is then integrated to update velocities and positions.

For complex articulated systems like robot manipulators, a naive O(n³) solution is inefficient. Advanced O(n) recursive algorithms are used:

• Featherstone Algorithm (Articulated Body Algorithm): Propagates forces and inertias inward, then computes accelerations outward without forming or inverting the large system mass matrix.
• Spatial Vector Algebra: Often used with Featherstone, it represents 6D linear/angular quantities compactly, simplifying notation and implementation.

Forward dynamics is tightly coupled with the constraint solver. The solver (handling contacts, joints) calculates the constraint forces needed to prevent penetration and maintain joint connections. These constraint forces are fed back as inputs to the forward dynamics computation. This creates a feedback loop: dynamics computes motion, which may cause new contacts, which the solver resolves, generating new forces for the next dynamics step.

Forward Dynamics is often contrasted with its inverse:

• Forward Dynamics: Acceleration = f(State, Forces). (Find motion from forces).
• Inverse Dynamics: Forces = f(State, Acceleration). (Find forces needed for a desired motion). Forward dynamics is used for simulation and prediction. Inverse dynamics is used for control system design and analysis, to compute the joint torques required to track a planned trajectory.

Inverse dynamics is the complementary calculation to forward dynamics. Given a desired motion trajectory (positions, velocities, and accelerations), it computes the forces and torques required at a system's joints to produce that motion. This is foundational for model-based control and actuator sizing.

• Primary Use: Robotics control, trajectory planning, and system analysis.
• Key Difference: Solves for forces/torques (inputs) from motion (output), whereas forward dynamics solves for motion from forces/torques.

The Newton-Euler equations are the fundamental differential equations of motion for a rigid body, forming the mathematical basis for forward dynamics.

• Newton's Second Law (Linear): (\vec{F} = m\vec{a}) relates net force to linear acceleration of the center of mass.
• Euler's Equation (Rotational): (\vec{\tau} = I\vec{\alpha} + \vec{\omega} \times I\vec{\omega}) relates net torque to angular acceleration, where (I) is the inertia tensor and (\vec{\omega}) is angular velocity.
• Combined: These equations are integrated by a physics engine to propagate the state of a body forward in time.

The Featherstone Algorithm (Articulated Body Algorithm) is an efficient O(n) recursive method for computing the forward dynamics of complex, articulated rigid body systems like robotic manipulators.

• Efficiency: Avoids constructing and inverting the large, dense system mass matrix required by naive methods.
• Process: Propagates velocities and inertias outward from the base, then calculates accelerations inward from the end-effector.
• Application: The standard for real-time simulation and control of high-degree-of-freedom robots and digital characters.

Spatial vector algebra is a compact 6D mathematical framework that combines linear and angular components into single vectors and matrices, dramatically simplifying the formulation of rigid body dynamics algorithms.

• Spatial Velocity: Combines linear ((v)) and angular ((\omega)) velocity into a 6D vector.
• Spatial Force: Combines force ((f)) and torque ((\tau)) into a 6D vector.
• Benefit: Algorithms like the Featherstone algorithm and equations of motion can be written in a much more concise and computationally efficient form.

The inertia tensor is a 3x3 symmetric matrix that quantifies how a rigid body's mass is distributed relative to its center of mass, defining its resistance to angular acceleration.

• Role in Forward Dynamics: It is the rotational analog of mass in (F=ma), appearing in Euler's equation (\tau = I\alpha + \omega \times I\omega).
• Properties: Depends on the body's shape and mass distribution. It causes a torque not aligned with the angular acceleration axis.
• Computation: Often pre-calculated from the geometry and density of a 3D model.

A constraint solver is the algorithmic core of a physics engine that resolves interactions like contact and joints. In forward dynamics, it calculates the forces/impulses needed to satisfy all constraints within a time step.

• Function: Takes the unconstrained accelerations from forward dynamics and modifies them to prevent penetration, enforce joint limits, and apply friction.
• Methods: Often formulates the problem as a Linear Complementarity Problem (LCP) or uses a Gauss-Seidel iterative solver.
• Integration: Works in tandem with the forward dynamics calculation to produce physically plausible, constrained motion.