From bb8fb4f0e31a8e97ae1d8e0972dee71ba086326c Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 15:15:27 +0200
Subject: [PATCH 01/11] Fix cleaning tool

---
 tools/clean-tutorial-base.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/clean-tutorial-base.sh b/tools/clean-tutorial-base.sh
index 1d1323c0f..7924cdd3f 100755
--- a/tools/clean-tutorial-base.sh
+++ b/tools/clean-tutorial-base.sh
@@ -7,5 +7,5 @@ set -e -u
 clean_tutorial .
 clean_aste 
 clean_precice_logs .
-rm -fv *.log
+rm -fv -- *.log
 

From 9fc120f59e6fafc6b606b0ea504d7380a11be900 Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 15:24:49 +0200
Subject: [PATCH 02/11] Port docs to new names

---
 aste-turbine/README.md | 14 +++++++-------
 aste-turbine/run.sh    | 16 ++++++++--------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index 752d8ab7e..269aeeab1 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -1,7 +1,7 @@
 ---
-title: ASTE (Artificial Solver Testing Environment) Turbine Tutorial
+title: ASTE (Artificial Solver Testing Environment) turbine tutorial
 permalink: tutorials-aste-turbine.html
-keywords: ASTE, Testing, Turbine
+keywords: ASTE, mapping, turbine
 summary: This tutorial is an example case for ASTE, showcasing basic features and usage of ASTE.
 ---
 
@@ -22,8 +22,8 @@ This case is a simple usage scenario for ASTE. Some features demonstrated by thi
 Run the `run.sh` script. It performs the following steps:
 
 * 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.
+* Using `precice-aste-evaluate` script, calculates function `eggholder` on a finer grid.
+* Using `precice-aste-partition` script, partitions the coarse and fine mesh into 2 domains.
+* Using `precice-aste-run` executable, maps the data from the fine grid to the coarse grid.
+* Using `precice-aste-join`script, joins the result meshes into a final mesh.
+* Using `precice-aste-evaluate` script, calculates difference between mapped and original function on coarse grid.
diff --git a/aste-turbine/run.sh b/aste-turbine/run.sh
index f43ab4895..62c4a5792 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -10,25 +10,25 @@ test -f meshes.tar.gz  || wget https://gitlab.lrz.de/precice/precice2-ref-paper-
 test -f 0.009.vtk -a 0.01.vtk ||tar -xf meshes.tar.gz
 
 # Calculate on fine mesh
-vtk_calculator.py -m 0.009.vtk -f "eggholder3d" -d "EggHolder"
+precice-aste-evaluate -m 0.009.vtk -f "eggholder3d" -d "EggHolder"
 
 # 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
+precice-aste-partition -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
+precice-aste-partition -m 0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm topology
 
-# The result directory of preciceMap needs to exist beforehand
+# The result directory of precice-aste-run needs to exist beforehand
 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"
+mpirun -n 2 precice-aste-run -v -p A --mesh fine_mesh/fine_mesh --data "EggHolder" &
+mpirun -n 2 precice-aste-run -v -p B --mesh coarse_mesh/coarse_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
+precice-aste-join -m mapped/mapped -o result.vtk --recovery coarse_mesh/coarse_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
+precice-aste-evaluate -m result.vtk -f "eggholder3d" -d difference --diffdata "InterpolatedData" --diff --stats

From 8ee059e7815b5e403a6a7457d349adfac9b0e115 Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 16:05:40 +0200
Subject: [PATCH 03/11] Overhaul script comments

---
 aste-turbine/run.sh          | 28 +++++++++++++++-------------
 tools/clean-tutorial-base.sh |  3 ++-
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/aste-turbine/run.sh b/aste-turbine/run.sh
index 62c4a5792..228a7b702 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -6,29 +6,31 @@ 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.009.vtk -a meshes/0.01.vtk || tar -xvf meshes.tar.gz --directory meshes
 
-# Calculate on fine mesh
-precice-aste-evaluate -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.009.vtk -f "franke3d" -d "Franke" -o input_mesh.vtu
 
 # Decompose both meshes to two procesors
