Current Software Developments

AutoPas is an open source library for arbitrary N-Body Simulations delivering optimal node-level performance through dynamic auto-tuning. It is written in C++ and build through CMake. The library provides a collection of particle containers (= neighbor search algorithms), traversals thereof (= parallelization patterns),and further optimization options but can be used as a black-box particle container. The user can define its own particles and forces for the library to use.

During the simulation, AutoPas chooses the optimal configuration of its internal options. This configuration is reevaluated again and again to adapt to changing sceanrios and sustain optimal performance.

For further information see: Gratl, F., Seckler, S., Tchipev, N., Bungartz, H. J., & Neumann, P. (2019). AutoPas: Auto-Tuning for Particle Simulations. In 2019 IEEE International Parallel and Distributed Processing Symposium (IPDPS).

AutoPas is available here: https://github.com/AutoPas/AutoPas

DaStGen

DaStGen is a data structure generator, designed and written by Wolfgang Eckhardt and Tobias Weinzierl in 2007. DaStGen reads a record specification and creates corresponding C++ types. Its most prominent features are:

Packs different data types, i.e. if two bools are assigned to one record, these two records are stored within one integer. DaStGen is able to back the types enum, integer, bool and double.
Creates corresponding setter and getter oerations, along with other utility funcions like toString().
Automatic generation of a derived MPI-Datatype

DaStGen is available at www5.in.tum.de/dastgen

MaMiCo

MaMiCo stands for macro-micro coupling tool. It is written in C++, supports 2D- and 3D-simulations and can be used to couple mesh-based CFD solvers and molecular dynamics (MD) simulations.

MaMiCo was successfully applied to multi-resolution fluid dynamics (resolving a part of the computational domain by MD and the rest by the mesh-based CFD solver), interfacing

the Lattice Boltzmann frameworks waLBerla, OpenLB, Palabos, PeanoLB (the latter being a spatially adaptive LB component of the Peano framework)
the MD solvers ls1 MarDyn, LAMMPS, ESPResSo, SimpleMD (the latter being a simple test code that comes along with MaMiCo).

For details on the software and its design, see amongst others:

P. Neumann, H. Flohr, R. Arora, P. Jarmatz, N. Tchipev and H.-J. Bungartz. MaMiCo: Software Design for Parallel Molecular-Continuum Flow Simulations. Accepted for publication in Computer Physics Communications, 2015
P. Neumann, W. Eckhardt and H.-J. Bungartz. Hybrid Molecular-Continuum Methods: From Prototypes to Coupling Software. Computers and Mathematics with Applications 67(2), pp. 272-281 (Proceedings of ICMMES 2012), 2014
P. Neumann and N. Tchipev. A Coupling Tool for Parallel Molecular Dynamics-Continuum Simulations. Proceedings of the 11th International Symposium on Parallel and Distributed Computing (ISPDC 2012), Munich. 2012
P. Neumann. Hybrid Multiscale Simulation Approaches for Micro- and Nanoflows. PhD thesis, Dr. Hut, 2013

To download the software, visit http://www5.in.tum.de/mamico.

preCICE

preCICE (Precise Code Interaction Coupling Environment) is a coupling tool for partitioned simulations of multi-physics scenarios. Partitioned means, that existing programs capable of simulating a subpart of the complete physics involved in the complete simulation, are taken and coupled together. The conceptual ideas of preCICE are not completely new, preCICE is basically an advancement of FSI*ce which has been developed by Markus Brenk.

The main goals of preCICE are the following:

Provide a high-level programming environment for all basic tasks appearing in the development of partitioned coupling simulation tools, i.e. communication, data mapping, and transient coupling schemes.
Exploit the flexibility coming with the partitioned approach.
Serve as a basis for the development of new coupling algortihms, methodologies and functionalities.
Run efficiently on massively parallel systems

preCICE webpage GitHub

Peano

Peano is a framework for mesh-based PDE solvers. Among Peano's highlights are the support of

Arbitrary dimensions
Multiscale solvers and models
Parallel on distributed memory and multicores
Low memory demands
High cache efficiency
Dynamic h-adaptivity

There's a couple of plugins for this framework available with a sophisticated fluid solver being perhaps the most prominent one. We are right now discussing the legal status of the source code. Afterwards, Peano will be available here. Peano is available at www5.in.tum.de/peano

SG++

SG++ is a toolbox that allows to use spatially adaptive Sparse Grids for different types of applications and from within different programming languages.

Main code & documentation is available at www5.in.tum.de/SGpp.

The parallel module can be downloaded separately here and integrated in the main code by following the instructions in the module's README.

FITOB

FITOB(Financial Toolbox) is a toolbox for financial product pricing. Its main focus is on PDE and combination technique based pricing methods, but it also contains Monte-Carlo and LS-Monte-Carlo capabilities.

FITOB Webpage

MarDyn

