RaiSim

RaiSim is a rigid body simulator developed by researchers at RSL, ETH Zurich (Jemin Hwangbo and Dongho Kang). RaiSim features efficient recursive algorithms for articulated systems as well as the new novel contact solver described in [1]. The goal of RaiSim project is to provide simulation for data-driven robotics and animation research. Since the robotics community needs quality data that reflects the reality, RaiSim is designed for uncompromising accuracy. It is also designed to be nearly tuning-free to ease the pain of manual parameter tuning. All the systems presented here are simulated with the default setup. RaiSim is currently unreleased and only the researchers at RSL, ETH Zurich have an access.

Video

Implementation Details

RaiSim is designed to be nearly tuning-free. In the benchmark tests, we used default solver parameters for most cases except the tests which investigate the behavior of deferent solver parameters. Also, Error Reduction Parameter(ERP) is set to zero for all tests.

The primitive shape objects in the simulations were created by C++ user API while articulated systems were loaded from URDF(The Unified Robot Description Format).

RaiSim has build-in actuator model, but we used direct torque input for PD control simulations.

Bullet Physics

Bullet Physics(Bullet)[2] is an open-source physics engine developed by Erwin Coumans subject to the terms of the zlib license. It features collision detection, rigid and soft body dynamics, multibody dynamics in minimal coordinate representation, inverse kinematics and dynamics so on. It has been one of the most commonly used simulator in computer games, computer graphics and robotics: it is a back-end physics engine of Gazebo and V-REP.

Implementation Details

We used the latest Bullet 2.88 for our benchmark software framework. The recent version of Bullet uses Bullet3 C API as a low-level and supports both python[3] and C++ Bullet3 Robotics API as a user level API while the old version was fully written in C++. We used C++ Bullet3 Robotics API since it performs well in the most situation and is actively maintained.

The latest Bullet only provides Sequential Impulse solver (or Multibody solver) while the old one had many experimental MLCP solvers. We only report result from Sequential Impulse solver in this project.

The simulation scenes were loaded from URDF files for both primitive and multibody objects. Although Bullet can simulate a built-in actuator model, we used direct torque input for PD control simulations.

The parameters and options used for general test cases are as follows:

ODE

Open Dynamics Engine(ODE)[4] is an open-source physics engine that is a default back-end physics engine of Gazebo simulator. It has collision detection, rigid and soft body dynamics features. While its low-level API is supported in C++, user-level API is in C.

Implementation Details

We used the latest 0.15.2 version which was released in June 2017. Although it is still used for many robotics applications, it is not actively maintained anymore.

ODE supports multibody object simulation with joints, but it does not support minimal coordinate representation and has no built-in URDF importer. Thus, we implemented own URDF importer that create multibody objects from URDF script for our benchmark framework.

The parameters and options used for general test cases are as follows:

MuJoCo

MuJoCo stands for Multi-Joint dynamics with Contact.[5] It is the main simulator for continuous control tasks of OpenAI gym. The main features of MuJoCo are collision detection, soft contact dynamics, inverse kinematics/dynamics etc. Notably, it has a stable and efficient multibody system dynamics implementation that enables effective end-to-end training of learning based robot control.

Training of multibody system locomotion using MuJoCo.
The video from Google DeepMind.

Implementation details

We used the latest 1.5.0 version MuJoCo in our software framework. It does not support runtime object creation, rather loads whole simulation scene specified in one URDF or MJCF file at initialization step. We implemented simulation related features by using C API functions or direct access to mjData, mjOption and mjModel that contain simulation data and variables.

MuJoCo uses the soft contact model that optimize to enforce complementarity. Namely, the reality of the simulation is sensitive to solver or contact related parameters. We mostly used default solver parameters, but for the specific tasks where the performance metric is highly related to the parameters, we tuned them; for instance, we set the no-slip parameter to a non-zero value for ANYmal PD control test since the feet of the robot steadily slipped without the parameter lead to more number of contacts.

DART Sim

DART[6] is an open-source physics engine. It's written in modern C++ and provides data structures and algorithms for kinematic and dynamic applications which are useful for robotics applications including minimal coordinate representation, Featherstone algorithm and full acceess full access to the mass matrix, Coriolis and centrifugal forces, Jacobian matrices for arbitrary body points so on.

Implementation Details

We used 6.4.0 version of DART. It supports FCL, Bullet, ODE, and DART collision detection; FCL represent a body as a mesh shape object thus very expensive while others use both primitive and mesh shapes. We tried every collision detector and selected Bullet collision detector since it is the most suitable for our simulation scene that only used primitive-shape collision bodies.

DART supports LCP Dantzig and LCP PGS as contact solvers. Although they work fine for the specific robotic tasks with a small number of contacts with the default parameters, simulation often was blown up or terminated by a bad memory allocation error. The current master branch code does not support user API to tune the solver parameter, so we reported the result with default parameters.

DART has RK4 integrator as an experimental feature, but the current master version does not support changing integrator. The benchmark results reported in this project were from Semi-implicit Euler integrator.

Implementation Note

What is ERP and CFM?[7]

ERP

ERP stands for Error Reduction Parameter that fixes position error after one simulation step and RaiSim, ODE and Bullet have ERP. As ERP is set to a non-zero value, simulation attempts to fix the position drift by applying additional force. This prevents position-level drift: as ERP set to non-zero value, the penetration error is significantly reduced as the following figure.

Box stacking simulation on Bullet Physics. ERP(left) vs no ERP(right)

However, we set the ERP to zero for most cases since the error correction algorithms are not based on physics and may lead to unrealistic simulation result. Also, as we focused on the numerical solution from the constraint solver itself, not post-process, thus there is no mean of using it in the benchmark tests. Finally, the ERP forces to hold constraints by adding artificial force, the system does not preserve energy or momentum which leads to undesirable simulation result.

CFM

CFM is the abbreviation of Constraint Force Mixing. If the CFM set to a positive value, the hard-contact constraint is softened which means that the constraint is allowed to be violated. This helps simulation to be more stable but not causes unrealistic result such as penetration and position drift. Thus, in our benchmark tests, CFM value was always set to zero.

References

  1. J. Hwangbo, J. Lee, and M. Hutter, "Per-Contact Iteration Method for Solving Contact Dynamics," IEEE Robotics and Automation Letters (2018).
  2. E. Coumans, "Bullet physics library," Open source: bulletphysics.org (2013).
  3. E. Coumans, and Y. Bai, "PyBullet, a Python module for physics simulation for games, robotics and machine learning," Open source: pybllet.org (2013).
  4. www.ode.org
  5. www.mujoco.org
  6. Lee et al., "DART: Dynamic Animation and Robotics Toolkit," Journal of Open Source Software (2018).
  7. http://bulletphysics.org/mediawiki-1.5.8/index.php/Definitions