Fix linting issues in Markdown files

Author: MakisH

elastic-tube-1d/README.md

@@ -13,9 +13,10 @@ We want to simulate the internal flow in a flexible tube as shown in the figure
 
 ![FSI3 setup](images/tutorials-elastic-tube-1d-setup.png)
 
-The flow is assumed to be incompressible flow and gravity is neglected. Due to the axisymmetry, the flow can be described using a quasi-two-dimensional continuity and momentum equations. The motivation and exact formulation of the equations that we consider can be found in [2]. 
+The flow is assumed to be incompressible flow and gravity is neglected. Due to the axisymmetry, the flow can be described using a quasi-two-dimensional continuity and momentum equations. The motivation and exact formulation of the equations that we consider can be found in [2].
 
 The following parameters have been chosen:
+
 - Length of the tube: L = 10
 - Inlet velocity: $$ v_{inlet} = 10 + 3 sin (10 \pi t) $$
 - Initial cross sectional area = 1
@@ -24,27 +25,25 @@ The following parameters have been chosen:
 - Fluid density: $$ \rho = 1 $$
 - Young modulus: E = 10000
 
-
 ## Available solvers
 
 Both fluid and solid participant are supported in:
 
-* *C++*: An example solver using the intrinsic [C++ API of preCICE](couple-your-code-api.html). This solver also depends on LAPACK (e.g. on Ubuntu `sudo apt-get install liblapack-dev`)
-* *Python*: An example solver using the preCICE [Python bindings](installation-bindings-python.html). This solver also depends on the Python libraries `numpy scipy matplotlib vtk mpi4py`, which you can get from your system package manager or with `pip3 install --user <package>`.
-
+- *C++*: An example solver using the intrinsic [C++ API of preCICE](couple-your-code-api.html). This solver also depends on LAPACK (e.g. on Ubuntu `sudo apt-get install liblapack-dev`)
+- *Python*: An example solver using the preCICE [Python bindings](installation-bindings-python.html). This solver also depends on the Python libraries `numpy scipy matplotlib vtk mpi4py`, which you can get from your system package manager or with `pip3 install --user <package>`.
 
 ### Building the C++ Solver
 
 In order to use the C++ solver, you first need to build the scripts `FluidSolver` and `SolidSolver`. Each script needs to be built separately.
 
-```
+```bash
 cd fluid-cpp
 mkdir build && cd build
 cmake ..
 make all
 ```
 
-```
+```bash
 cd solid-cpp
 mkdir build && cd build
 cmake .. 
@@ -53,38 +52,43 @@ make all
 
 Building can be skipped if you do not plan to use the C++ version.  
 
-## Running the Simulation 
+## Running the Simulation
 
 ### C++
 
-Open two separate terminals and start each participant by calling the respective run script. 
+Open two separate terminals and start each participant by calling the respective run script.
 
-```
+```bash
 cd fluid-cpp
 ./run.sh
 ```
+
 and
-```
+
+```bash
 cd solid-cpp
 ./run.sh
 ```
 
-The solvers use the parameters `N = 100`, `tau = 0.01`, `kappa = 100` by default and can be modified in the solver. 
+The solvers use the parameters `N = 100`, `tau = 0.01`, `kappa = 100` by default and can be modified in the solver.
 
 ### Python
 
 Open two separate terminals and start each participant by calling the respective run script. Only serial run is possible:
 
-```
+```bash
 cd fluid-python
 ./run.sh
 ```
+
 and
-```
+
+```bash
 cd solid-python
 ./run.sh
 ```
-Parameters such as `N` can be modified directly at the `FluidSolver.py` and at the `SolidSolver.py`. The parameters must be consistent between the different solvers and participants. 
+
+Parameters such as `N` can be modified directly at the `FluidSolver.py` and at the `SolidSolver.py`. The parameters must be consistent between the different solvers and participants.
 
 **Optional:** Visualization and video output of the fluid participant can be triggered via the options `--enable-plot` and `--write-video` of `FluidSolver.py`. To generate .vtk files during execution, you need to add the flag `--write-vtk`.
 
@@ -95,21 +99,27 @@ Parameters such as `N` can be modified directly at the `FluidSolver.py` and at t
 ## Post-processing
 
 The results from each simulation are stored in each `fluid-<participant>/output/` folder. You can visualize these VTK files using the provided `plot-diameter.sh` script
+
 ```bash
 ./plot-diameter.sh
 ```
+
 which will try to visualize the results from both fluid cases, if available.
 
 This script calls the more flexible `plot-vtk.py` Python script, which you can use as
+
 ```bash
 python3 plot-vtk.py <quantity> <case>/output/<prefix>
 ```
+
 Note the required arguments specifying which quantity to plot (`pressure`, `velocity` or `diameter`) and the name prefix of the target vtk files.
 
 For example, to plot the diameter of the fluid-python case using the default prefix for VTK files, `plot-diamter.sh` executes:
+
 ```bash
 python3 plot-vtk.py diameter fluid-python/output/out_fluid_
 ```
+
 ![FSI3 setup](images/tutorials-elastic-tube-1d-diameter.png)
 
 ## References
@@ -120,8 +130,3 @@ python3 plot-vtk.py diameter fluid-python/output/out_fluid_
 
 [3] M. Mehl, B. Uekermann, H. Bijl, D. Blom, B. Gatzhammer, and A. van Zuijlen.
 Parallel coupling numerics for partitioned fluid-structure interaction simulations. CAMWA, 2016.  
-
-
-
-
-

flow-over-heated-plate-nearest-projection/README.md

@@ -28,12 +28,14 @@ The solvers are currently only OpenFOAM related. For information regarding the n
 
 Open two separate terminals and start each participant by calling the respective run script.
 
-```
+```bash
 cd fluid-openfoam
 ./run.sh
 ```
