Create quickstart tutorial: rotating rigid body in a channel flow

[uekerman]

For the new docs, we need a simple, yet interesting enough first testcase. Simple means minimal dependencies, easy to run, easy to understand the physics. Interesting means close to real solvers, sth moving etc.

A good candidate could be an FSI coupling between OpenFOAM and a C++ rigid body solver. The following could work:

The tutorial could go to FSI/rigid_flap/OpenFOAM-RigidBody.

Setup:

• The channel flow uses OpenFOAM.
• A rigid beam is fixed at a rotation point and therefore only has one degree of freedom: the deflection angle.
• The flow is instationary and laminar, a similar regime as the Turek and Hron FSI3 for example. We should get an oscillatory movement of the rigid beam (at least no convergence to a steady state). If necessary we could vertically dislocate the beam (similarly to the Turek and Hron benchmarks)
• The beam should be 2D, we want to use the 2D-3D mapping within OpenFOAM (the preCICE dimension is 2).
• The angle should get big enough to be easily visible, but still small enough to give a robust mesh movement.
• The added-mass effect should be large such that implicit coupling and IQN is necessary. Let's use a serial coupling.
• Let's call the participants Fluid and Solid.

Rigid body solver:

• I do not recommend to start from the existing 6dof solver, but from scratch.
• It should be one C++ file only, directly hosted in the tutorial. Building with cmake.
• The code should be C++-14 using smart pointers and vectors. No external dependencies (beyond the std libs).
• We don't need a configuration file. All options can be hard-coded variables.
• Options are the width and height of the beam and the number of boundary vertices along the width and height. Moreover, the mass of the beam. This is probably the best way to fine-tune the added-mass effect in the end.
• The read data are forces, the write data displacements.
• From the forces, the total angular momentum can be computed and from there the angular acceleration, the angular velocity and then the angle itself. The beam should have inertia. First order time integration is enough. We should document these formulas directly in the quickstart.
• The code should be short and readable. The internal physics could be separated from the coupling in a separate function. But otherwise, no extensive software engineering should be used. Basically one main + one or two separate functions.
• Mesh connectivity should be defined. We could then use two nearest projection mappings.
• For visualization we can directly use the preCICE export. The beam code does not need an own visualization. It's enough to write the angle, the angular velocity, and the angular acceleration to the screen.
• A watchpoint could track the end of the beam. Let's also provide a gnuplot script to visualize the watchpoint.

[MakisH]

I created an issue for the missing part in the OpenFOAM adapter: https://github.com/precice/openfoam-adapter/issues/146

As we already discussed, I completely agree with the described idea.

[davidscn]

Somehow this way?

The Fluid mesh is very coarse, so, still some resolution possible.

[MakisH]

Looks very good to me! How long does it take to simulate? We don't need anything fine, just something that run in <1-2min on a laptop.

[davidscn]

On my laptop, it currently needs around 4.5 min. We could decrease the total run time from currently 5s to maybe 2.5s, where the quasi-stationary state is already reached. Maybe I can tune the case still a bit.

[davidscn]

Closed via #123