ls1/MarDyn is used to simulate nanoscale processes (nucleation, multi-phase flow, e.g.) with up to a trillion particles (or more) using the NVT or NVE ensemble. Supported molecular potentials are Lennard-Jones, dipoles, and quadrupoles. Currently, internal degrees of freedom are not supported. The program is parallelised and optimised for heterogeneous particle distributions and thus comprises a dynamic load-balancing which was evaluated for up to several thousand processes. Besides, the simulation is vectorised using intrinsics wrappers. For download and more information, see here.

SWE

SWE is a simple, education-oriented code to solve the shallow water equations, as used for tsunami simulation. SWE features a modular design that support parallelisation with different programming paradigms (MPI, OpenMP, CUDA, ...) including hybrid parallelisation.

All further information is available on the SWE Website.

SWE-X10

SWE-X10 is an actor-based tsunami simulation based on the finite volume scheme of SWE Website. Further Information may be found in the paper. For access to the code, please contact Alexander Pöppl.

Pond and Actor Library

Pond is a proxy application based on SWE and an actor library. They use the UPC++ PGAS library for realization of shared- and distributed memory paralleization. The code is available on BitBucket

FSI*ce

The aim of FSI*ce is the development of a modular simulation environment for a class of coupled problems as large as possible. The modular approach means here that the modelling as well as the programming effort shall be highly reduced by the use of already available program codes. This leads to a great flexibility regarding the treated problems as well as the used codes. In addition, a structuring is given, which e. g. simplifies the distributed computation of the system.

For that purpose , FSI*ce includes:

a "coupling language" for a specification of the coupling,
efficient iteration methods,
well-defined interfaces between the control modul and each of the involved simulation codes,
conversion moduls between the different data representations,
a general description of the geometry with adaptation possibilities to the used programms, e. g. for the connection to CAD systems,
modules for the realization and synchronisation of the data transport.

First investigations were made on the basis of the two- and threedimensional simulation of the fluid-structure interaction in a valve-driven micro pump. As CFD-solver, we used #F3F, which was developed at the chair, as structure solver, we used ADINA, NASTRAN and AdHoc, which was developed at the chair for Computing in Engineering.

F3F

description coming soon

quadfluid

Matlab package for the numerical simulation of 2D laminar, incompressible fluid flow on adaptive grids

quadfluid solves the unsteady Navier-Stokes equations in two dimension on adaptive Cartesian grids (quadtree) as a testbed for mathematical and physical methods in the context of flow simulation.

Based on the Chorin projection method, the time discretisation of the momentum equations is done by an explicit Euler method. The discretisation of the space is realised by bilinear elements for the velocities using constant pressure per cell as the corresponding Lagrangeian multiplier for the continuity constraint. In each time step, thus, a linear system of equations (the discrete pressure poisson equation) is solved whose solution is used to update the velocities for the next time step. For the calculation of force values (on obstacles, e.g.), the method of consistent forces is used. Special care (interpolation etc.) is applied whenever coarser and finer grid cells touch each other.

Screenshot of the matlab-GUI

Via the use of obstacle node lists, arbitrary geometries can be used in a rectangular domain. Built in scenarios are e.g. driven cavity, free channel flow, cylinder channel benchmarks, and the CFD1 benchmark of the Forschergruppe 493 zur Fluid-Struktur-Wechselwirkung.

This is an extension of the version for regular grids: quickfluid.

The program package comes with an easy to use visualisation GUI called quadvis.

A version of this matlab package is available by contacting Tobias Neckel

quickfluid

Matlab package for the numerical simulation of 2D laminar, incompressible fluid flow

quickfluid solves the unsteady Navier-Stokes equations in two dimension on (regular) Cartesian grids as a testbed for mathematical and physical methods in the context of flow simulation.

Based on the Chorin projection method, the time discretisation of the momentum equations is done by an explicit Euler method. The discretisation of the space is realised by bilinear elements for the velocities using constant pressure per cell as the corresponding Lagrangeian multiplier for the continuity constraint. In each time step, thus, a linear system of equations (the discrete pressure poisson equation) is solved whose solution is used to update the velocities for the next time step. For the calculation of force values (on obstacles, e.g.), the method of consistent forces is used.

Screenshot of the matlab-GUI

Via the use of obstacle node lists, arbitrary geometries can be used in a rectangular domain. Built in scenarios are e.g. driven cavity, free channel flow, and cylinder channel benchmarks.

An extension to adaptive cartesian grids exists and is named quadfluid.

The program package comes with an easy to use visualisation GUI called quickvis.

A GNU GPL version of this matlab package is available by contacting Tobias Neckel

Nast

The task of Nast++ is the simulation of instationary laminar flows of incompressible fluids in two and three dimensions. The underlying mathematical model are the Navier-Stokes equations.

The Navier-Stokes equations are discretised via finite differences on a staggered grid. Using a projection method, we get a Poisson equation for the pressure. The resulting pressure field is used to guaranty the mass conservation property of the method.

NaSt2D/3D

Programm zur numerischen Simulation laminarer Strömungen viskoser, inkompressibler Fluide in zwei und drei Raumdimensionen.