+
 and
-```
+
+```bash
 cd solid-openfoam
 ./run.sh
 ```
@@ -45,22 +47,24 @@ You can also run OpenFOAM in parallel by `./run.sh -parallel`. If you are using
 As we are defining two meshes for each participant, we need to define them in the `precice-config.xml` and `preciceDict` configuration files. Additionally, we need to enable the `connectivity` switch for the adapter.
 
 ### Changes in `precice-config.xml`
+
 In order to map from face nodes to face centers, both meshes need to be specified. The nodes-based mesh uses the write data and the centers-based mesh uses the read data. Have a look in the given `precice-config.xml` in this tutorial. Example: `Temperature` is calculated by the `Fluid` participant and passed to the `Solid` participant. Therefore, it is the write data of the participant `Fluid` and the read data of the participant `Solid`. This results in the following two meshes for this data:
-```
+
+```xml
 <mesh name="Fluid-Mesh-Nodes">
   <use-data name="Temperature"/>
 </mesh>
 <mesh name="Solid-Mesh-Centers">
   <use-data name="Temperature"/>
 </mesh>
 ```
+
 All further changes follow from this interface splitting. Have a look in the given config files for all details.
 
 ### Notes on 2D Cases
 
 From the preCICE point of view, the simulation here is in 3D, as opposed to the original 2D case, as is often the case with 3D solvers (such as OpenFOAM). In such cases, we recommend keeping the out-of-plane thickness of the domain small and comparable to the in-plane cell size. Otherwise, the face centers will have a large distance to the face nodes, which might trigger a preCICE warning and preCICE may even filter out one of the meshes, especially in parallel simulations.
 
-
 ## Post-processing
 
 Have a look at the [flow-over heated-plate](tutorials-flow-over-heated-plate.html) tutorial for the general aspects of post-processing.

multiple-perpendicular-flaps/README.md

@@ -11,7 +11,7 @@ summary: In this case, a fluid and two solids are coupled together using a fully
 
 In the following tutorial we model a fluid flowing through a channel. Two solid, elastic flaps are fixed to the floor of this channel. The flaps oscillate due to the fluid pressure building up on its surface. In this case, a fluid and two solids are coupled together using a fully-implicit multi-coupling scheme. The case setup is shown here:
 
-![](images/tutorials-multiple-perpendicular-flaps-setup-two-flaps.png)
+![Setup](images/tutorials-multiple-perpendicular-flaps-setup-two-flaps.png)
 
 The simulated flow domain is 6 units long (x) and 4 units tall (z). The flaps are clamped at the bottom (z=0) and they are 1 unit tall (z), 0.1 units long (x), and 0.3 units wide (y). Being located at x=-1 and x=1, the flaps split the domain into three equal parts.
 
@@ -46,49 +46,61 @@ Most of the coupling details are specified in the file `precide-config.xml`. Her
 
 For the simulation of the solid participants we use the deal.II adapter. In deal.II, the geometry of the domain is specified directly on the solver. The two flaps in our case are essentially the same but for the x-coordinate. The flap geometry is given to the solver when we select the scenario in the '.prm' file.
 
-   ```
-   set Scenario            = PF
-   ```
+```text
+set Scenario            = PF
+```
+
 But to specify the position of the flap along the x-axis, we must specify it in the `Solid1/linear_elasticity.prm` file as follows:
 
-   ```
-   set Flap location     = -1.0
-   ```
+```text
+set Flap location     = -1.0
+```
+
 While in case of `Solid2/linear_elasticity.prm` we write:
 
-   ```
-   set Flap location     = 1.0
-   ```
+```text
+set Flap location     = 1.0
+```
+
 The scenario settings are implemented similarly for the nonlinear case.
 
 ## Running the Simulation
+
 1. Preparation:
    To run the coupled simulation, copy the deal.II executable `linear_elasticity` or `nonlinear_elasticity` into the main folder. To learn how to obtain the deal.II executable take a look at the description on the  [deal.II-adapter page](adapter-dealii-overview.html).
 2. Starting:
 
    We are going to run each solver in a different terminal. It is important that first we navigate to the simulation directory so that all solvers start in the same directory.
    To start the `Fluid` participant, run:
