Coulomb Friction

The model defines two distinct regimes. Static friction acts when surfaces are at relative rest, opposing any applied tangential force up to a maximum threshold. Kinetic (or dynamic) friction acts when sliding occurs, providing a constant opposing force. The maximum static friction force is typically greater than the kinetic friction force, explaining the initial 'stickiness' before motion begins.

• Static Friction Force: (F_s \leq \mu_s F_n)
• Kinetic Friction Force: (F_k = \mu_k F_n) Where (F_n) is the normal force, (\mu_s) is the static friction coefficient, and (\mu_k) is the kinetic friction coefficient.

A key, often counter-intuitive, postulate of the Coulomb model is that the magnitude of the friction force is independent of the apparent or macroscopic area of contact between the two surfaces. The force depends only on the normal force and the material-dependent friction coefficient. This arises from the model's assumption that friction results from the shearing of microscopic asperities; the real contact area is proportional to the normal force, not the geometric area. This simplification is crucial for efficient simulation but breaks down for very soft materials or extremely smooth surfaces.

Coulomb's law is geometrically represented by the friction cone. At a contact point, the total contact force (normal + friction) must lie within or on a cone whose axis is aligned with the contact normal. The half-angle of this cone is (\theta = \arctan(\mu)), where (\mu) is the relevant friction coefficient. This visualization is critical in robotics for grasp stability analysis and motion planning, as it defines the set of all possible reaction forces a contact can provide to resist slippage.

The model's core equation states that the maximum friction force is directly proportional to the normal force pressing the surfaces together: (F_{friction}^{max} = \mu F_{normal}). This linear relationship is a first-order approximation that holds reasonably well for many common material pairs under moderate loads. It simplifies the calculation of frictional effects in multi-body dynamics, as the normal force is typically computed by the constraint solver during collision resolution.

The friction force vector always acts in the direction opposite to the relative motion or impending motion at the contact interface. For kinetic friction, this is directly opposed to the current sliding velocity. For static friction, it opposes the net applied tangential force that is trying to initiate motion. This directional property is essential for generating realistic damping and energy dissipation in simulations, as it ensures friction always acts as a non-conservative, dissipative force.

While foundational, the classical Coulomb model has known limitations that simulation engines must address:

• Stiction Discontinuity: The instantaneous switch from static to kinetic friction at the threshold creates a non-smooth, discontinuous system, challenging for numerical integrators.
• No Velocity Dependence: It does not account for the slight decrease in friction with increasing sliding velocity (Stribeck effect) observed in lubricated contacts.
• Numerical Solvers: In physics engines, Coulomb friction is typically formulated as a Linear Complementarity Problem (LCP) or similar constraint, solved iteratively each time step to find feasible friction forces that satisfy the 'stick-or-slip' conditions without generating energy.

Coulomb friction is a classical dry friction model defining two distinct regimes:

• Static Friction: The maximum force that must be overcome to initiate sliding, proportional to the normal force: F_static_max = μ_s * N.
• Kinetic Friction: A constant opposing force during sliding motion: F_kinetic = μ_k * N. The model's key assumptions are that friction is independent of apparent contact area and velocity magnitude (for kinetic friction). The coefficients μ_s (static) and μ_k (kinetic) are material properties, with μ_s typically ≥ μ_k.

In simulation engines like MuJoCo, Bullet, or Isaac Sim, Coulomb friction is approximated within the constraint solver. Each contact point is modeled with a friction cone—a geometric representation of allowable tangential forces. The solver (often via a Linear Complementarity Problem) finds forces that:

• Prevent inter-penetration (normal force).
• Satisfy |F_tangent| ≤ μ * F_normal.
• Apply the stiction transition logic, where the solver determines if the contact is sticking (static) or sliding (kinetic). This is computationally intensive and a key factor in simulation step time.

Inaccurate friction modeling is a primary source of the reality gap. Key challenges include:

• Parameter Identification: Real-world μ_s and μ_k are difficult to measure and are environment-dependent (e.g., dust, moisture).
• Surface Geometry: Real surfaces are rough, violating the model's assumption of uniform pressure.
• Velocity Dependence: Real kinetic friction often has a slight negative viscous slope (Stribeck effect), not captured by the basic model. Policies trained with incorrect friction can fail catastrophically on real hardware, e.g., a gripper dropping objects or a robot leg slipping.

To create policies robust to friction uncertainty, Domain Randomization is applied:

• Parameter Randomization: The friction coefficients (μ_s, μ_k) are sampled from a plausible range (e.g., 0.3 to 1.2) during each training episode.
• Randomized Surface Properties: Different friction values can be assigned to different floor tiles or object surfaces in the sim.
• Asymmetric Randomization: Sampling μ_s and μ_k independently to cover a wider space of material behaviors. This forces the reinforcement learning policy to learn a generalized strategy that does not overfit to one specific friction value.

For higher-fidelity simulation, engines implement extensions to the basic Coulomb model:

• Pyramid Approximation: The friction cone is approximated as a pyramid for simpler linear constraint solving.
• Regularized Friction: A small velocity-dependent term is added to avoid the numerical discontinuity at zero velocity, improving solver stability.
• Anisotropic Friction: Different coefficients for two orthogonal tangential directions (e.g., like a tire or a ski).
• Stribeck Effect: Modeling the velocity-dependent transition from static to kinetic friction. These are used in high-precision digital twins for control system validation.

Grasping & Manipulation:

• Friction determines if a gripper can hold an object against gravity. Policies must learn to apply sufficient normal force.

Legged Locomotion:

• Friction between a robot's foot and the ground dictates maximum push-off force and lateral stability. A policy trained with high sim friction may cause a real robot to slip and fall on a low-friction surface.

Push-Recovery Controllers:

• Algorithms that regain balance after a shove rely critically on accurate friction cone constraints to compute feasible recovery steps.

The contact force is the resultant force generated at the interface between two simulated rigid bodies upon collision or sustained touch. It is decomposed into two orthogonal components:

• Normal Force: Acts perpendicular to the contact surface, preventing inter-penetration.
• Tangential Friction Force: Acts parallel to the contact surface, resisting sliding motion, and is governed by models like Coulomb friction. This decomposition is fundamental for physics engines, separating the enforcement of non-penetration from the simulation of frictional effects.

A friction cone is the geometric representation of all allowable friction forces at a contact point, as defined by Coulomb's law. It is a cone whose:

• Axis is aligned with the contact normal force.
• Angle is defined by the arctangent of the friction coefficient (μ). For static friction, the resultant tangential force vector must lie within this cone. If a required force lies on the cone's surface, sliding is impending; if outside, kinetic friction applies. Solvers use this concept to formulate friction constraints as a Linear Complementarity Problem (LCP).

A Linear Complementarity Problem is a core mathematical formulation used in rigid-body physics engines to model contact and friction. It solves for unknown forces (λ) and relative velocities (v) that satisfy three conditions simultaneously:

1. Non-penetration: v ≥ 0 (bodies separate or are at rest).
2. Non-adhesion: λ ≥ 0 (contact forces are repulsive, not attractive).
3. Complementarity: vᵀλ = 0 (either the separation velocity OR the force is zero). For friction, the friction cone is often approximated as a polyhedral pyramid to fit the LCP framework, allowing solvers to compute stick-slip transitions deterministically.

The constraint solver is the algorithmic core of a physics engine that iteratively calculates the forces or impulses needed to satisfy all contact constraints and joint constraints within a single simulation time step. For contact, it must resolve:

• Non-penetration (normal forces).
• Friction (tangential forces, using the Coulomb model).
• Restitution (bounciness). Modern solvers use methods like Sequential Impulse or Projected Gauss-Seidel to approximate the solution to the large, coupled system defined by the LCP. Warm starting from the previous frame's solution is critical for stability and performance.

Impulse-based dynamics is a simulation method that resolves collisions and constraints by applying instantaneous changes in velocity (impulses) rather than computing continuous forces over time. An impulse (J) applied at a contact point changes the linear and angular velocity of bodies according to: Δv = M⁻¹ * J where M⁻¹ is the effective mass at the contact. The solver calculates the correct impulse to satisfy the Coulomb friction model and prevent penetration. This method is computationally efficient and widely used in real-time interactive simulations and games, though it can struggle with persistent contact stacks.

The coefficient of restitution is a dimensionless scalar (typically between 0 and 1) that characterizes the elasticity of a collision. Defined as the ratio of the relative separation velocity to the relative approach velocity perpendicular to the contact surface: COR = - (v_separation_normal / v_approach_normal)

• COR = 1: Perfectly elastic collision (no energy loss).
• COR = 0: Perfectly inelastic collision (objects stick together). In simulation, the COR is used alongside the Coulomb friction model to compute the final contact impulse. It models energy loss due to factors like plastic deformation, which is distinct from energy dissipated by friction.