-# Choose resolution 0.009 mesh as fine mesh
-precice-aste-partition -m 0.009.vtk -n 2 -o fine_mesh --dir fine_mesh --algorithm topology
-# Choose resolution 0.01 mesh as coarse mesh
-precice-aste-partition -m 0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm topology
+# Choose resolution 0.009 mesh as fine mesh and partition the mesh using a uniform algorithm
+precice-aste-partition -m input_mesh.vtu -n 2 -o fine_mesh --dir fine_mesh --algorithm uniform
+# Choose resolution 0.01 mesh as coarse mesh and partition the mesh using a meshfree algorithm
+precice-aste-partition -m meshes/0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm meshfree
 
 # The result directory of precice-aste-run needs to exist beforehand
 mkdir -p mapped
 
 # Map from the finer mesh to coarser mesh
-mpirun -n 2 precice-aste-run -v -p A --mesh fine_mesh/fine_mesh --data "EggHolder" &
-mpirun -n 2 precice-aste-run -v -p B --mesh coarse_mesh/coarse_mesh --output mapped/mapped --data "InterpolatedData"
+mpirun -n 2 precice-aste-run -p A --mesh fine_mesh/fine_mesh --data "Franke" &
+mpirun -n 2 precice-aste-run -p B --mesh coarse_mesh/coarse_mesh --output mapped/mapped --data "InterpolatedData"
 
-# Join the output files together to result.vtk,
+# Join the output files together to result.vtu,
 # Recovery cannot be used since GlobalID's are not exist in mapped mesh
-precice-aste-join -m mapped/mapped -o result.vtk --recovery coarse_mesh/coarse_mesh_recovery.json
+precice-aste-join -m mapped/mapped -o result.vtu --recovery coarse_mesh/coarse_mesh_recovery.json
 
 # Measure the difference between the original function and the mapped values
-# Save into data array called difference
-precice-aste-evaluate -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 7924cdd3f..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
 

From 545d61e5b722fb5c6576e16bbb62addbb3932660 Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 17:03:57 +0200
Subject: [PATCH 04/11] Extend documentation

---
 aste-turbine/README.md                        |  47 +++++++++++-------
 .../images/tutorials-aste-turbine-setup.png   | Bin 0 -> 901665 bytes
 aste-turbine/precice-config.xml               |   5 +-
 aste-turbine/run.sh                           |   8 +--
 4 files changed, 35 insertions(+), 25 deletions(-)
 create mode 100644 aste-turbine/images/tutorials-aste-turbine-setup.png

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index 269aeeab1..f047ca502 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -1,29 +1,42 @@
 ---
-title: ASTE (Artificial Solver Testing Environment) turbine tutorial
+title: ASTE (artificial solver testing environment) turbine tutorial
 permalink: tutorials-aste-turbine.html
