# Software-Entwicklungen

Software is often the main product of our research and in this list you can get an overview of codes developed in the context of our running or completed research projects.

Apart from the software developments listed here, you can also find more project in the LRZ GitLab and on GitHub.

## Actively developed

preCICE is an open-source coupling library for partitioned multi-physics simulations, including, but not restricted to fluid-structure interaction and conjugate heat transfer simulations.

Partitioned means that preCICE couples existing programs/solvers capable of simulating a subpart of the complete physics involved in a simulation. This allows for the high flexibility that is needed to keep a decent time-to-solution for complex multi-physics scenarios.

The software offers convenient methods for transient equation coupling, communication, and data mapping.

- Website: https://precice.org/
- Code: https://github.com/precice/ (main library: C++, LGPLv3)
- Main publications:
- People:
- Currently involved: Gerasimos Chourdakis, Benjamin Rodenberg, Frédéric Simonis, + Univ. Stuttgart (US3 and SGS)
- Previously involved: Bernhard Gatzhammer

- Related student projects: Coupled Problems / Multi-Physics Simulations
- Related software projects: FSI*ce (predecessor, see "archived projects")

ExaHyPE is an engine to solve hyperbolic PDEs given in first-order formulation. With the second generation of this engine, i.e. ExaHyPE 2, the code is shipped as add-on to Peano 4, i.e. the latest Peano version. That means, it is a collection of C++ components plus a set of high-level Python routines which emit a stand-alone, native Peano application in the end.

Peano is an open source framework for solvers on dynamically adaptive Cartesian meshes.

Its core is built with C++, but many tools around it are written in Python. Peano is based upon the fact that spacetrees, a generalisation of the classical octree concept, yield a cascade of adaptive Cartesian grids. Consequently, any spacetree traversal is equivalent to an element-wise traversal of the hierarchy of the adaptive Cartesian grids. The software Peano realises such a grid traversal and storage algorithm, and it provides hook-in points for applications performing per-element, per-vertex, and so forth operations on the grid. It also provides interfaces for dynamic load balancing, sophisticated geometry representations, and other features.

- Website: https://tobiasweinzierl.webspace.durham.ac.uk/software/peano/
- Code: https://gitlab.lrz.de/hpcsoftware/Peano (main library: C++)
- People:
- Currently involved: Mario Wille, Marc Marot-Lassauzaie + Univ. Durham (Tobias Weinzierl)

- Related software projects: ExaHyPE (predecessor)

SeisSol is a software package to simulate physics-based earthquake scenarios at extreme scale.

SeisSol's core purpose is to solve the coupled problem of frictional failure along faults and seismic wave propagation.

We achieve high-order in space and time, by using the ADER-DG method.

The use of tetrahedral elements gives us geometric flexibility, so we are able to model realistic topography and fault geometry.

To achieve high performance on latest computer architectures, we generate highly optimized CPU or GPU code for the heavily-used compute kernels.

Using mesh-partitioning, we can distribute the workload on several compute nodes to compute in parallel.

A crucial ingredient to minimize time-to-solution is a clustered local time-stepping scheme.

SeisSol has been used on numerous of the latest supercomputers, in particular at our home base: SuperMUC-NG at LRZ in Garching.

Ongoing research includes GPU-computing, earthquake-tsunami coupling and more advanced material models.

- Website: https://www.seissol.org
- Code: https://github.com/SeisSol/SeisSol/.
- People: David Schneller, Vikas Kurapati
- Related student projects: Computational Seismology

# Actor-UPCXX

Actor-UPCXX is a high performance computing library based on the actor model to enable the use of the actor model for HPC simulations.

- Code: https://github.com/TUM-I5/Actor-UPCXX (main library: C++, UPC++)
- People:
- Currently involved: Mario Wille, Yakup Budanaz
- Previously involved: Alexander Pöppl, Philipp Samfass

# SWE: An Education-Oriented Code for Parallel Tsunami Simulation

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.

- Website: https://www5.in.tum.de/wiki/index.php/SWE
- Code: https://github.com/TUM-I5/SWE (main library: C++, OpenMP, CUDA)
- People:
- Currently involved: Mario Wille, Marc Marot-Lassauzaie
- Previously involved: Leonhard Rannabauer

## Archived projects

The aim of *FSI*ce* was 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.

SWE-X10 is an actor based implementation of SWE using the Actor-X10 library in the context of invasive computing.

Wait, there is more!