Hammad Mazhar

Using Nesterov's Method to Accelerate Multibody Dynamics with Friction and Contact

We present a solution method that, compared to the traditional Gauss-Seidel approach, reduces the time required to simulate the dynamics of large systems of rigid bodies interacting through frictional contact by one to two orders of magnitude. Unlike Gauss-Seidel, it can be easily parallelized, which allows for the physics-based simulation of systems with millions of bodies. The proposed accelerated projected gradient descent (APGD) method relies on an approach by Nesterov in which a quadratic optimization problem with conic constraints is solved at each simulation time step to recover the normal and friction forces present in the system. The APGD method is validated against experimental data, compared in terms of speed of convergence and solution time with the Gauss-Seidel and Jacobi methods, and demonstrated in conjunction with snow modeling, bulldozer dynamics, and several benchmark tests that highlight the interplay between the friction and cohesion forces.

Chrono: An Open Source Multi-physics Dynamics Engine

We provide an overview of a multi-physics dynamics engine called Chrono. Its forte is the handling of complex and large dynamic systems containing millions of rigid bodies that interact through frictional contact. Chrono has been recently augmented to support the modeling of fluid-solid interaction (FSI) problems and linear and nonlinear finite element analysis (FEA). We discuss Chrono’s software layout/design and outline some of the modeling and numerical solution techniques at the cornerstone of this dynamics engine. We briefly report on some validation studies that gauge the predictive attribute of the software solution. Chrono is released as open source under a permissive BSD3 license and available for download on GitHub.

Parallel Computing in Multibody System Dynamics: Why, When, and How

This paper addresses three questions related to the use of parallel computing in Multibody Dynamics (MBD) simulation. The “why parallel computing?” question is answered based on the argument that in the upcoming decade parallel computing represents the main source of speed improvement in MBD simulation. The answer to “when is it relevant?” is built around the observation that MBD software users are increasingly interested in multi-physics problems that cross disciplinary boundaries and lead to large sets of equations. The “how?” question is addressed by providing an overview of the state of the art in parallel computing. Emphasis is placed on parallelization approaches and support tools specific to MBD simulation. Three MBD applications are presented where parallel computing has been used to increase problem size and/or reduce time to solution. The paper concludes with a summary of best practices relevant when mapping MBD solutions onto parallel computing hardware.

Investigating Through Simulation the Mobility of Light Tracked Vehicles Operating on Discrete Granular Terrain

This paper presents a computational framework for the physics-based simulation of light vehicles operating on discrete terrain. The focus is on characterizing through simulation the mobility of vehicles that weigh 1000 pounds or less, such as a reconnaissance robot. The terrain is considered to be deformable and is represented as a collection of bodies of arbitrary shape. The modeling stage relies on a novel formulation of the frictional contact problem that requires at each time step of the numerical simulation the solution of an optimization problem. The proposed computational framework, when run on ubiquitous Graphics Processing Unit (GPU) cards, allows the simulation of systems in which the terrain is represented by more than 0.5 million bodies leading to problems with more than one million degrees of freedom. The numerical solution for the equations of motion is tailored to map on the underlying GPU architecture and is parallelized to leverage more than 1500 Scalar Processors available on modern hardware architectures. As a demonstration of this technology, we present the simulation of a light tracked vehicle that negotiates several obstacles whose dimensions are comparable to those of the vehicle. The number of bodies used to represent the vehicle is larger than 100 and the terrain the vehicle operates on is considered to be made up of gravel.

Original article: Parallel collision detection of ellipsoids with applications in large scale multibody dynamics