-keywords: ASTE, mapping, 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 turbine blade geometry, which was triangulated using different refinement levels. The mesh files are stored in the [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 our exemplariy setup, we map the mesh `0.006.vtk` (left side of the figure) to the mesh `0.01.vtk` (right side of the figure).
+
+![Turbine setup](images/tutorials-aste-setup.png)
+
+## Running the tutorial
 
-* 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.
+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:
 
-## Running ASTE
+1. Downloads the meshe files from the preCICE reference paper repository and stores all of them in the `meshes` directory. Note that this step is only executed when running the script for the first time. For our example setup, we use only the two meshes mentioned above, but the tutorial can easily be modified in order to employ a different mesh.
+2. Generate input data for our mapping problem. As described in the [ASTE documentation](https://precice.org/tooling-aste.html#precice-aste-evaluate), we use the python script called `precice-aste-evaluate` in order to evaluate and store a test function on our mesh. Here, we select arbitrarily Franke's function, evaluate it on the input mesh `0.006.vtk` and store the data in a mesh called `input_mesh.vtu`. There are other pre-defined test functions available in the `precice-aste-evaluate` script. Use `precice-aste-evaluate --list-functions` to get a complete list of available functions and their definition.
+3. In our case, we want to execute the mapping in parallel. In order to run ASTE in parallel, we need to partition our mesh files so that each rank receives its own mesh file. The python script `precice-aste-partition`, partitions the given mesh in the specified number of pieces (here two for the input mesh and two for the output mesh). Therefore, we execute ASTE with four ranks per participant.
+4. Executing the actual mapping using `precice-aste-run`, which is the ASTE core module interfacing with preCICE. Here, we map the data from our fine input mesh to the coarse output. The executable stores the mesh and data per rank in the files `mapped/mapped...` with the data called `InterpolatedData`.
+5. In order to join the scattered mesh files, we use the python script `precice-aste-join`. As a result, we get one large mesh file called `result.vtu`.
+6. As a last step we investigate the accuracy of our applied mapping configuration, using `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, which looks as follows:
 
-Run the `run.sh` script. It performs the following steps:
+```bash
+---[ASTE-Evaluate] INFO : Vertex count 3458
+---[ASTE-Evaluate] INFO : Relative l2 error 0.0020057221573822875
+---[ASTE-Evaluate] INFO : Maximum absolute error per vertex 0.010019551121144277
+---[ASTE-Evaluate] INFO : Maximum signed error per vertex 0.007814315048550458
+---[ASTE-Evaluate] INFO : Minimum absolute error per vertex 0.0
+---[ASTE-Evaluate] INFO : Minimum signed error per vertex -0.010019551121144277
+---[ASTE-Evaluate] INFO : Median absolute error per vertex 0.0009199747224788446
+---[ASTE-Evaluate] INFO : 99th percentile of absolute error per vertex 0.005908856215884218
+---[ASTE-Evaluate] INFO : 95th percentile of absolute error per vertex 0.004282379936870699
+---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 0.003504421261280574
+```
 
-* Downloads the meshes from preCICE repository.
-* Using `precice-aste-evaluate` script, calculates function `eggholder` on a finer grid.
-* Using `precice-aste-partition` script, partitions the coarse and fine mesh into 2 domains.
-* Using `precice-aste-run` executable, maps the data from the fine grid to the coarse grid.
-* Using `precice-aste-join`script, joins the result meshes into a final mesh.
-* Using `precice-aste-evaluate` script, calculates difference between mapped and original function on coarse grid.
+The information above is additionally stored in a JSON file called `result.stats.json`. The json file can be used in order to further process and store the resulting data.
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 0000000000000000000000000000000000000000..ced1067fa9240a1bda2c4c8193ff7bb746f1a019
GIT binary patch
diff --git a/aste-turbine/precice-config.xml b/aste-turbine/precice-config.xml
index 7886dc96c..f4c9c6f65 100644
--- a/aste-turbine/precice-config.xml
+++ b/aste-turbine/precice-config.xml
@@ -35,10 +35,7 @@
 
       <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-gaussian shape-parameter="4" 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 228a7b702..372439800 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -9,13 +9,13 @@ test -f meshes.tar.gz  || wget https://gitlab.lrz.de/precice/precice2-ref-paper-
 mkdir -p meshes
 
 # Extract the meshes
-test -f meshes/0.009.vtk -a meshes/0.01.vtk || tar -xvf meshes.tar.gz --directory meshes
+test -f meshes/0.006.vtk -a meshes/0.01.vtk || tar -xvf meshes.tar.gz --directory meshes
 
 # Generate input data for the mapping problem using the predefined Franke's function function
-precice-aste-evaluate -m meshes/0.009.vtk -f "franke3d" -d "Franke" -o input_mesh.vtu
+precice-aste-evaluate -m meshes/0.006.vtk -f "franke3d" -d "Franke" -o input_mesh.vtu
 
 # Decompose both meshes to two procesors
-# Choose resolution 0.009 mesh as fine mesh and partition the mesh using a uniform algorithm
+# Choose resolution 0.006 mesh as fine mesh and partition the mesh using a uniform algorithm
 precice-aste-partition -m input_mesh.vtu -n 2 -o fine_mesh --dir fine_mesh --algorithm uniform
 # Choose resolution 0.01 mesh as coarse mesh and partition the mesh using a meshfree algorithm
 precice-aste-partition -m meshes/0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm meshfree
@@ -33,4 +33,4 @@ precice-aste-join -m mapped/mapped -o result.vtu --recovery coarse_mesh/coarse_m
 
 # Measure the difference between the original function and the mapped values
 # Save into data array called error
-precice-aste-evaluate -m result.vtu -f "franke3d" -d error --diffdata "InterpolatedData" --diff --stats
+precice-aste-evaluate -m result.vtu -f "franke3d" -d "Error" --diffdata "InterpolatedData" --diff --stats

From 665c601c7b64ffbc64b4dac52913f6232856280f Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 17:46:16 +0200
Subject: [PATCH 05/11] Add more setups and example results

---
 aste-turbine/README.md          | 21 +++++++++++++++++++++
 aste-turbine/precice-config.xml |  3 ++-
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index f047ca502..a6ab05ed5 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -40,3 +40,24 @@ All necessary steps in order to run the mapping setup are summarized in the `run
 ```
 
 The information above is additionally stored in a JSON file called `result.stats.json`. The json file can be used in order to further process and store the resulting data.
+
+{% note %}
+The error measures as used here are only useful for consistent mapping configurations, i.e., `constraint="consistent"`.
+{% endnote %}
+
+The tutorial here is meant as a starting point in order to investigate mapping setups. The default configuration here 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:
+
+```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
+```
+
+which are clearly better than the `nearest-neighbor` mapping. However, this comes at the cost of a higher runtime, which can easily be observed looking at the `precice-B-events-summary.log` (e.g. the `advance/map.rbf.mapData.FromA-MeshToB-Mesh` event).
diff --git a/aste-turbine/precice-config.xml b/aste-turbine/precice-config.xml
index f4c9c6f65..0ee25fb24 100644
--- a/aste-turbine/precice-config.xml
+++ b/aste-turbine/precice-config.xml
@@ -35,7 +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" /> -->
+      <!-- <mapping:rbf-compact-polynomial-c6 support-radius="0.2" use-qr-decomposition="false" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
+      <!-- <mapping:rbf-compact-polynomial-c6 support-radius="0.2" use-qr-decomposition="true" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
     </participant>
     
     <coupling-scheme:parallel-explicit>

From 398fa6f7f20eabd946c28d9a7b8e13a7da27cdb8 Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Mon, 19 Sep 2022 17:49:16 +0200
Subject: [PATCH 06/11] Compress image file

---
 .../images/tutorials-aste-turbine-setup.png   | Bin 901665 -> 231596 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/aste-turbine/images/tutorials-aste-turbine-setup.png b/aste-turbine/images/tutorials-aste-turbine-setup.png
index ced1067fa9240a1bda2c4c8193ff7bb746f1a019..42f8a51d0057a0cd408944937ffe80078593aca8 100644
GIT binary patch

From 46fb16c739862992a667496e4e8a7a3f92e865c9 Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Tue, 20 Sep 2022 08:37:19 +0200
Subject: [PATCH 07/11] Apply Makis suggestions from code review

Co-authored-by: Gerasimos Chourdakis <chourdak@in.tum.de>
---
 aste-turbine/README.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index a6ab05ed5..73597e367 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -1,5 +1,5 @@
 ---
-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, mapping, data mapping, mapping configuration, turbine
 summary: This tutorial is an example case for ASTE, where we investigate different preCICE mappings using ASTE.
@@ -11,7 +11,7 @@ If you are completely new to ASTE have a look at our [ASTE documentation](https:
 
 ## Setup
 
-Our example consists of a turbine blade geometry, which was triangulated using different refinement levels. The mesh files are stored in the [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 our exemplariy setup, we map the mesh `0.006.vtk` (left side of the figure) to the mesh `0.01.vtk` (right side of the figure).
+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.006.vtk` (left side of the figure) to the mesh `0.01.vtk` (right side of the figure).
 
 ![Turbine setup](images/tutorials-aste-setup.png)
 
@@ -19,12 +19,12 @@ Our example consists of a turbine blade geometry, which was triangulated using d
 
 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. Downloads the meshe files from the preCICE reference paper repository and stores all of them in the `meshes` directory. Note that this step is only executed when running the script for the first time. For our example setup, we use only the two meshes mentioned above, but the tutorial can easily be modified in order to employ a different mesh.
-2. Generate input data for our mapping problem. As described in the [ASTE documentation](https://precice.org/tooling-aste.html#precice-aste-evaluate), we use the python script called `precice-aste-evaluate` in order to evaluate and store a test function on our mesh. Here, we select arbitrarily Franke's function, evaluate it on the input mesh `0.006.vtk` and store the data in a mesh called `input_mesh.vtu`. There are other pre-defined test functions available in the `precice-aste-evaluate` script. Use `precice-aste-evaluate --list-functions` to get a complete list of available functions and their definition.
+1. Downloads the mesh files from the preCICE reference paper repository, and stores all of them in the `meshes` directory. Note that this step is only executed when running the script for the first time. For our example setup, we use only the two meshes mentioned above, but the tutorial can easily be modified in order to employ a different mesh.
+2. Generate input data for our mapping problem. As described in the [ASTE documentation](https://precice.org/tooling-aste.html#precice-aste-evaluate), we use the python script called `precice-aste-evaluate` in order to evaluate and store a test function on our mesh. Here, we arbitrarily select Franke's function, evaluate it on the input mesh `0.006.vtk` and store the data in a mesh called `input_mesh.vtu`. There are other pre-defined test functions available in the `precice-aste-evaluate` script. Use `precice-aste-evaluate --list-functions` to get a complete list of available functions and their definition.
 3. In our case, we want to execute the mapping in parallel. In order to run ASTE in parallel, we need to partition our mesh files so that each rank receives its own mesh file. The python script `precice-aste-partition`, partitions the given mesh in the specified number of pieces (here two for the input mesh and two for the output mesh). Therefore, we execute ASTE with four ranks per participant.
 4. Executing the actual mapping using `precice-aste-run`, which is the ASTE core module interfacing with preCICE. Here, we map the data from our fine input mesh to the coarse output. The executable stores the mesh and data per rank in the files `mapped/mapped...` with the data called `InterpolatedData`.
 5. In order to join the scattered mesh files, we use the python script `precice-aste-join`. As a result, we get one large mesh file called `result.vtu`.
-6. As a last step we investigate the accuracy of our applied mapping configuration, using `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, which looks as follows:
+6. As a last step, we investigate the accuracy of our applied mapping configuration, using `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, which looks as follows:
 
 ```bash
 ---[ASTE-Evaluate] INFO : Vertex count 3458
@@ -45,7 +45,7 @@ The information above is additionally stored in a JSON file called `result.stats
 The error measures as used here are only useful for consistent mapping configurations, i.e., `constraint="consistent"`.
 {% endnote %}
 
-The tutorial here is meant as a starting point in order to investigate mapping setups. The default configuration here 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:
+This tutorial is meant as a starting point in order 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:
 
 ```bash
 ---[ASTE-Evaluate] INFO : Vertex count 3458
@@ -60,4 +60,4 @@ The tutorial here is meant as a starting point in order to investigate mapping s
 ---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 8.077894064206796e-08
 ```
 
-which are clearly better than the `nearest-neighbor` mapping. However, this comes at the cost of a higher runtime, which can easily be observed looking at the `precice-B-events-summary.log` (e.g. the `advance/map.rbf.mapData.FromA-MeshToB-Mesh` event).
+which are clearly better than the ones we got with `nearest-neighbor` mapping above. However, this comes at the cost of a higher runtime, which can easily be observed looking at the `precice-B-events-summary.log` (e.g., the `advance/map.rbf.mapData.FromA-MeshToB-Mesh` event).

From 5dd72a6ce3a566d5876b7823f0bcf1bf263ebecc Mon Sep 17 00:00:00 2001
From: Benjamin Uekermann <benjamin.uekermann@ipvs.uni-stuttgart.de>
Date: Tue, 20 Sep 2022 17:16:16 +0200
Subject: [PATCH 08/11] Tweak language

---
 aste-turbine/README.md | 20 ++++++++++----------
 aste-turbine/run.sh    |  8 ++++----
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index 73597e367..dd05a073d 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -19,12 +19,12 @@ Our example consists of a wind turbine blade geometry, which was triangulated us
 
 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. Downloads the mesh files from the preCICE reference paper repository, and stores all of them in the `meshes` directory. Note that this step is only executed when running the script for the first time. For our example setup, we use only the two meshes mentioned above, but the tutorial can easily be modified in order to employ a different mesh.
-2. Generate input data for our mapping problem. As described in the [ASTE documentation](https://precice.org/tooling-aste.html#precice-aste-evaluate), we use the python script called `precice-aste-evaluate` in order to evaluate and store a test function on our mesh. Here, we arbitrarily select Franke's function, evaluate it on the input mesh `0.006.vtk` and store the data in a mesh called `input_mesh.vtu`. There are other pre-defined test functions available in the `precice-aste-evaluate` script. Use `precice-aste-evaluate --list-functions` to get a complete list of available functions and their definition.
-3. In our case, we want to execute the mapping in parallel. In order to run ASTE in parallel, we need to partition our mesh files so that each rank receives its own mesh file. The python script `precice-aste-partition`, partitions the given mesh in the specified number of pieces (here two for the input mesh and two for the output mesh). Therefore, we execute ASTE with four ranks per participant.
-4. Executing the actual mapping using `precice-aste-run`, which is the ASTE core module interfacing with preCICE. Here, we map the data from our fine input mesh to the coarse output. The executable stores the mesh and data per rank in the files `mapped/mapped...` with the data called `InterpolatedData`.
-5. In order to join the scattered mesh files, we use the python script `precice-aste-join`. As a result, we get one large mesh file called `result.vtu`.
-6. As a last step, we investigate the accuracy of our applied mapping configuration, using `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, which looks as follows:
+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.006.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 fine input mesh to the coarse 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 3458
@@ -39,13 +39,13 @@ All necessary steps in order to run the mapping setup are summarized in the `run
 ---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 0.003504421261280574
 ```
 
-The information above is additionally stored in a JSON file called `result.stats.json`. The json file can be used in order to further process and store the resulting data.
+This information is additionally stored in a JSON file `result.stats.json` for potential further processing.
 
 {% note %}
-The error measures as used here are only useful for consistent mapping configurations, i.e., `constraint="consistent"`.
+The error measures used here are only useful for consistent mapping configurations, i.e., `constraint="consistent"`.
 {% endnote %}
 
-This tutorial is meant as a starting point in order 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:
+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:
 
 ```bash
 ---[ASTE-Evaluate] INFO : Vertex count 3458
@@ -60,4 +60,4 @@ This tutorial is meant as a starting point in order to investigate mapping setup
 ---[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 8.077894064206796e-08
 ```
 
-which are clearly better than the ones we got with `nearest-neighbor` mapping above. However, this comes at the cost of a higher runtime, which can easily be observed looking at the `precice-B-events-summary.log` (e.g., the `advance/map.rbf.mapData.FromA-MeshToB-Mesh` event).
+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/run.sh b/aste-turbine/run.sh
index 372439800..c01b19d05 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -20,17 +20,17 @@ precice-aste-partition -m input_mesh.vtu -n 2 -o fine_mesh --dir fine_mesh --alg
 # Choose resolution 0.01 mesh as coarse mesh and partition the mesh using a meshfree algorithm
 precice-aste-partition -m meshes/0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm meshfree
 
-# The result directory of precice-aste-run needs to exist beforehand
+# Create results directory of precice-aste-run
 mkdir -p mapped
 
-# Map from the finer mesh to coarser mesh
+# Map from fine mesh to coarse mesh, start to ASTE instances, one for each participant
 mpirun -n 2 precice-aste-run -p A --mesh fine_mesh/fine_mesh --data "Franke" &
 mpirun -n 2 precice-aste-run -p B --mesh coarse_mesh/coarse_mesh --output mapped/mapped --data "InterpolatedData"
 
-# Join the output files together to result.vtu,
+# Join the output files together to result.vtu
 # Recovery cannot be used since GlobalID's are not exist in mapped mesh
 precice-aste-join -m mapped/mapped -o result.vtu --recovery coarse_mesh/coarse_mesh_recovery.json
 
 # Measure the difference between the original function and the mapped values
-# Save into data array called error
+# Save into data array called Error
 precice-aste-evaluate -m result.vtu -f "franke3d" -d "Error" --diffdata "InterpolatedData" --diff --stats

From 24519a1432ba0b22f050e372a28d377c6a27be7e Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Thu, 22 Sep 2022 10:58:06 +0200
Subject: [PATCH 09/11] Remove comment on recovery file

---
 aste-turbine/run.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/aste-turbine/run.sh b/aste-turbine/run.sh
index c01b19d05..e4661f12d 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -28,7 +28,6 @@ mpirun -n 2 precice-aste-run -p A --mesh fine_mesh/fine_mesh --data "Franke" &
 mpirun -n 2 precice-aste-run -p B --mesh coarse_mesh/coarse_mesh --output mapped/mapped --data "InterpolatedData"
 
 # Join the output files together to result.vtu
-# Recovery cannot be used since GlobalID's are not exist in mapped mesh
 precice-aste-join -m mapped/mapped -o result.vtu --recovery coarse_mesh/coarse_mesh_recovery.json
 
 # Measure the difference between the original function and the mapped values

From 8a67073dae0bb641269fa5da727e929cccfcd8fe Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Thu, 22 Sep 2022 12:03:13 +0200
Subject: [PATCH 10/11] Exchange fine and coarse

---
 aste-turbine/README.md |  6 +++---
 aste-turbine/run.sh    | 18 +++++++++---------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index dd05a073d..2798d3f4c 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -11,7 +11,7 @@ If you are completely new to ASTE have a look at our [ASTE documentation](https:
 
 ## Setup
 
-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.006.vtk` (left side of the figure) to the mesh `0.01.vtk` (right side of the figure).
+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)
 
@@ -20,9 +20,9 @@ Our example consists of a wind turbine blade geometry, which was triangulated us
 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.006.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.
+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 fine input mesh to the coarse output mesh. We store the mesh and data per rank in files `mapped/mapped...` with data called `InterpolatedData`.
+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:
 
diff --git a/aste-turbine/run.sh b/aste-turbine/run.sh
index e4661f12d..fb2ebe686 100755
--- a/aste-turbine/run.sh
+++ b/aste-turbine/run.sh
@@ -12,23 +12,23 @@ mkdir -p meshes
 test -f meshes/0.006.vtk -a meshes/0.01.vtk || tar -xvf meshes.tar.gz --directory meshes
 
 # Generate input data for the mapping problem using the predefined Franke's function function
-precice-aste-evaluate -m meshes/0.006.vtk -f "franke3d" -d "Franke" -o input_mesh.vtu
+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.006 mesh as fine mesh and partition the mesh using a uniform algorithm
-precice-aste-partition -m input_mesh.vtu -n 2 -o fine_mesh --dir fine_mesh --algorithm uniform
-# Choose resolution 0.01 mesh as coarse mesh and partition the mesh using a meshfree algorithm
-precice-aste-partition -m meshes/0.01.vtk -n 2 -o coarse_mesh --dir coarse_mesh --algorithm meshfree
+# 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
 
 # Create results directory of precice-aste-run
 mkdir -p mapped
 
-# Map from fine mesh to coarse mesh, start to ASTE instances, one for each participant
-mpirun -n 2 precice-aste-run -p A --mesh fine_mesh/fine_mesh --data "Franke" &
-mpirun -n 2 precice-aste-run -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.vtu
-precice-aste-join -m mapped/mapped -o result.vtu --recovery coarse_mesh/coarse_mesh_recovery.json
+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 Error

From 8fad2c92943998905eee13db338930fd46259f9d Mon Sep 17 00:00:00 2001
From: David Schneider <david.schneider@ipvs.uni-stuttgart.de>
Date: Thu, 22 Sep 2022 12:12:50 +0200
Subject: [PATCH 11/11] Tmp

---
 aste-turbine/README.md          | 18 +++++++++---------
 aste-turbine/precice-config.xml |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/aste-turbine/README.md b/aste-turbine/README.md
index 2798d3f4c..a00dbf1d7 100644
--- a/aste-turbine/README.md
+++ b/aste-turbine/README.md
@@ -27,16 +27,16 @@ All necessary steps in order to run the mapping setup are summarized in the `run
 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 3458
----[ASTE-Evaluate] INFO : Relative l2 error 0.0020057221573822875
----[ASTE-Evaluate] INFO : Maximum absolute error per vertex 0.010019551121144277
----[ASTE-Evaluate] INFO : Maximum signed error per vertex 0.007814315048550458
+---[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.010019551121144277
----[ASTE-Evaluate] INFO : Median absolute error per vertex 0.0009199747224788446
----[ASTE-Evaluate] INFO : 99th percentile of absolute error per vertex 0.005908856215884218
----[ASTE-Evaluate] INFO : 95th percentile of absolute error per vertex 0.004282379936870699
----[ASTE-Evaluate] INFO : 90th percentile of absolute error per vertex 0.003504421261280574
+---[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.
diff --git a/aste-turbine/precice-config.xml b/aste-turbine/precice-config.xml
index 0ee25fb24..863444d5a 100644
--- a/aste-turbine/precice-config.xml
+++ b/aste-turbine/precice-config.xml
@@ -35,8 +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-compact-polynomial-c6 support-radius="0.2" use-qr-decomposition="false" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
-      <!-- <mapping:rbf-compact-polynomial-c6 support-radius="0.2" use-qr-decomposition="true" constraint="consistent" direction="read" from="A-Mesh" to="B-Mesh" /> -->
+      <!-- <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>