-   ```
+
+   ```bash
    cd fluid-openfoam
    ./run.sh
    ```
+
    to start OpenFOAM in serial or
-   ```
+
+   ```bash
    cd fluid-openfoam
    ./run.sh -parallel
    ```
+
    for a parallel run.
 
    The solid participants are only designed for serial runs. To run the `Solid1` participant, execute the corresponding deal.II binary file e.g. by:
-   ```
+
+   ```bash
    cd solid-left-dealii
    ./run.sh -linear
    ```
+
    Finally, in the third terminal we will run the solver for the `Solid2` participant by:
-   ```
+
+   ```bash
    cd solid-right-dealii
    ./run.sh -linear
    ```
+
    In case we want to run the nonlinear case, simply replace the flag`-linear` by `-nonlinear`.
 
 ## Postprocessing
@@ -100,4 +112,3 @@ After the simulation has finished, you can visualize your results using e.g. Par
 ## References
 
 [1] H. Bungartz, F. Linder, M. Mehl, B. Uekerman. A plug-and-play coupling approach for parallel multi-field simulations. 2014.
-

partitioned-elastic-beam/README.md

@@ -17,7 +17,6 @@ We have a rectangular linear elastic beam of dimensions 1 x 1 x 8 m, divided in
 
 * CalculiX. CalculiX is used for both structural parts. For more information, have a look at the [CalculiX adapter documentation](adapter-calculix-overview.html) for more.
 
-
 ## Running the Simulation
 
 The prepared case already contains configuration and mesh files, so that the simulation is ready to run. You can start the simulation by running the script `./run.sh` located in each participant directory. You will see both participants of the simulation running simultaneously.

partitioned-heat-conduction/README.md

@@ -38,21 +38,21 @@ For choosing whether you want to run the Dirichlet-kind and a Neumann-kind parti
 
 For running the case, open two terminals run:
 
-```
+```bash
 cd fenics
 ./run.sh -d
 ```
 
 and
 
-```
+```bash
 cd fenics
 ./run.sh -n
 ```
 
 If you want to use Nutils for one or both sides of the setup, just `cd nutils`. The FEniCS case also supports parallel runs. Here, you cannot use the `run.sh` script, but must simply execute
 
-```
+```bash
 mpirun -n <N_PROC> heat.py -d
 ```
 
@@ -62,7 +62,7 @@ You can mix the Nutils and FEniCS solver, if you like. Note that the error for a
 
 ## Visualization
 
-Output is written into the folders `fenics/out` and `nutils`. 
+Output is written into the folders `fenics/out` and `nutils`.
 
 For FEniCS you can visualize the content with paraview by opening the `*.pvd` files. The files `Dirichlet.pvd` and `Neumann.pvd` correspond to the numerical solution of the Dirichlet, respectively Neumann, problem, while the files with the prefix `ref` correspond to the analytical reference solution, the files with `error` show the error and the files with `ranks` the ranks of the solvers (if executed in parallel).
 

partitioned-pipe/README.md

@@ -25,12 +25,14 @@ Both for Fluid1 and Fluid2, the following participants are available:
 
 All listed solvers can be used in order to run the simulation. Open two separate terminals and start the desired fluid1 and fluid2 participants by calling the respective run script. For example:
 
-```
+```bash
 cd fluid1-openfoam-pimplefoam
 ./run.sh
 ```
+
 and
-```
+
+```bash
 cd fluid2-openfoam-sonicliquidfoam
 ./run.sh
 ```

perpendicular-flap/README.md

@@ -37,17 +37,19 @@ Solid participant:
 
 All listed solvers can be used in order to run the simulation. Open two separate terminals and start the desired fluid and solid participant by calling the respective run script `run.sh` located in the participant directory. For example:
 
-```
+```bash
 cd fluid-openfoam
 ./run.sh
 ```
+
 and
-```
+
+```bash
 cd solid-fenics
 ./run.sh
 ```
-in order to use OpenFOAM and FEniCS for this test case.
 
+in order to use OpenFOAM and FEniCS for this test case.
 
 ## Post-processing
 
@@ -57,7 +59,6 @@ CalculiX exports results in `.frd` format, which you can visualize in CGX (`cgx
 
 As we defined a watchpoint on the 'Solid' participant at the flap tip (see `precice-config.xml`), we can plot it with gnuplot using the script `plot-displacement.sh.` You need to specify the directory of the selected solid participant as a command line argument, so that the script can pick-up the desired watchpoint file, e.g. `plot-displacement.sh solid-fenics`. The resulting graph shows the x displacement of the flap tip. You can modify the script to plot the force instead.
 
-
 ![Flap watchpoint](images/tutorials-perpendicular-flap-displacement-watchpoint.png)
 
 There is moreover a script `plot-all-displacements.sh` to plot and compare all possible variants. This script expects all watchpoint logs to be available in a subfolder `watchpoints` in the format `openfoam-dealii.log` or similar. If you want to use this script, you need to copy the files over accordingly.