diff --git a/quickstart/README.md b/quickstart/README.md
index 0575badf0..b32b28ce9 100644
--- a/quickstart/README.md
+++ b/quickstart/README.md
@@ -2,7 +2,7 @@
title: Quickstart
permalink: quickstart.html
keywords: tutorial, quickstart
-summary: "Install preCICE on Linux (e.g. via a Debian package), and then couple two OpenFOAM solvers with the OpenFOAM-preCICE adapter."
+summary: "Install preCICE on Linux (e.g. via a Debian package) and couple an OpenFOAM fluid solver (using the OpenFOAM-preCICE adapter) with an example rigid body solver in C++."
layout: "page"
comments: false
search: true
@@ -16,16 +16,16 @@ toc: false
## Start here
1. To get a feeling what preCICE does, watch a [short presentation](https://www.youtube.com/watch?v=FCv2FNUvKA8), a [longer training session](https://www.youtube.com/watch?v=FCv2FNUvKA8), or [click through a tutorial in your browser](http://run.precice.org/).
-2. Get and install preCICE. For Linux systems, this is pretty easy. Just pick what suits you best on [this overview page](installation-overview.html). Facing any problems? [Ask for help](community-channels.html).
+2. Get and install preCICE. For Linux systems, this is pretty easy, for macOS and Windows still possible with a bit more effort. Just pick what suits you best on [this overview page](installation-overview.html). Facing any problems? [Ask for help](community-channels.html).
- For example, [download](https://github.com/precice/precice/releases/latest) and install our binary package for Ubuntu 20.04 (Focal Fossa) by clicking on it or using the following commands:
```shell
- wget https://github.com/precice/precice/releases/download/v2.1.1/libprecice2_2.1.1_focal.deb
- sudo apt install ./libprecice2_2.1.1_focal.deb
+ wget https://github.com/precice/precice/releases/download/v2.2.0/libprecice2_2.2.0_focal.deb
+ sudo apt install ./libprecice2_2.2.0_focal.deb
```
-3. Build and couple two [C++ solverdummies](https://github.com/precice/precice/tree/master/examples/solverdummies/cpp).
-4. You probably want to couple a solver you are already using, such as OpenFOAM. Since many of our tutorials use it, [install OpenFOAM](adapter-openfoam-support.html).
-5. Download and install the [OpenFOAM-preCICE adapter](adapter-openfoam-get.html).
-6. [Couple OpenFOAM with OpenFOAM](https://github.com/precice/openfoam-adapter/wiki/Tutorial-for-CHT:-Flow-over-a-heated-plate). This testcase is part of the OpenFOAM adapter.
+ - If you prefer to try everything in an isolated environment, you may prefer using our [demo virtual machine](installation-vm.html).
+3. We will use OpenFOAM here and in many of our tutorial cases, so [install OpenFOAM](adapter-openfoam-support.html) (most compatible version: latest ESI/OpenFOAM.com).
+4. Download and install the [OpenFOAM-preCICE adapter](adapter-openfoam-get.html).
+5. Couple OpenFOAM with a C++ rigid body solver. [Find the case in our tutorials](https://github.com/precice/tutorials/quickstart) and keep reading. You can either `git clone` the [tutorials repository](https://github.com/precice/tutorials), or [directly download the current state](https://github.com/precice/tutorials/archive/master.zip).
## What's next?
@@ -33,11 +33,34 @@ To become a preCICE pro:
* Get an overview of the [preCICE docs](docs.html).
* See what users talk about in the [preCICE forum](https://precice.discourse.group/).
-* Run [tutorials with other coupled solvers](https://github.com/precice/precice/wiki#2-getting-started---tutorials).
-* Watch some [preCICE videos](https://www.youtube.com/channel/UCxZdSQdmDrheEqxq8g48t6A).
-* Register to our [virtual preCICE Workshop 2021](precice-workshop-2021.html).
+* Run [tutorials with other coupled solvers](tutorials.html).
+* Watch some [preCICE videos](https://www.youtube.com/c/preCICECoupling/).
+* Meet our [community](community.html).
* Find out how to [couple your own solver](couple-your-code-overview.html).
* Tell us [your story](community-projects.html).
-{% include important.html content="We are currently working on a really nice getting started page. Till then, we hope these tips already help." %}
+## About the case
+
+This tutorial deals with a fluid-structure interaction problem. The fluid part of the simulation is computed using OpenFOAM and the rigid body motion is a rigid body model (implemented in C++) with only a single degree of freedom, namely the deflection angle of the flap in the channel. The rigid body is fixed in the origin at (0,0) and the force exerted by the fluid on the rigid body structure causes an oscillatory rotation of the body. The simulation runs for 2.5 seconds. In order to gain more control over the rigid body oscillation, a rotational spring is applied at the rigid body origin. After 1.5 seconds we increase the spring constant by a factor of 8 to stabilize the coupled problem. Feel free to modify these parameters (directly in `rigid_body_solver.cpp`) and increase the simulation time (in `precice-config.xml`).
+
+
+
+### Building the rigid body solver
+Before starting the coupled simulation, the rigid body solver needs to be built using CMake. You can run the following commands from this directory to build the `rigid_body_solver.cpp`
+```
+cd solid-cpp && cmake . && make
+```
+
+### Running the coupled simulation
+
+You may run the two simulations in two different terminals and watch their output on the screen using the `run.sh` scripts (or `run.sh -parallel`, option only available for OpenFOAM) located in each participant directory. You can cleanup the simulation using `clean.sh`.
+
+
+In serial, the simulation takes roughly 30 seconds to compute.
+
+### Visualizing the results
+
+You can visualize the simulation results of the `Fluid` participant using ParaView (use `paraFoam` to trigger the OpenFOAM native reader or load the (empty) file `Fluid.foam` into ParaView). The rigid body doesn't generate any readable output files, but the motion can be observed in the OpenFOAM data. In addition, one could visualize the coupling meshes including the exchanged coupling data. preCICE generates the relevant files during the simulation and stores them in the directory `coupling-meshes`. In order to visualize the results, load the VTK files in ParaView and apply a `Glyph` filter. Depending on the specific ParaView version, you might additionally need to disable the `ScaleArray` option by selecting `No scale array`, since the exchanged data might be inappropriate for a scaling operation. You can further add a `Warp By Vector` filter with `Displacement` to deform the coupling data. The result would look the following way:
+
+
diff --git a/quickstart/clean-tutorials.sh b/quickstart/clean-tutorials.sh
new file mode 120000
index 000000000..4713f5092
--- /dev/null
+++ b/quickstart/clean-tutorials.sh
@@ -0,0 +1 @@
+../tools/clean-tutorial-base.sh
\ No newline at end of file
diff --git a/quickstart/fluid-openfoam/0/U b/quickstart/fluid-openfoam/0/U
new file mode 100644
index 000000000..69dfcf932
--- /dev/null
+++ b/quickstart/fluid-openfoam/0/U
@@ -0,0 +1,54 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class volVectorField;
+ object U;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [0 1 -1 0 0 0 0];
+
+internalField uniform (0 0 0);
+
+boundaryField
+{
+
+ flap
+ {
+ type movingWallVelocity;
+ value uniform (0 0 0);
+ }
+
+ top
+ {
+ type noSlip;
+ }
+
+ bottom
+ {
+ type noSlip;
+ }
+
+ inlet
+ {
+ type fixedValue;
+ value uniform (1 0 0);
+ }
+
+ outlet
+ {
+ type zeroGradient;
+ }
+
+ front
+ {
+ type empty;
+ }
+ back
+ {
+ type empty;
+ }
+}
+
+// ************************************************************************* //
diff --git a/quickstart/fluid-openfoam/0/p b/quickstart/fluid-openfoam/0/p
new file mode 100644
index 000000000..90e9358f4
--- /dev/null
+++ b/quickstart/fluid-openfoam/0/p
@@ -0,0 +1,52 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class volScalarField;
+ object p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [0 2 -2 0 0 0 0];
+
+internalField uniform 0;
+
+boundaryField
+{
+ flap
+ {
+ type zeroGradient;
+ }
+
+ top
+ {
+ type zeroGradient;
+ }
+
+ bottom
+ {
+ type zeroGradient;
+ }
+
+ inlet
+ {
+ type zeroGradient;
+ }
+
+ outlet
+ {
+ type fixedValue;
+ value uniform 0;
+ }
+
+ front
+ {
+ type empty;
+ }
+ back
+ {
+ type empty;
+ }
+}
+
+// ************************************************************************* //
diff --git a/quickstart/fluid-openfoam/0/pointDisplacement b/quickstart/fluid-openfoam/0/pointDisplacement
new file mode 100644
index 000000000..e12eaa933
--- /dev/null
+++ b/quickstart/fluid-openfoam/0/pointDisplacement
@@ -0,0 +1,53 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class pointVectorField;
+ object pointDisplacement;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions [0 1 0 0 0 0 0];
+
+internalField uniform (0 0 0);
+
+boundaryField
+{
+ inlet
+ {
+ type fixedValue;
+ value uniform (0 0 0);
+ }
+
+ outlet
+ {
+ type fixedValue;
+ value uniform (0 0 0);
+ }
+
+ flap
+ {
+ type fixedValue;
+ value $internalField;
+ }
+
+ top
+ {
+ type slip;
+ }
+
+ bottom
+ {
+ type slip;
+ }
+ front
+ {
+ type empty;
+ }
+ back
+ {
+ type empty;
+ }
+}
+
+// ************************************************************************* //
diff --git a/quickstart/fluid-openfoam/clean.sh b/quickstart/fluid-openfoam/clean.sh
new file mode 100755
index 000000000..c31d9fc76
--- /dev/null
+++ b/quickstart/fluid-openfoam/clean.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+set -e -u
+
+. ../../tools/cleaning-tools.sh
+
+clean_openfoam .
diff --git a/quickstart/fluid-openfoam/constant/dynamicMeshDict b/quickstart/fluid-openfoam/constant/dynamicMeshDict
new file mode 100644
index 000000000..d323bc059
--- /dev/null
+++ b/quickstart/fluid-openfoam/constant/dynamicMeshDict
@@ -0,0 +1,22 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location "constant";
+ object dynamicMeshDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dynamicFvMesh dynamicMotionSolverFvMesh;
+
+motionSolverLibs ("libfvMotionSolvers.so");
+
+solver displacementLaplacian;
+
+displacementLaplacianCoeffs {
+
+ diffusivity quadratic inverseDistance (flap);
+
+}
\ No newline at end of file
diff --git a/quickstart/fluid-openfoam/constant/transportProperties b/quickstart/fluid-openfoam/constant/transportProperties
new file mode 100644
index 000000000..870a0bb1c
--- /dev/null
+++ b/quickstart/fluid-openfoam/constant/transportProperties
@@ -0,0 +1,14 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location constant;
+ object transportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ transportModel Newtonian;
+
+ nu nu [0 2 -1 0 0 0 0 ] 0.001;
+ pRef pRef [1 -1 -2 0 0 0 0 ] 0.0;
diff --git a/quickstart/fluid-openfoam/constant/turbulenceProperties b/quickstart/fluid-openfoam/constant/turbulenceProperties
new file mode 100644
index 000000000..f906d4153
--- /dev/null
+++ b/quickstart/fluid-openfoam/constant/turbulenceProperties
@@ -0,0 +1,11 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location constant;
+ object turbulenceProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType laminar;
diff --git a/quickstart/fluid-openfoam/run.sh b/quickstart/fluid-openfoam/run.sh
new file mode 100755
index 000000000..c191b9e48
--- /dev/null
+++ b/quickstart/fluid-openfoam/run.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+set -e -u
+
+blockMesh
+touch fluid-openfoam.foam
+
+../../tools/run-openfoam.sh "$@"
+. ../../tools/openfoam-remove-empty-dirs.sh && openfoam_remove_empty_dirs
diff --git a/quickstart/fluid-openfoam/system/blockMeshDict b/quickstart/fluid-openfoam/system/blockMeshDict
new file mode 100644
index 000000000..c8a955624
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/blockMeshDict
@@ -0,0 +1,199 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ object blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+scale 1;
+
+b -0.1; // z-back
+f 0.1; // z-front
+
+// Vertices
+X1 -0.2; // pre rigid body
+X2 0.0; // begin rigid body
+X3 0.2; // end rigid body
+X4 0.6; // wake
+
+Y1 -0.13; // distance to bottom
+Y2 -0.01; // half body height
+Y3 0.01; // half body height
+Y4 0.12; // distance to top
+
+// Blocks
+H1 12;
+H2 14;
+H3 20;
+
+V1 12;
+V2 2;
+V3 11;
+
+G3 4;
+
+vertices
+(
+ // X1 layer back
+ ($X1 $Y1 $b) // 0
+ ($X1 $Y2 $b)
+ ($X1 $Y3 $b)
+ ($X1 $Y4 $b)
+
+ // X1 layer front
+ ($X1 $Y1 $f) // 4
+ ($X1 $Y2 $f)
+ ($X1 $Y3 $f)
+ ($X1 $Y4 $f)
+
+ // X2 layer back
+ ($X2 $Y1 $b) // 8
+ ($X2 $Y2 $b)
+ ($X2 $Y3 $b)
+ ($X2 $Y4 $b)
+
+ // X2 layer front
+ ($X2 $Y1 $f) // 12
+ ($X2 $Y2 $f)
+ ($X2 $Y3 $f)
+ ($X2 $Y4 $f)
+
+ // X3 layer back
+ ($X3 $Y1 $b) // 16
+ ($X3 $Y2 $b)
+ ($X3 $Y3 $b)
+ ($X3 $Y4 $b)
+
+ // X3 layer front
+ ($X3 $Y1 $f) // 20
+ ($X3 $Y2 $f)
+ ($X3 $Y3 $f)
+ ($X3 $Y4 $f)
+
+ // X4 layer back
+ ($X4 $Y1 $b) // 24
+ ($X4 $Y2 $b)
+ ($X4 $Y3 $b)
+ ($X4 $Y4 $b)
+
+ // X4 layer front
+ ($X4 $Y1 $f) // 28
+ ($X4 $Y2 $f)
+ ($X4 $Y3 $f)
+ ($X4 $Y4 $f)
+
+);
+
+blocks
+(
+ // Block 0-3
+ hex ( 0 8 9 1 4 12 13 5) ($H1 $V1 1) simpleGrading (1 1 1)
+ hex ( 1 9 10 2 5 13 14 6) ($H1 $V2 1) simpleGrading (1 1 1)
+ hex ( 2 10 11 3 6 14 15 7) ($H1 $V3 1) simpleGrading (1 1 1)
+
+ // Block 4-6 \5
+ hex ( 8 16 17 9 12 20 21 13) ($H2 $V1 1) simpleGrading (1 1 1)
+ hex ( 10 18 19 11 14 22 23 15) ($H2 $V3 1) simpleGrading (1 1 1)
+
+ // Block 7-9
+ hex ( 16 24 25 17 20 28 29 21) ($H3 $V1 1) simpleGrading ($G3 1 1)
+ hex ( 17 25 26 18 21 29 30 22) ($H3 $V2 1) simpleGrading ($G3 1 1)
+ hex ( 18 26 27 19 22 30 31 23) ($H3 $V3 1) simpleGrading ($G3 1 1)
+
+);
+
+
+boundary
+(
+ back
+ {
+ type empty;
+ faces
+ (
+ (0 8 9 1)
+ (1 9 10 2)
+ (2 10 11 3)
+ (8 16 17 9)
+ (10 18 19 11)
+ (16 24 25 17)
+ (17 25 26 18)
+ (18 26 27 19)
+ );
+ }
+
+ front
+ {
+ type empty;
+ faces
+ (
+ (4 12 13 5)
+ (5 13 14 6)
+ (6 14 15 7)
+ (12 20 21 13)
+ (14 22 23 15)
+ (20 28 29 21)
+ (21 29 30 22)
+ (22 30 31 23)
+ );
+ }
+
+ inlet
+ {
+ type patch;
+ faces
+ (
+ (0 4 5 1)
+ (1 5 6 2)
+ (2 6 7 3)
+ );
+ }
+
+ outlet
+ {
+ type patch;
+ faces
+ (
+ (24 28 29 25)
+ (25 29 30 26)
+ (26 30 31 27)
+ );
+ }
+
+ flap
+ {
+ type wall;
+ faces
+ (
+ (9 13 14 10)
+ (9 17 21 13)
+ (10 18 22 14)
+ (18 22 21 17)
+ );
+ }
+
+ bottom
+ {
+ type wall;
+ faces
+ (
+ (0 8 12 4)
+ (8 16 20 12)
+ (16 24 28 20)
+ );
+ }
+
+ top
+ {
+ type wall;
+ faces
+ (
+ (3 11 15 7)
+ (11 19 23 15)
+ (19 27 31 23)
+ );
+ }
+);
+
+// ************************************************************************* //
diff --git a/quickstart/fluid-openfoam/system/controlDict b/quickstart/fluid-openfoam/system/controlDict
new file mode 100644
index 000000000..8a241d19b
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/controlDict
@@ -0,0 +1,61 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location system;
+ object controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Note: With OpenFOAM v1806 and OpenFOAM 6, the DyM solvers
+// were marked deprecated and merged into their respective standard solvers.
+application pimpleFoam; // OpenFOAM v1806, OpenFOAM 6, or newer
+// application pimpleDyMFoam; // OpenFOAM v1712, OpenFOAM 5.x, or older
+
+
+startFrom startTime;
+
+startTime 0;
+
+stopAt endTime;
+
+endTime 2.5;
+
+deltaT 2.5e-2;
+
+writeControl adjustableRunTime;
+
+writeInterval 2.5e-2;
+
+purgeWrite 0;
+
+writeFormat ascii;
+
+writePrecision 10;
+
+writeCompression off;
+
+timeFormat general;
+
+timePrecision 8;
+
+functions
+{
+ forces
+ {
+ type forces;
+ libs ( "libforces.so" );
+ patches (flap);
+ rho rhoInf;
+ log true;
+ rhoInf 10;
+ CofR (0 0 0);
+ }
+
+ preCICE_Adapter
+ {
+ type preciceAdapterFunctionObject;
+ libs ("libpreciceAdapterFunctionObject.so");
+ }
+}
diff --git a/quickstart/fluid-openfoam/system/decomposeParDict b/quickstart/fluid-openfoam/system/decomposeParDict
new file mode 100644
index 000000000..dee82bfd0
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/decomposeParDict
@@ -0,0 +1,25 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location system;
+ object decomposeParDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ numberOfSubdomains 2;
+
+ method hierarchical;
+ hierarchicalCoeffs
+ {
+ n (2 1 1);
+ delta 0.001;
+ order xyz;
+ }
+
+ distributed false;
+ roots
+ (
+ );
+
diff --git a/quickstart/fluid-openfoam/system/fvSchemes b/quickstart/fluid-openfoam/system/fvSchemes
new file mode 100644
index 000000000..c784ff608
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/fvSchemes
@@ -0,0 +1,41 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location "system";
+ object fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ ddtSchemes
+ {
+ default backward;
+ }
+
+ gradSchemes
+ {
+ default cellLimited Gauss linear 1;
+ }
+
+ divSchemes
+ {
+ default none;
+ div(phi,U) Gauss linearUpwind grad(U);
+ div((nuEff*dev2(T(grad(U))))) Gauss linear;
+ }
+
+ interpolationSchemes
+ {
+ default linear;
+ }
+
+ laplacianSchemes
+ {
+ default Gauss linear corrected;
+ }
+
+ snGradSchemes
+ {
+ default corrected;
+ }
diff --git a/quickstart/fluid-openfoam/system/fvSolution b/quickstart/fluid-openfoam/system/fvSolution
new file mode 100644
index 000000000..5592bdf82
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/fvSolution
@@ -0,0 +1,85 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location "system";
+ object fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+ p
+ {
+ solver GAMG;
+ tolerance 1e-6;
+ relTol 1e-4;
+ smoother DICGaussSeidel;
+ }
+
+ pFinal
+ {
+ $p;
+ tolerance 1e-07;
+ relTol 0;
+ }
+
+ pcorr
+ {
+ solver GAMG;
+ tolerance 1e-5;
+ relTol 1e-3;
+ smoother GaussSeidel;
+ }
+
+ pcorrFinal
+ {
+ $pcorr;
+ relTol 0;
+ }
+
+ phi
+ {
+ $p;
+ }
+
+ "(U|cellDisplacement)"
+ {
+ solver smoothSolver;
+ smoother symGaussSeidel;
+ tolerance 1e-7;
+ relTol 1e-5;
+ }
+
+ "(U|cellDisplacement)Final"
+ {
+ $U;
+ relTol 0;
+ }
+}
+
+PIMPLE
+{
+ nOuterCorrectors 10;
+ nCorrectors 2;
+ nNonOrthogonalCorrectors 1;
+ tolerance 1.0e-8;
+
+ correctPhi yes;
+ relTol 1e-4;
+ pisoTol 1e-6;
+ consistent true;
+
+}
+PISO
+{
+ nNonOrthogonalCorrectors 1;
+}
+potentialFlow
+{
+ nNonOrthogonalCorrectors 1;
+}
+
+
+// ************************************************************************* //
diff --git a/quickstart/fluid-openfoam/system/preciceDict b/quickstart/fluid-openfoam/system/preciceDict
new file mode 100644
index 000000000..c67f623a0
--- /dev/null
+++ b/quickstart/fluid-openfoam/system/preciceDict
@@ -0,0 +1,39 @@
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location "system";
+ object preciceDict;
+}
+
+preciceConfig "../precice-config.xml";
+
+participant Fluid;
+
+modules (FSI);
+
+interfaces
+{
+ Interface1
+ {
+ mesh Fluid-Mesh;
+ patches (flap);
+ locations faceCenters;
+
+ readData
+ (
+ Displacement
+ );
+
+ writeData
+ (
+ Force
+ );
+ };
+};
+
+FSI
+{
+ rho rho [1 -3 0 0 0 0 0] 1000;
+}
diff --git a/quickstart/images/quickstart-result.png b/quickstart/images/quickstart-result.png
new file mode 100644
index 000000000..27f75affd
Binary files /dev/null and b/quickstart/images/quickstart-result.png differ
diff --git a/quickstart/images/quickstart-setup.png b/quickstart/images/quickstart-setup.png
new file mode 100644
index 000000000..37dec838d
Binary files /dev/null and b/quickstart/images/quickstart-setup.png differ
diff --git a/quickstart/plotDisplacement.sh b/quickstart/plotDisplacement.sh
new file mode 100755
index 000000000..f2f0840f2
--- /dev/null
+++ b/quickstart/plotDisplacement.sh
@@ -0,0 +1,8 @@
+#! /bin/bash
+gnuplot -p << EOF
+ set grid
+ set title 'Displacement of the rigid body tip'
+ set xlabel 'time [s]'
+ set ylabel 'y-displacement [m]'
+ plot "solid-cpp/precice-Solid-watchpoint-Flap-Tip.log" using 1:5 with lines notitle
+EOF
diff --git a/quickstart/precice-config.xml b/quickstart/precice-config.xml
new file mode 100644
index 000000000..e33d690a7
--- /dev/null
+++ b/quickstart/precice-config.xml
@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/quickstart/solid-cpp/CMakeLists.txt b/quickstart/solid-cpp/CMakeLists.txt
new file mode 100644
index 000000000..4024b0f9d
--- /dev/null
+++ b/quickstart/solid-cpp/CMakeLists.txt
@@ -0,0 +1,10 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 3.10.2)
+SET(TARGET "rigid_body_solver")
+PROJECT(${TARGET} LANGUAGES CXX DESCRIPTION "rigid_body_solver")
+
+FIND_PACKAGE(precice REQUIRED CONFIG)
+ADD_EXECUTABLE(
+ ${TARGET}
+ ${TARGET}.cpp)
+
+TARGET_LINK_LIBRARIES(${TARGET} PRIVATE precice::precice)
diff --git a/quickstart/solid-cpp/clean.sh b/quickstart/solid-cpp/clean.sh
new file mode 100755
index 000000000..ccbff3c12
--- /dev/null
+++ b/quickstart/solid-cpp/clean.sh
@@ -0,0 +1,7 @@
+#bin/sh
+set -e -u
+
+. ../../tools/cleaning-tools.sh
+
+rm -rfv coupling-meshes
+clean_precice_logs .
diff --git a/quickstart/solid-cpp/rigid_body_solver.cpp b/quickstart/solid-cpp/rigid_body_solver.cpp
new file mode 100644
index 000000000..e0af5aefc
--- /dev/null
+++ b/quickstart/solid-cpp/rigid_body_solver.cpp
@@ -0,0 +1,256 @@
+#include
+#include
+#include
+#include
+
+using Vector = std::vector;
+
+struct DataContainer {
+ void save_old_state(const Vector &vertices,
+ const double &theta,
+ const double &theta_dot)
+ {
+ old_vertices = vertices;
+ old_theta = theta;
+ old_theta_dot = theta_dot;
+ }
+
+ void reload_old_state(Vector &vertices,
+ double &theta,
+ double &theta_dot) const
+ {
+ vertices = old_vertices;
+ theta = old_theta;
+ theta_dot = old_theta_dot;
+ }
+
+ Vector old_vertices;
+ double old_theta;
+ double old_theta_dot;
+};
+
+class Solver {
+public:
+ Solver(const double moment_of_inertia)
+ : moment_of_inertia(moment_of_inertia)
+ {
+ }
+
+ void
+ solve(const Vector &forces,
+ const Vector &initial_vertices,
+ Vector & vertices,
+ double & theta,
+ double & theta_dot,
+ const double spring_constant,
+ const double delta_t) const
+ {
+ // Compute total moment M = x^{n} x f^{n+1}
+ double moment = 0;
+ for (unsigned int i = 0; i < forces.size() / 2; ++i)
+ moment += vertices[2 * i] * forces[2 * i + 1] - vertices[2 * i + 1] * forces[2 * i];
+
+ // Store rigid body angle at the previous time level theta^{n}
+ const double theta_old = theta;
+
+ // Update angle to theta^{n+1} according to forward Euler method (simplified moment
+ // computation, which does not depend on the updated configuration). The contribution
+ // of the spring with strength k is discretized implicitly.
+ // theta^{n+1} = 1/ (1 - (k/I)*dt^2) * dt^2 * M / I + dt * \dot{theta}^{n} + theta^{n}
+ theta = (1. / (1 - (spring_constant / moment_of_inertia) * std::pow(delta_t, 2))) *
+ (std::pow(delta_t, 2) * moment / moment_of_inertia + delta_t * theta_dot + theta);
+
+ // Update angular velocity
+ // \dot{theta}^{n+1} = (theta^{n+1} - \dot{theta}^{n}) / dt
+ theta_dot = (theta - theta_old) / delta_t;
+
+ // Update vertices according to rigid body rotation using an out-of-plane (z-axis) rotation matrix
+ // x^{n+1} = x^{0} * cos(theta^{n+1}) + y^{0} * sin(theta^{n+1})
+ // y^{n+1} = -x^{0} * sin(theta^{n+1}) + y^{0} * cos(theta^{n+1})
+ for (uint i = 0; i < vertices.size() / 2; ++i) {
+ const double x_coord = initial_vertices[2 * i];
+ vertices[2 * i] = x_coord * std::cos(theta) + initial_vertices[2 * i + 1] * std::sin(theta);
+ vertices[2 * i + 1] = -x_coord * std::sin(theta) + initial_vertices[2 * i + 1] * std::cos(theta);
+ }
+ std::cout << "Theta: " << theta << " Theta dot: " << theta_dot << " Moment: " << moment << " Spring force: " << spring_constant * theta << std::endl;
+ }
+
+private:
+ const double moment_of_inertia;
+};
+
+int main()
+{
+ std::cout << "Rigid body: starting... \n";
+
+ // Configuration settings
+ const std::string config_file_name("../precice-config.xml");
+ const std::string solver_name("Solid");
+ const std::string mesh_name("Solid-Mesh");
+ const std::string data_write_name("Displacement");
+ const std::string data_read_name("Force");
+
+ // Mesh configuration
+ constexpr int vertical_refinement = 3;
+ constexpr int horizontal_refinement = 6;
+ // Rotation centre is at (0,0)
+ constexpr double length = 0.2;
+ constexpr double height = 0.02;
+
+ constexpr double density = 10000;
+ constexpr double spring_constant = -25;
+
+ // Time, where spring is stiffened
+ constexpr double switch_time = 1.5;
+ constexpr double stiffening_factor = 8;
+ //*******************************************************************************************//
+
+ // Derived quantities
+ constexpr int n_vertical_nodes = vertical_refinement * 2 + 1;
+ constexpr int n_horizontal_nodes = horizontal_refinement * 2 + 1;
+ // Substract shared nodes at each rigid body corner
+ constexpr int n_nodes = (n_vertical_nodes + n_horizontal_nodes - 2) * 2;
+ constexpr double mass = length * height * density;
+ // The moment of inertia is computed according to the rigid body configuration:
+ // a thin rectangular plate of height h, length l and mass m with axis of rotation
+ // at the end of the plate: I = (1/12)*m*(4*l^2+h^2)
+ constexpr double inertia_moment = (1. / 12) * mass * (4 * std::pow(length, 2) + std::pow(height, 2));
+ constexpr double delta_y = height / (n_vertical_nodes - 1);
+ constexpr double delta_x = length / (n_horizontal_nodes - 1);
+
+ // Create Solverinterface
+ precice::SolverInterface precice(solver_name,
+ config_file_name,
+ /*comm_rank*/ 0,
+ /*comm_size*/ 1);
+
+ const int mesh_id = precice.getMeshID(mesh_name);
+ const int dim = precice.getDimensions();
+ const int write_id = precice.getDataID(data_write_name, mesh_id);
+ const int read_id = precice.getDataID(data_read_name, mesh_id);
+
+ // Set up data structures
+ Vector forces(dim * n_nodes);
+ Vector vertices(dim * n_nodes);
+ Vector displacement(dim * n_nodes);
+ std::vector vertex_ids(n_nodes);
+ double theta_dot = 0.0;
+ double theta = 0.0;
+
+ {
+ // Define a boundary mesh
+ std::cout << "Rigid body: defining mesh: ";
+ std::cout << n_nodes << " nodes " << std::endl;
+
+ // upper y
+ // o---o---o---o---o---o---o
+ // |.......................|
+ // lower x o.......................o upper x
+ // |.......................|
+ // o---o---o---o---o---o---o
+ // lower y
+
+ // x planes
+ for (int i = 0; i < n_vertical_nodes; ++i) {
+ // lower x plane
+ vertices[dim * i] = 0.0; // fixed x
+ vertices[dim * i + 1] = -height * 0.5 + delta_y * i; // increasing y
+ // upper x plane
+ vertices[(2 * n_vertical_nodes) + dim * i] = length; // fixed x
+ vertices[(2 * n_vertical_nodes) + dim * i + 1] = vertices[dim * i + 1]; // increasing y
+ }
+
+ // y planes
+ const unsigned int of = 2 * dim * n_vertical_nodes; // static offset
+ // Lower and upper bounds are already included due to positive/negative x-planes
+ const unsigned int n_remaining_nodes = n_horizontal_nodes - 2;
+ for (unsigned int i = 0; i < n_remaining_nodes; ++i) {
+ // lower y plane
+ vertices[of + dim * i] = delta_x * (i + 1); // increasing x
+ vertices[of + dim * i + 1] = -height * 0.5; // fixed y
+ // upper y plane
+ vertices[of + (2 * n_remaining_nodes) + dim * i] = vertices[of + dim * i]; // increasing x
+ vertices[of + (2 * n_remaining_nodes) + dim * i + 1] = -vertices[of + dim * i + 1]; // fixed y
+ }
+ }
+ // Store the initial configuration
+ const Vector initial_vertices = vertices;
+
+ // Pass the vertices to preCICE
+ precice.setMeshVertices(mesh_id,
+ n_nodes,
+ vertices.data(),
+ vertex_ids.data());
+
+ // initialize the Solverinterface
+ double dt = precice.initialize();
+
+ // Compute the absolute displacement between the current vertices and the
+ // initial configuration. Here, this is mostly done for consistency reasons.
+ for (uint i = 0; i < displacement.size(); ++i)
+ displacement[i] = vertices[i] - initial_vertices[i];
+
+ // Set up a struct in order to store time dependent values
+ DataContainer data_container;
+ // Set up an object which handles the time integration
+ const Solver solver(inertia_moment);
+
+ // Start time loop
+ double time = 0;
+ while (precice.isCouplingOngoing()) {
+
+ std::cout << "Rigid body: t = " << time << "s \n";
+
+ std::cout << "Rigid body: reading initial data \n";
+ if (precice.isReadDataAvailable())
+ precice.readBlockVectorData(read_id,
+ n_nodes,
+ vertex_ids.data(),
+ forces.data());
+
+ // Store time dependent values
+ if (precice.isActionRequired(
+ precice::constants::actionWriteIterationCheckpoint())) {
+ data_container.save_old_state(vertices, theta, theta_dot);
+
+ precice.markActionFulfilled(
+ precice::constants::actionWriteIterationCheckpoint());
+ }
+
+ const double current_spring = time > switch_time ? spring_constant * stiffening_factor : spring_constant;
+ // Solve system
+ solver.solve(forces, initial_vertices, vertices, theta, theta_dot, current_spring, dt);
+
+ // Advance coupled system
+ // Compute absolute displacement with respect to the initial configuration
+ for (uint i = 0; i < displacement.size(); ++i)
+ displacement[i] = vertices[i] - initial_vertices[i];
+
+ std::cout << "Rigid body: writing coupling data \n";
+ if (precice.isWriteDataRequired(dt))
+ precice.writeBlockVectorData(write_id,
+ n_nodes,
+ vertex_ids.data(),
+ displacement.data());
+
+ std::cout << "Rigid body: advancing in time\n";
+ dt = precice.advance(dt);
+
+ // Reload time dependent values
+ if (precice.isActionRequired(
+ precice::constants::actionReadIterationCheckpoint())) {
+ data_container.reload_old_state(vertices, theta, theta_dot);
+
+ precice.markActionFulfilled(
+ precice::constants::actionReadIterationCheckpoint());
+ }
+
+ // Increment time in case the time window has been completed
+ if (precice.isTimeWindowComplete())
+ time += dt;
+ }
+
+ std::cout << "Rigid body: closing...\n";
+
+ return 0;
+}
diff --git a/quickstart/solid-cpp/run.sh b/quickstart/solid-cpp/run.sh
new file mode 100755
index 000000000..60b4fd3eb
--- /dev/null
+++ b/quickstart/solid-cpp/run.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+set -e -u
+
+solver=./rigid_body_solver
+if [ -f "${solver}" ]; then
+ ${solver}
+else
+ echo "Unable to locate the executable ${solver}. Have a look at the README for building instructions."
+fi