Software Developments
Current Software Developments
name  license  problem class  programming language  contact  
AutoPas  BSD 2  AutoTuning for NBody Simulations  C++  Fabio Gratl, Steffen Seckler 
 
preCICE  LGPL3  Multiphysics coupling  C++  Benjamin Uekermann 
 
Pond and Actor Library  GPL  ActorBased Tsunami Simulation using UPC++  C++  Alexander Pöppl 
 
SeisSol  BSD  Seismic wave propagation and dynamic rupture simulations  C++, Fortran, Python  Carsten Uphoff, Lukas Krenz, Ravil Dorozhinksii, M.Sc., Sebastian Wolf, M.Sc. 
 
MarDyn  BSDlike  Molecular dynamics simulation (chemical engineering)  C++  Fabio Gratl, Steffen Seckler, Nikola Tchipev 
 
MaMiCo  BSD‑like  Macromicro coupling tool for hybrid molecularcontinuum flow simulations  C++  Philipp Neumann 
 
SG++  BSD‑like  Spatially adaptive Sparse Grid toolbox  C++, Python, Java  Dirk Pflüger, Kilian Röhner, Paul Sarbu 
 
Parallel Module  C++  Paul Sarbu 
 
SWE  GPL  Educationfocused code for tsunami simulation  C++, CUDA  Alexander Breuer 
 
SWEX10  Unreleased  ActorBased Tsunami simulation  X10  Alexander Pöppl 
 
Peano  BSD‑like  PDE solver framework with CFD/Poisson solver/heat equation plugin  C++  Tobias Neckel, Tobias Weinzierl 

Finished Software Developments
name  problem class  programming language  contact  
DaStGen  Data structure generator for scientific datatypes in C++  Java  Wolfgang Eckhardt, Tobias Weinzierl 
 
TifaMMy  TifaMMy isn't the fastest matrix multiplication, yet  C++  Michael Bader, Alexander Heinecke 
 
FITOB  Toolbox for financial contract pricing  C++  Janos Benk, M.Sc  FITOB Webpage  
Sierpinski  Dynamic adaptive mesh refinement on 2D triangular grids with clusterbased parallelization and MPI/OpenMP/TBB support  C++  Martin Schreiber 
 
SToRM  computational steering  C++  Martin Bernreuther  
F3F  numerical fluid dynamics  C  Bernhard Gatzhammer  
quadfluid  numerical fluid dynamics  matlab  Tobias Neckel  
quickfluid  numerical fluid dynamics  matlab  Tobias Neckel  
FSI*ce  multiphysics simulations  C++  Bernhard Gatzhammer  
Nast  numerical fluid dynamics  C++  Miriam Mehl  
NaSt2D/3D  numerical fluid dynamics  C  Michael Bader  
Sparse Grids  sparse grid solvers  C  Stefan Zimmer  
FlowSi  combination method  C  Stefan Zimmer  
ARESO  engineering applications  Java    
Pendulum  BGCE project: selferecting pendulum  Matlab/Simulink/C  Martin Buchholz 
Software Descriptions
AutoPas
AutoPas is an open source library for arbitrary NBody Simulations delivering optimal nodelevel performance through dynamic autotuning. 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 blackbox 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: AutoTuning 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 MPIDatatype
DaStGen is available at www5.in.tum.de/dastgen
MaMiCo
MaMiCo stands for macromicro coupling tool. It is written in C++, supports 2D and 3Dsimulations and can be used to couple meshbased CFD solvers and molecular dynamics (MD) simulations.
MaMiCo was successfully applied to multiresolution fluid dynamics (resolving a part of the computational domain by MD and the rest by the meshbased 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 MolecularContinuum Flow Simulations. Accepted for publication in Computer Physics Communications, 2015
 P. Neumann, W. Eckhardt and H.J. Bungartz. Hybrid MolecularContinuum Methods: From Prototypes to Coupling Software. Computers and Mathematics with Applications 67(2), pp. 272281 (Proceedings of ICMMES 2012), 2014
 P. Neumann and N. Tchipev. A Coupling Tool for Parallel Molecular DynamicsContinuum 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 multiphysics 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 highlevel 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
Peano
Peano is a framework for meshbased 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 hadaptivity
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 MonteCarlo and LSMonteCarlo capabilities.
MarDyn
ls1/MarDyn is used to simulate nanoscale processes (nucleation, multiphase flow, e.g.) with up to a trillion particles (or more) using the NVT or NVE ensemble. Supported molecular potentials are LennardJones, 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 loadbalancing 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, educationoriented 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.
SWEX10
SWEX10 is an actorbased 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,
 welldefined 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 fluidstructure interaction in a valvedriven micro pump. As CFDsolver, 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 NavierStokes 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 matlabGUI
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 FluidStrukturWechselwirkung.
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 NavierStokes 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 matlabGUI
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 NavierStokes equations.
The NavierStokes 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 NavierStokesGleichungen 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 FluxBlending diskretisiert, d.h. es ist eine Mittelung aus zentralen Differenzen und UpwindDifferenzen (DonorCellSchema) 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 BoussinesqApproximation
 Transport chemischer Stoffe
 Freie Randwertprobleme mit dem MarkerundCell Verfahren
Die Eingabe der Parameter erfolgt durch problemspezifische Eingabedateien.
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 (socalled 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
 Poissonlike 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 FiniteElementMethode
ARESO is a divideandconquer approach based on an adaptive, recursive decomposition of technical objects according to the substructure technique. The topdown 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 linkup.
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,
 convectiondiffusion 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 illconditioned 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 illconditioned 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 Peanocurve algorithm for matrix multiplication. It is intended as a student project, and available on http://sourceforge.net/projects/tifammy/.