Markus Holzer authored 4 years ago and Dominik Thoennes committed 4 years ago

also clean up some old leftovers nearby

The default target of \file is the current file.

- checking order of integrator
- checking energy conservation
- added semi implicit euler
- improved documentation
- playground for integrator analysis

How could this have been working until now?
We should not call `cudaFree` on uninitialized memory.

We have to free the old pointers before resize. This also prevents
memory leakage in case the vector gets shrinked.

Apparently the previous code relied on the fact that `resize` somehow
initialized the memory to null pointers or that `cudaFree` just ignores
pointers it didn't allocate.

If load balancing changes the neighborhood, caching of receive
buffers can lead to dead locks.

Since MSVC only has beta support for OpenMP 2.0 firstprivate
cannot be used for these compilers. However, firstprivate
is necessary for a reasonably safe implementation of OpenMP
in MESA-PD. The solution is to move OpenMP support to the
generator and disable OpenMP for the checked in version.
The waLBerla OpenMP guards are removed as they are no longer
needed. It is now assumed that if MESA-PD is generated with
OpenMP support it is about to be used. If OpenMP is disabled
with CMake warnings will pop up about undefined pragmas.

staggered boundary generation: direction index should point to fluid cell when inner_or_boundary=False

In that case, the index vector contains the boundary cells, so the direction should point to the fluid cell.
When inner_or_boundary=True, the index vector contains the fluid cells and the direction points to the boundary cell.

274e09cd introduced a skip of the generation if the target file is not
present. While this might hint a wrong target directory it also prevents the
generation of new files. Since the provided mesa_pd.py script asks to
confirm the target directory anyway, this skip is removed.

Added warning if no SIMD instruction could be determined, adapted field layouts in all tests and benchmarks