1,701 research outputs found
The Astrophysical Multipurpose Software Environment
We present the open source Astrophysical Multi-purpose Software Environment
(AMUSE, www.amusecode.org), a component library for performing astrophysical
simulations involving different physical domains and scales. It couples
existing codes within a Python framework based on a communication layer using
MPI. The interfaces are standardized for each domain and their implementation
based on MPI guarantees that the whole framework is well-suited for distributed
computation. It includes facilities for unit handling and data storage.
Currently it includes codes for gravitational dynamics, stellar evolution,
hydrodynamics and radiative transfer. Within each domain the interfaces to the
codes are as similar as possible. We describe the design and implementation of
AMUSE, as well as the main components and community codes currently supported
and we discuss the code interactions facilitated by the framework.
Additionally, we demonstrate how AMUSE can be used to resolve complex
astrophysical problems by presenting example applications.Comment: 23 pages, 25 figures, accepted for A&
REBOUND: An open-source multi-purpose N-body code for collisional dynamics
REBOUND is a new multi-purpose N-body code which is freely available under an
open-source license. It was designed for collisional dynamics such as planetary
rings but can also solve the classical N-body problem. It is highly modular and
can be customized easily to work on a wide variety of different problems in
astrophysics and beyond.
REBOUND comes with three symplectic integrators: leap-frog, the symplectic
epicycle integrator (SEI) and a Wisdom-Holman mapping (WH). It supports open,
periodic and shearing-sheet boundary conditions. REBOUND can use a Barnes-Hut
tree to calculate both self-gravity and collisions. These modules are fully
parallelized with MPI as well as OpenMP. The former makes use of a static
domain decomposition and a distributed essential tree. Two new collision
detection modules based on a plane-sweep algorithm are also implemented. The
performance of the plane-sweep algorithm is superior to a tree code for
simulations in which one dimension is much longer than the other two and in
simulations which are quasi-two dimensional with less than one million
particles.
In this work, we discuss the different algorithms implemented in REBOUND, the
philosophy behind the code's structure as well as implementation specific
details of the different modules. We present results of accuracy and scaling
tests which show that the code can run efficiently on both desktop machines and
large computing clusters.Comment: 10 pages, 9 figures, accepted by A&A, source code available at
https://github.com/hannorein/reboun
NBODY6++GPU: Ready for the gravitational million-body problem
Accurate direct -body simulations help to obtain detailed information
about the dynamical evolution of star clusters. They also enable comparisons
with analytical models and Fokker-Planck or Monte-Carlo methods. NBODY6 is a
well-known direct -body code for star clusters, and NBODY6++ is the extended
version designed for large particle number simulations by supercomputers. We
present NBODY6++GPU, an optimized version of NBODY6++ with hybrid
parallelization methods (MPI, GPU, OpenMP, and AVX/SSE) to accelerate large
direct -body simulations, and in particular to solve the million-body
problem. We discuss the new features of the NBODY6++GPU code, benchmarks, as
well as the first results from a simulation of a realistic globular cluster
initially containing a million particles. For million-body simulations,
NBODY6++GPU is times faster than NBODY6 with 320 CPU cores and 32
NVIDIA K20X GPUs. With this computing cluster specification, the simulations of
million-body globular clusters including primordial binaries require
about an hour per half-mass crossing time.Comment: 13 pages, 9 figures, 3 table
Distributed N-body Simulation on the Grid Using Dedicated Hardware
We present performance measurements of direct gravitational N -body
simulation on the grid, with and without specialized (GRAPE-6) hardware. Our
inter-continental virtual organization consists of three sites, one in Tokyo,
one in Philadelphia and one in Amsterdam. We run simulations with up to 196608
particles for a variety of topologies. In many cases, high performance
simulations over the entire planet are dominated by network bandwidth rather
than latency. With this global grid of GRAPEs our calculation time remains
dominated by communication over the entire range of N, which was limited due to
the use of three sites. Increasing the number of particles will result in a
more efficient execution. Based on these timings we construct and calibrate a
model to predict the performance of our simulation on any grid infrastructure
with or without GRAPE. We apply this model to predict the simulation
performance on the Netherlands DAS-3 wide area computer. Equipping the DAS-3
with GRAPE-6Af hardware would achieve break-even between calculation and
communication at a few million particles, resulting in a compute time of just
over ten hours for 1 N -body time unit. Key words: high-performance computing,
grid, N-body simulation, performance modellingComment: (in press) New Astronomy, 24 pages, 5 figure
JETSPIN: a specific-purpose open-source software for simulations of nanofiber electrospinning
We present the open-source computer program JETSPIN, specifically designed to
simulate the electrospinning process of nanofibers. Its capabilities are shown
with proper reference to the underlying model, as well as a description of the
relevant input variables and associated test-case simulations. The various
interactions included in the electrospinning model implemented in JETSPIN are
discussed in detail. The code is designed to exploit different computational
architectures, from single to parallel processor workstations. This paper
provides an overview of JETSPIN, focusing primarily on its structure, parallel
implementations, functionality, performance, and availability.Comment: 22 pages, 11 figures. arXiv admin note: substantial text overlap with
arXiv:1507.0701
Systolic and Hyper-Systolic Algorithms for the Gravitational N-Body Problem, with an Application to Brownian Motion
A systolic algorithm rhythmically computes and passes data through a network
of processors. We investigate the performance of systolic algorithms for
implementing the gravitational N-body problem on distributed-memory computers.
Systolic algorithms minimize memory requirements by distributing the particles
between processors. We show that the performance of systolic routines can be
greatly enhanced by the use of non-blocking communication, which allows
particle coordinates to be communicated at the same time that force
calculations are being carried out. Hyper-systolic algorithms reduce the
communication complexity at the expense of increased memory demands. As an
example of an application requiring large N, we use the systolic algorithm to
carry out direct-summation simulations using 10^6 particles of the Brownian
motion of the supermassive black hole at the center of the Milky Way galaxy. We
predict a 3D random velocity of 0.4 km/s for the black hole.Comment: 33 pages, 10 postscript figure
StePS: A Multi-GPU Cosmological N-body Code for Compactified Simulations
We present the multi-GPU realization of the StePS (Stereographically
Projected Cosmological Simulations) algorithm with MPI-OpenMP-CUDA hybrid
parallelization and nearly ideal scale-out to multiple compute nodes. Our new
zoom-in cosmological direct N-body simulation method simulates the infinite
universe with unprecedented dynamic range for a given amount of memory and, in
contrast to traditional periodic simulations, its fundamental geometry and
topology match observations. By using a spherical geometry instead of periodic
boundary conditions, and gradually decreasing the mass resolution with radius,
our code is capable of running simulations with a few gigaparsecs in diameter
and with a mass resolution of in the center in four days
on three compute nodes with four GTX 1080Ti GPUs in each. The code can also be
used to run extremely fast simulations with reasonable resolution for fitting
cosmological parameters. These simulations are useful for prediction needs of
large surveys. The StePS code is publicly available for the research community
- …