Das Programm Nast sowie die zugrunde liegenden numerischen Verfahren sind beschrieben in:

Michael Griebel, Thomas Dornseifer, Tilman Neunhoeffer:

 Numerische Simulation in der Strömungsmechanik - eine praxisorientierte 
 Einführung, Vieweg, 1995.

NaSt2D/NaSt3D behandelt die instationären Navier-Stokes-Gleichungen in zwei bzw. drei Raumdimensionen. Grundlage ist die Chorinsche Projektionsmethode. Die Zeitdiskretisierung der Impulsgleichungen erfolgt durch ein explizites Eulerverfahren. Der Ortsdiskretisierung liegt ein finites Differenzenverfahren auf einem versetzten äquidistanten Gitter zugrunde. Die konvektiven Terme der Impulsgleichung werden durch Flux-Blending diskretisiert, d.h. es ist eine Mittelung aus zentralen Differenzen und Upwind-Differenzen (Donor-Cell-Schema) möglich. Durch Flagfelder können beliebige Gebiete des rechteckigen Grundgebietes ausgeblendet werden, so daß auch stark zerklüftete Strömungsgebiete behandelt werden können.

Es können folgende Problemklassen behandelt werden:

Strömungen in festen Geometrien
Energietransport
Temperaturgetriebene Strömungen mittels Boussinesq-Approximation
Transport chemischer Stoffe
Freie Randwertprobleme mit dem Marker-und-Cell Verfahren

Die Eingabe der Parameter erfolgt durch problemspezifische Eingabedateien.

Einige Simulationsbeispiele

Sparse Grids

A powerfull tool for the solution of elliptic partial differential equations is the concept of hierarchical bases: they allow for a simple construction of adaptive grids and lead to a much faster convergence of iterative solvers. If, in addition, hierarchical grids with different aspect ratios (so-called Sparse Grids) are used, the complexity that is the dimension of the solution space can be reduced substantially without accuracy losses.

Two standard examples for Sparse Grids in 2D and 3D:

The software can be applied to 2D and 3D scenarios and allows for adaptive refinements and higher order discretisation schemes.

FlowSi

The combination method leads to solutions on Sparse Grids. It's a special case of a multivariate extrapolation scheme. The computations are performed distributedly on the single grids involved in the combination process.

The combination method can be seen as an enhancement of existing algorithms. Such, existing codes canbe reused. The method can be parallelised in a trivial way. In the existing version, a process parallel approach was chosen. The storage requirements reduse to O(N) in comparison to O(N^3) for previous approaches on full grids with similar accuracy (N is the number of grid points per coordinate direction).

The method is implemented for

Poisson-like problems on the unit square/cube
laminar flow scenarios in simple and complex geometries
turbulent flow scenarios (via DNS) in simple geometries.

ARESO

Programm zur parallelen, adaptiven numerischen Simulation mit Hilfe der Finite-Element-Methode

ARESO is a divide-and-conquer approach based on an adaptive, recursive decomposition of technical objects according to the substructure technique. The top-down decomposition allows for the distribution of data and for the parallelisation on a heterogeneous workstation network.

ARESO can be used for general engineering problems and supports the teamwork of engineers in the numerical simulation of technical objects. Existing routines or codes can be used for the computation on subdomains as ARESO offers interfaces for their link-up.

In the algorithm, direct as well as iterative solvers based on mathematical methods such as hierarchical bases, adaptive relaxation are implemented. The solvers work highly memory efficient on the basis of the Jacobi and the conjugate gradient method. Also the combined usage of the methods - direct solvers for small subdomain, iterative solvers for large ones - is possible.

The following problem classes can be handled:

stationary heat equation,
linear planar elasticity,
convection-diffusion scenarios.

The current version of the code is written in Java. Thereby, the upper coordination layer in the functional language FASAN offers a highly flexible possibiliy for parallelisation and distribution and is translated into Java as well by the FASAN compiler. Existing, mostly written in C or FORTRAN, programs can be integrated via the Java Native Interface (JNI) into ARESO.

MSPAI

MSPAI is a preconditioner for large sparse and ill-conditioned systems of
linear equations. We extended the basic SPAI minimization

to target form and further generalized it in order to add additional probing constraints:

For an overview of the versatile employment possibilities of our MSPAI formulation,
see MSPAI and this pdf taken from here.

FSPAI

FSPAI is a preconditioner for large sparse and ill-conditioned symmetric positive
definite systems of linear equations. It is the factorized version of the SPAI
algorithm. FSPAI is inherently parallel and generates a preconditioner which
approximates the inverse of the Cholesky factor of the system matrix, i.e.,

Based on an initial chosen sparsity structure, FSPAI automatically updates its
sparsity structure and improves on a current approximation. See the FSPAI webpage.

TifaMMy

TifaMMy (TifaMMy isn't the fastest matrix multiplication, yet) is an implementation of the Peano-curve algorithm for matrix multiplication. It is intended as a student project, and available on http://sourceforge.net/projects/tifammy/.

Software Developments

Contents