diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index 752d8ab7e..a00dbf1d7 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -1,29 +1,63 @@
 ---
-title: ASTE (Artificial Solver Testing Environment) Turbine Tutorial
+title: ASTE (artificial solver testing environment) wind turbine blade tutorial
 permalink: tutorials-aste-turbine.html
-keywords: ASTE, Testing, Turbine
-summary: This tutorial is an example case for ASTE, showcasing basic features and usage of ASTE.
+keywords: ASTE, mapping, data mapping, mapping configuration, turbine
+summary: This tutorial is an example case for ASTE, where we investigate different preCICE mappings using ASTE.
 ---
 
 {% include note.html content="Get the [case files of this tutorial](https://github.com/precice/tutorials/tree/master/aste-turbine). Read how in the [tutorials introduction](https://precice.org/tutorials.html)." %}
 
+If you are completely new to ASTE have a look at our [ASTE documentation](https://precice.org/tooling-aste.html). This tutorial shows how to setup a mapping between two (artificial) meshes using preCICE and ASTE in parallel. The executed mapping can be investigated in terms of accuracy as well as runtime.
+
 ## Setup
 
-This case is a simple usage scenario for ASTE. Some features demonstrated by this tutorial:
+Our example consists of a wind turbine blade geometry, which was triangulated using different refinement levels. The mesh files are stored in [this GitLab repository](https://gitlab.lrz.de/precice/precice2-ref-paper-setup) and correspond to the mesh files used for the mapping tests of our [version 2 reference paper](https://doi.org/10.12688/openreseurope.14445.1). The mesh files are automatically downloaded when the `run.sh` script is executed. In this example setup, we map the mesh `0.01.vtk` (left side of the figure) to the mesh `0.006.vtk` (right side of the figure).
+
+![Turbine setup](images/tutorials-aste-setup.png)
+
+## Running the tutorial
+
+All necessary steps in order to run the mapping setup are summarized in the `run.sh` script. Have a look at the comments in the run script in order to understand what is happening. In particular, the script executes the following steps:
+
+1. Download the mesh files and extract them in the `meshes` directory. This step is only executed when running the script for the first time. For our example, we only use two of the downloaded meshes. The tutorial can easily be modified to employ different meshes.
+2. Generate input data for our mapping problem. As described in the [ASTE documentation](https://precice.org/tooling-aste.html#precice-aste-evaluate), the python script `precice-aste-evaluate` evaluates a test function and stores the results on a mesh. Here, we select Franke's function, evaluate it on the input mesh `0.01.vtk`, and store the results on a mesh called `input_mesh.vtu`. Use `precice-aste-evaluate --list-functions` to get a complete list of available test functions and their definitions.
+3. Partition meshes. We want to execute the mapping in parallel. To this end, we need to partition our mesh files so that each rank receives its own mesh file. The python script `precice-aste-partition` partitions a given mesh in a specified number of pieces (here two for the input mesh and two for the output mesh).
+4. Execute the actual mapping. We start two instances of `precice-aste-run`, which is the ASTE core module interfacing with preCICE, to emulate two participants. Here, we map the data from the coarse input mesh to the fine output mesh. We store the mesh and data per rank in files `mapped/mapped...` with data called `InterpolatedData`.
+5. Join scattered mesh files. The python script `precice-aste-join` joins the results into one large mesh file `result.vtu`.
+6. Investigate accuracy of mapping configuration. We use `precice-aste-evaluate` again. This time, we use the `--diff` flag in order to compute the error between our test function and the mapped data. We store the difference data (`Error`) on the result mesh (`result.vtu`) as well, which allows us to visualize the error distribution, e.g., using `ParaView`. `precice-aste-evaluate` also prints several global error measures to the console:
+
+```bash
+---[ASTE-Evaluate] INFO : Vertex count 9588
+---[ASTE-Evaluate] INFO : Relative l2 error 0.002402706834866804
+---[ASTE-Evaluate] INFO : Maximum absolute error per vertex 0.009659755828445804
+---[ASTE-Evaluate] INFO : Maximum signed error per vertex 0.00888725146042224
+---[ASTE-Evaluate] INFO : Minimum absolute error per vertex 0.0
+---[ASTE-Evaluate] INFO : Minimum signed error per vertex -0.009659755828445804
+---[ASTE-Evaluate] INFO : Median absolute error per vertex 0.0011544478395176805
+---[ASTE-Evaluate] INFO : 99th percentile of absolute error per vertex 0.007066025673252374
+---[ASTE-Evaluate] INFO : 95th percentile of absolute error per vertex 0.005206080046631978
+---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 0.004253350142177374
+```
+
+This information is additionally stored in a JSON file `result.stats.json` for potential further processing.
 
-* Mapping from a fine grid (`0.009.vtk`) to a coarse grid (`0.01.vtk`).
-* Usage of ASTE partitioner.
-* Usage of ASTE mesh joiner.
-* Usage of ASTE calculator for calculating a function on a given mesh.
-* Usage of ASTE.
+{% note %}
+The error measures used here are only useful for consistent mapping configurations, i.e., `constraint="consistent"`.
+{% endnote %}
 
-## Running ASTE
+This tutorial is meant as a starting point to investigate mapping setups. The provided configuration uses a `nearest-neighbor` mapping, but there are other mapping configurations available (commented out) in the `precice-config.xml` file. Example: using the last configuration (`rbf-compact-polynomial-c6` with a dense matrix decomposition) leads to the following error measures:
 
-Run the `run.sh` script. It performs the following steps:
+```bash
+---[ASTE-Evaluate] INFO : Vertex count 3458
+---[ASTE-Evaluate] INFO : Relative l2 error 9.588343106540401e-08
+---[ASTE-Evaluate] INFO : Maximum absolute error per vertex 1.7229951972397295e-06
+---[ASTE-Evaluate] INFO : Maximum signed error per vertex 1.7229951972397295e-06
+---[ASTE-Evaluate] INFO : Minimum absolute error per vertex 3.5638159090467525e-14
+---[ASTE-Evaluate] INFO : Minimum signed error per vertex -1.6968422637542169e-06
+---[ASTE-Evaluate] INFO : Median absolute error per vertex 6.217611314696114e-09
+---[ASTE-Evaluate] INFO : 99th percentile of absolute error per vertex 3.548732313379818e-07
+---[ASTE-Evaluate] INFO : 95th percentile of absolute error per vertex 1.6012309731194814e-07
+---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 8.077894064206796e-08
+```
 
-* Downloads the meshes from preCICE repository.
-* Using `vtk_calculator.py` script, calculates function `eggholder` on a finer grid.
-* Using `partition_mesh.py` script, partitions the coarse and fine mesh into 2 domains.
-* Using `preciceMap` executable, maps the data from the fine grid to the coarse grid.
-* Using `join_mesh.py`script, joins the result meshes into a final mesh.
-* Using ``vtk_calculator.py` script, calculates difference between mapped and original function on coarse grid.
+which are clearly better than the ones we got with `nearest-neighbor` mapping above. However, this comes at the cost of a much higher runtime ().
diff --git a/aste-turbine/images/tutorials-aste-turbine-setup.png b/aste-turbine/images/tutorials-aste-turbine-setup.png
new file mode 100644
index 000000000..42f8a51d0
Binary files /dev/null and b/aste-turbine/images/tutorials-aste-turbine-setup.png differ
diff --git a/aste-turbine/precice-config.xml b/aste-turbine/precice-config.xml
index 7886dc96c..863444d5a 100644
--- a/aste-turbine/precice-config.xml
+++ b/aste-turbine/precice-config.xml
@@ -35,10 +35,8 @@
 
       <mapping:nearest-neighbor constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" />
       <!-- <mapping:nearest-projection constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
-      <!-- <mapping:rbf-gaussian shape-parameter="4" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" x-dead="false" y-dead="false" z-dead="false" /> -->
-      <!-- <mapping:rbf-gaussian shape-parameter="5600" solver-rtol="1e-9" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" x-dead="true" y-dead="false" z-dead="false" polynomial="separate" preallocation="tree"/> -->
-      <!-- <mapping:rbf-volume-splines solver-rtol="1e-9" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" x-dead="false" y-dead="false" z-dead="false" /> -->
-      <!-- <export:vtk every-n-time-windows="1" directory="vtkB/" normals="0"/> -->
+      <!-- <mapping:rbf-compact-polynomial-c6 support-radius="0.1" use-qr-decomposition="false" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
+      <!-- <mapping:rbf-compact-polynomial-c6 support-radius="0.1" use-qr-decomposition="true" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
     </participant>
     
     <coupling-scheme:parallel-explicit>
diff --git a/aste-turbine/run.sh b/aste-turbine/run.sh
index f43ab4895..fb2ebe686 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -6,29 +6,30 @@ set -e -x
 # Download the meshes
 test -f meshes.tar.gz  || wget https://gitlab.lrz.de/precice/precice2-ref-paper-setup/-/raw/main/meshes/meshes.tar.gz
 
+mkdir -p meshes
+
 # Extract the meshes
-test -f 0.009.vtk -a 0.01.vtk ||tar -xf meshes.tar.gz
+test -f meshes/0.006.vtk -a meshes/0.01.vtk || tar -xvf meshes.tar.gz --directory meshes
 
-# Calculate on fine mesh
-vtk_calculator.py -m 0.009.vtk -f "eggholder3d" -d "EggHolder"
+# Generate input data for the mapping problem using the predefined Franke's function function
+precice-aste-evaluate -m meshes/0.01.vtk -f "franke3d" -d "Franke" -o input_mesh.vtu
 
 # Decompose both meshes to two procesors
-# Choose resolution 0.009 mesh as fine mesh
-partition_mesh.py -m 0.009.vtk -n 2 -o fine_mesh --dir fine_mesh --algorithm topology
-# Choose resolution 0.01 mesh as coarse mesh
-partition_mesh.py -m 0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm topology
+# Choose resolution 0.01 mesh as coarse mesh and partition the mesh using a uniform algorithm
+precice-aste-partition -m input_mesh.vtu -n 2 -o coarse_mesh --dir coarse_mesh --algorithm uniform
+# Choose resolution 0.006 mesh as coarse mesh and partition the mesh using a meshfree algorithm
+precice-aste-partition -m meshes/0.006.vtk -n 2 -o fine_mesh --dir fine_mesh --algorithm meshfree
 
-# The result directory of preciceMap needs to exist beforehand
+# Create results directory of precice-aste-run
 mkdir -p mapped
 
-# Map from the finer mesh to coarser mesh
-mpirun -n 2 preciceMap -v -p A --mesh fine_mesh/fine_mesh --data "EggHolder" &
-mpirun -n 2 preciceMap -v -p B --mesh coarse_mesh/coarse_mesh --output mapped/mapped --data "InterpolatedData"
+# Map from coarse mesh to fine mesh, start two ASTE instances, one for each participant
+mpirun -n 2 precice-aste-run -p A --mesh coarse_mesh/coarse_mesh --data "Franke" &
+mpirun -n 2 precice-aste-run -p B --mesh fine_mesh/fine_mesh --output mapped/mapped --data "InterpolatedData"
 
-# Join the output files together to result.vtk,
-# Recovery cannot be used since GlobalID's are not exist in mapped mesh
-join_mesh.py -m mapped/mapped -o result.vtk --recovery coarse_mesh/coarse_mesh_recovery.json
+# Join the output files together to result.vtu
+precice-aste-join -m mapped/mapped -o result.vtu --recovery fine_mesh/fine_mesh_recovery.json
 
 # Measure the difference between the original function and the mapped values
-# Save into data array called difference
-vtk_calculator.py -m result.vtk -f "eggholder3d" -d difference --diffdata "InterpolatedData" --diff --stats
+# Save into data array called Error
+precice-aste-evaluate -m result.vtu -f "franke3d" -d "Error" --diffdata "InterpolatedData" --diff --stats
diff --git a/tools/clean-tutorial-base.sh b/tools/clean-tutorial-base.sh
index 1d1323c0f..080e13228 100755
--- a/tools/clean-tutorial-base.sh
+++ b/tools/clean-tutorial-base.sh
@@ -7,5 +7,6 @@ set -e -u
 clean_tutorial .
 clean_aste 
 clean_precice_logs .
-rm -fv *.log
+rm -fv ./*.log
+rm -fv ./*.vtu
 
