Time Integrating Articulated Body Dynamics Using Position-Based Collocation Method

TL;DR

This paper introduces a novel position-based, fully implicit time integrator for articulated body dynamics that guarantees stability at large timesteps and is highly parallelizable, outperforming traditional methods in efficiency and stability.

Contribution

The authors reformulate articulated dynamics as an optimization problem using only position variables, enabling stable, large-timestep integration without high-order derivatives and with GPU acceleration.

Findings

Stable integration at timestep sizes up to 0.1s

Up to 4 times speedup on CPU with larger timesteps

Additional 3-6 times speedup with GPU acceleration

Abstract

We present a new time integrator for articulated body dynamics. We formulate the governing equations of the dynamics using only the position variables and recast the position-based articulated dynamics as an optimization problem. Our reformulation allows us to integrate the dynamics in a fully implicit manner without computing high-order derivatives. Therefore, under arbitrarily large timestep sizes, the stability of our time integration scheme is guaranteed using an off-the-shelf numerical optimizer. In addition to stability, we show that, similar to the Runge-Kutta method, the accuracy of our time integrator can also be increased arbitrarily by using a high-order collocation method. We provide efficient algorithms to perform time integration using our position-based formulation. We show that each iteration of optimization has a complexity of O(N) using Quasi-Newton method or O(N^2) using Newton's method, where N is the number of links. Finally, our method is highly parallelizable and can be accelerated using a Graphics Processing Unit (GPU). We highlight the efficiency and stability of our method on different benchmarks and compare the performance with prior articulated body dynamics simulation methods based on the Newton-Euler's equation. Our method is stable under a timestep size as large as 0.1s. Using a larger timestep size and less timesteps, our method achieves up to 4 times speedup on a single-core CPU. With GPU acceleration, we observe an additional 3-6 times speedup over a 4-core CPU.