Time Integrating Articulated Body Dynamics Using Position-Based Collocation Method
This work addresses the need for stable and efficient simulation of articulated bodies, such as in robotics or animation, by offering a method that is stable under large timesteps and highly parallelizable, though it appears incremental as it builds on existing optimization and collocation techniques.
The paper tackles the problem of simulating articulated body dynamics by introducing a new time integrator that formulates dynamics using position variables and recasts it as an optimization problem, achieving stability under large timesteps (e.g., 0.1s) and up to 4 times speedup on a single-core CPU, with GPU acceleration providing an additional 3-6 times speedup.
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.