This contribution describes a parallel approach for determining the collision state of a large collection of ellipsoids. Collision detection is required in granular dynamics simulation where it can combine with a differential variational inequality solver or discrete element method to approximate the time evolution of a collection of rigid bodies interacting through frictional contact. The approach proposed is structured on three levels. At the lowest level, the collision information associated with two colliding ellipsoids is obtained as the solution of a two-variable unconstrained optimization problem for which first and second order sensitivity information is derived analytically. Although this optimization approach suffices to resolve the collision problem between any two arbitrary ellipsoids, a less versatile but more efficient approach precedes it to gauge whether two ellipsoids are actually in contact and require the more costly optimization approach. This intermediate level draws on the analytical solution of a 3rd order polynomial obtained from the characteristic equation of two arbitrary ellipsoids. Finally, this intermediate level is invoked by the outer level only when a 3D spatial binning algorithm indicates that two ellipsoids share the same bin (box) and therefore could potentially collide. This multi-level approach is implemented in parallel and when executed on a ubiquitous Graphics Processing Unit (GPU) card scales linearly and yields a two orders of magnitude speedup over a similar algorithm executed on the Central Processing Unit (CPU). The GPU-based ellipsoid contact detection algorithm yields a 14-fold speedup over a CPU-based sphere contact detection algorithm implemented in the third party open source Bullet Physics Library (BPL). The proposed methodology provides the efficiency demanded by granular dynamics applications, which routinely handle scenarios with millions of collision events.

Solving Large Multibody Dynamics Problems on the GPU

Publisher Summary This chapter describes an approach for the dynamic simulation of large collections of rigid bodies interacting through millions of frictional contacts and bilateral mechanical constraints. The ability to efficiently and accurately simulate the dynamics of rigid multibody systems is relevant in computer-aided engineering design, virtual reality, video games, and computer graphics. Devices composed of rigid bodies interacting through frictional contacts and mechanical joints pose numerical solution challenges because of the discontinuous nature of the motion. Reports indicate that the most popular rigid body software for engineering simulation, which uses an approach based on the so-called “discrete element method,” runs into significant difficulties when handling problems involving thousands of contact events. Another example of commercially available rigid body dynamics software is NVIDIAs PhysX. This software is commonly used in real-time applications where performance is the primary goal. The formulation of the equations of motion, that is, the equations that govern the time evolution of a multibody system, is based on the absolute, or Cartesian, representation of the attitude of each rigid body in the system. The GPU dynamics solver data structures are implemented as large arrays (buffers) to match the execution model associated with NVIDIAs CUDA. Four main buffers used are—the contacts buffer, the constraints buffer, the reduction buffer, and the bodies buffer. The data structure for the contacts has been mapped into columns of four floats.

A Multibody Dynamics-Enabled Mobility Analysis Tool for Military Applications

1 Abstract This paper describes a modeling, simulation, and visualization framework aimed at enabling physicsbased analysis of ground vehicle mobility. This framework, called Chrono, has been built to leverage parallel computing both on distributed and shared memory architectures. Chrono is both modular and extensible. Modularity stems from the design decision to build vertical applications whose goal is to reduce the end-to-end time from vision-to-modelto-solution-to-visualization for a targeted application field. The extensibility is a consequence of the design of the foundation modules, which can be enhanced with new features that benefit all the vertical applications. Two factors motivated the development of Chrono. First, there is a manifest need of modeling approaches and simulation tools to support mobility analysis on deformable terrain. Second, the hardware available today has improved to a point where the amount of sheer computer power, the memory size, and the available software stack (productivity tools and programming languages) support computing on a scale that allows integrating highly accurate vehicle dynamics and physics-based terramechanics models. Although commercial software is available nowadays for simulating vehicle and tire models that operate on paved roads; deformable terrain models that complement the fidelity of present day vehicle and tire models have been lacking due to the complexity of soil behavior. This paper demonstrates Chrono’s ability to handle these difficult mobility situations through several simulations, including: (i) urban operations, (ii) muddy terrain operations, (iii) gravel slope operations, and (iv) river fording.

Chrono: A Parallel Physics Library for Rigid-Body, Flexible-Body, and Fluid Dynamics

This contribution discusses a multi-physics simulation engine, called Chrono, that relies heavily on parallel computing. Chrono aims at simulating the dynamics of systems containing rigid bodies, flexible (compliant) bodies, and fluid-rigid body interaction. To this end, it relies on five modules: equation formulation (modeling), equation solution (simulation), collision detection support, domain decomposition for parallel computing, and post-processing analysis with emphasis on high quality rendering/visualization. For each component we point out how parallel CPU and/or GPU computing have been leveraged to allow for the simulation of applications with millions of degrees of freedom such as rover dynamics on granular terrain, fluid-structure interaction problems, or large-scale flexible body dynamics with friction and contact for applications in polymer analysis.

Using a Granular Dynamics Code to Investigate the Performance of a Helical Anchoring System Design

NASA is interested in designing a spacecraft capable of visiting a Near Earth Object (NEO), performing experiments, and then returning safely. Certain periods of this mission will require the spacecraft to remain stationary relative to the NEO. Due to the low gravity, such situations require an anchoring mechanism that is compact, easy to deploy and upon mission completion, easily removed. In the proposed approach, using Chrono::Engine (Tasora 2008; Negrut, Tasora et al. 2011; SBEL 2011), a simulation package capable of utilizing massively parallel GPU hardware, extensive validation experiments will first be performed. A set of parametric studies will concentrate on the simulation of the anchoring system. The outcome of this effort will be a systematic study that considers several different anchor designs, along with a recommendation on which anchor design is better suited to the task of anchoring. The anchors will be tested against a range of parameters relating to soil, environment and anchor penetration angles/velocities on a NEO to better understand their performance characteristics. SIMULATION CAPABILITY The simulation of very large collections of rigid bodies is prohibitively time consuming if done on sequential processors. Until recently, the high cost of parallel computing limited the analysis of such large systems to a small number of research groups. This is rapidly changing, owing in large part to general-purpose computing on the GPU (GP-GPU). GP-GPU computing has been vigorously promoted by NVIDIA since the release of the CUDA development platform (NVIDIA 2011), an application interface for software development targeted to run on NVIDIA GPUs. A large number of scientific applications have been developed using CUDA, most of them dealing with problems that are quite easily parallelizable such as molecular dynamics or signal processing. Very few GP-GPU projects are concerned though with the dynamics of multibody systems, the two most significant being the Havok (Havok 2011) and the NVIDIA PhysX (NVIDIA 2010) engines. Both are commercial and proprietary libraries used in the video-game industry and their algorithmic details are not public. Typically, these physics engines trade precision for efficiency as the priority is in speed rather than accuracy. In this context, the goal of this effort is to moderately de-emphasize the efficiency attribute and instead implement a free, general-purpose physics based GPU solver for multibody dynamics backed by convergence results that guarantee the accuracy of the numerical solution. Unlike the so-called penalty or regularization methods, where the frictional interaction can be represented by a collection of stiff springs combined with damping

GPU Collision Detection Using Spatial Subdivision With Applications in Contact Dynamics

This work concentrates on the issue of rigid body collision detection, a critical component of any software package employed to approximate the dynamics of multibody systems with frictional contact. This paper presents a scalable collision detection algorithm designed for massively parallel computing architectures. The approach proposed is implemented on a ubiquitous Graphics Processing Unit (GPU) card and shown to achieve a 40x speedup over state-of-the art Central Processing Unit (CPU) implementations when handling multi-million object collision detection. GPUs are composed of many (on the order of hundreds) scalar processors that can simultaneously execute an operation; this strength is leveraged in the proposed algorithm. The approach can detect collisions between five million objects in less than two seconds; with newer GPUs, the capability of detecting collisions between eighty million objects in less than thirty seconds is expected. The proposed methodology is expected to have an impact on a wide range of granular flow dynamics and smoothed particle hydrodynamics applications, e.g. sand, gravel and fluid simulations, where the number of contacts can reach into the hundreds of millions.Copyright