diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 516ed44..1179f16 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -14,11 +14,11 @@ on:
             benchmark_config:
                 description: 'Path to benchmark configuration'
                 required: True
-                default: src/app-feelpp-discr-1/thermal_bridges_case_3.json
+                default: src/app-feelpp-io/feelpp-io.json
             plots_config:
                 description: 'Path to plots related configuration'
                 required: True
-                default: src/app-feelpp-discr-1/heat_plots.json
+                default: src/app-feelpp-io/plots.json
             create_pr:
                 description: 'Create Pull Request'
                 type: boolean
@@ -42,7 +42,7 @@ jobs:
         -   name: Get machines configuration
             id: download_systems_config
             run: |
-                machine_config=$(curl https://gist.githubusercontent.com/thomas-saigre/50760ea0999fb22dbf623c962a3c7664/raw/1ebe7c248e6d50466e492480cc24928bbc60be3c/systems.json )
+                machine_config=$(curl -H "Authorization: token ${{ secrets.CR_PAT }}" https://raw.githubusercontent.com/feelpp/hpc-systems/refs/heads/main/systems.json)
                 machine_config=$(jq --compact-output '.' <<< $machine_config)
                 echo "machine_config=$machine_config" >> $GITHUB_OUTPUT
 
@@ -54,55 +54,50 @@ jobs:
 
                 filtered_systems_config=$(echo "$machine_config" | jq --arg valid_systems "$valid_systems" '
                     ($valid_systems | split(",")) as $systems |
-                    with_entries(select([.key] | inside($systems))) | [.[]]
+                    with_entries(select(.key as $k | $systems | index($k))) | [.[]]
                 ')
                 filtered_systems_config=$(jq --compact-output '.' <<< $filtered_systems_config)
                 echo "filtered_systems_config=$filtered_systems_config" >> $GITHUB_OUTPUT
 
-        # -   name: Filter Available Runners
-        #     id: filter-available-systems
-        #     run: |
-        #         all_runners=$(curl -H "Accept: application/vnd.github+json" \
-        #                             -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
-        #                             -H "X-GitHub-Api-Version: 2022-11-28" \
-        #                             https://api.github.com/orgs/numpex/actions/runners
-        #                     )
-        #         echo $all_runners
-
-        #         all_runners=$(echo $all_runners | jq -r '.runners')
-
-        #         available_systems="[]"
-
-        #         while read -r system; do
-        #             tag=$(echo "$system" | jq -r .runner_tag);
-        #             runner=$(echo "$all_runners" | jq --arg tag "$tag" '
-        #                 map(select(.labels[].name | contains($tag)))
-        #             ')
-
-        #             if [ "$(echo "$runner" | jq 'length')" -eq 0 ]; then
-        #                 echo "No runner found for $tag ..."
-        #                 continue
-        #             fi
-
-        #             if echo "$runner" | jq -e 'map(select(.status == "online")) | length > 0' >/dev/null; then
-        #                 available_systems=$(echo "$available_systems" | jq --argjson sys "$system" '. + [$sys]')
-        #             else
-        #                 echo "No online runners for $tag ..."
-        #             fi
-        #         done < <(echo '${{steps.filter-systems.outputs.filtered_systems_config}}' | jq -c '.[]')
-
-        #         available_systems=$(jq --compact-output '.' <<< $available_systems)
-        #         echo "available_systems=$available_systems" >> $GITHUB_OUTPUT
-
-        # -   name: Set matrix
-        #     id: hpc-systems
-        #     run: |
-        #         echo "matrix=$(jq -c --null-input --argjson config '${{steps.filter-available-systems.outputs.available_systems}}' '{include: $config}')" >> $GITHUB_OUTPUT
+        -   name: Filter Available Runners
+            id: filter-available-systems
+            run: |
+                all_runners=$(curl -H "Accept: application/vnd.github+json" \
+                                    -H "Authorization: Bearer ${{ secrets.CR_PAT }}" \
+                                    -H "X-GitHub-Api-Version: 2022-11-28" \
+                                    https://api.github.com/repos/numpex/apps-feelpp/actions/runners
+                            )
+                echo $all_runners
+
+                all_runners=$(echo $all_runners | jq -r '.runners')
+
+                available_systems="[]"
+
+                while read -r system; do
+                    tag=$(echo "$system" | jq -r .runner_tag);
+                    runner=$(echo "$all_runners" | jq --arg tag "$tag" '
+                        map(select(.labels[].name | contains($tag)))
+                    ')
+
+                    if [ "$(echo "$runner" | jq 'length')" -eq 0 ]; then
+                        echo "No runner found for $tag ..."
+                        continue
+                    fi
+
+                    if echo "$runner" | jq -e 'map(select(.status == "online")) | length > 0' >/dev/null; then
+                        available_systems=$(echo "$available_systems" | jq --argjson sys "$system" '. + [$sys]')
+                    else
+                        echo "No online runners for $tag ..."
+                    fi
+                done < <(echo '${{steps.filter-systems.outputs.filtered_systems_config}}' | jq -c '.[]')
+
+                available_systems=$(jq --compact-output '.' <<< $available_systems)
+                echo "available_systems=$available_systems" >> $GITHUB_OUTPUT
 
         -   name: Set matrix
             id: hpc-systems
             run: |
-                echo "matrix=$(jq -c --null-input --argjson config '${{steps.filter-systems.outputs.filtered_systems_config}}' '{include: $config}')" >> $GITHUB_OUTPUT
+                echo "matrix=$(jq -c --null-input --argjson config '${{steps.filter-available-systems.outputs.available_systems}}' '{include: $config}')" >> $GITHUB_OUTPUT
 
     benchmark:
         needs: [factory]
@@ -113,46 +108,56 @@ jobs:
         timeout-minutes: 7200
         name: ${{matrix.machine}}
         steps:
-        -   uses: actions/checkout@v6
+        -   uses: actions/checkout@v4
+
+        -   uses: astral-sh/setup-uv@v5
 
         -   name: Create machine config
             run: |
                 json_machine_config='${{ toJson(matrix.system_config) }}'
                 echo "$json_machine_config" > machine_config.json
 
+        -   name: Create venv
+            run: |
+                uv venv .venv
+                source .venv/bin/activate
+
+        -   name: Install feelpp-benchmarking
+            run: uv pip install feelpp-benchmarking
+
+
+        -   name: Print system Usage
+            run: bash ./system_entrypoints/${{matrix.machine}}.sh
+            env:
+                PROJECT_ID: ${{matrix.project_id || ''}}
+
         -   name: Execute benchmarks (CLI)
             if: ${{ matrix.submit == 'cli' }}
             run: |
-                ./tmp_system_entrypoints/${{matrix.machine}}.sh
                 source .venv/bin/activate
                 feelpp-benchmarking-exec \
                     -mc machine_config.json \
                     -bc ${{ github.event.inputs.benchmark_config || github.event.client_payload.benchmark_config }} \
                     -pc ${{ github.event.inputs.plots_config || github.event.client_payload.plots_config}} \
                     -v \
-                    -rfm="-v --exec-order=name --max-retries=2"
+                    -rfm="-v --exec-order=name"
             env:
-                # GIRDER_API_KEY: ${{ secrets.GIRDER }}
-                PROJECT_ID: ${{matrix.project_id || ''}}
                 GHCRIO_USER: ${{ github.actor }}
-                GHCRIO_TOKEN: ${{ secrets.CR_PAT_WORKFLOW }}
+                GHCRIO_TOKEN: ${{ secrets.CR_PAT }}
 
-        #TODO TEMPORARY TMP_SYSTEM_ENTRYPOINTS
+        #TODO TEMPORARY SYSTEM_ENTRYPOINTS
         -   name: Execute benchmarks (slurm)
             if: ${{ matrix.submit == 'slurm' }}
             run: |
-                ./tmp_system_entrypoints/${{matrix.machine}}.sh
                 srun --partition ${{matrix.submit_partition}} \
                     --time 48:00:00 \
                     --account ${{matrix.project_id}} \
                     --qos ${{matrix.qos}} \
                     --nodes 1 --ntasks 1 --cpus-per-task 1 --ntasks-per-node 1 \
-                    ./tmp_system_entrypoints/${{matrix.machine}}_launchBenchmark.sh \
+                    ./system_entrypoints/${{matrix.machine}}_launchBenchmark.sh \
                         -m machine_config.json \
                         -b ${{ github.event.inputs.benchmark_config || github.event.client_payload.benchmark_config }} \
                         -p ${{ github.event.inputs.plots_config || github.event.client_payload.plots_config}}
-            env:
-                GIRDER_API_KEY: ${{ secrets.GIRDER }}
 
         -   name: Parse reports path
             id: parse_reports_path
@@ -170,7 +175,10 @@ jobs:
         name: Stage results
         if: ${{ github.event.inputs.create_pr == 'true' || github.event.client_payload.create_pr == 'true' }}
         steps:
-        -   uses: actions/checkout@v6
+        -   uses: actions/checkout@v4
+
+        -   uses: astral-sh/setup-uv@v5
+
 
         -   name: Download results
             uses: actions/download-artifact@v6
@@ -181,9 +189,11 @@ jobs:
 
         -   name: Create Virtual Environment
             run: |
-                python3 -m venv .venv
+                uv venv .venv
                 source .venv/bin/activate
-                pip3 install -r requirements.txt
+
+        -   name: Install feelpp-benchmarking
+            run: uv pip install feelpp-benchmarking
 
         -   name: Upload to staging folder
             run: |
@@ -204,7 +214,7 @@ jobs:
                 echo "use_case=$(jq -r '.use_case_name' ${{ github.event.inputs.benchmark_config || github.event.client_payload.benchmark_config }})" >> $GITHUB_OUTPUT
 
         -   name: Create Pull Request
-            uses: peter-evans/create-pull-request@v7
+            uses: peter-evans/create-pull-request@v8
             with:
                 title: "Add benchmark on ${{ github.event.inputs.hpc-systems }} for ${{ steps.gather_arguments.outputs.executable_name }} - ${{ steps.gather_arguments.outputs.use_case }}"
                 commit-message: "Add benchmark on ${{ github.event.inputs.hpc-systems }} for ${{ steps.gather_arguments.outputs.executable_name }} - ${{ steps.gather_arguments.outputs.use_case }}"
@@ -220,9 +230,6 @@ jobs:
                     see https://github.com/peter-evans/create-pull-request for more details
                 reviewers: |
                     JavierCladellas
-                    prudhomm
-                    vincentchabannes
-                    thomas-saigre
                 labels: new-benchmark
                 branch: new-benchmark-${{ github.event.inputs.hpc-systems || github.event.client_payload.hpc-systems }}-${{ steps.gather_arguments.outputs.use_case }}
             env:
@@ -235,7 +242,9 @@ jobs:
         if: ${{ github.event.inputs.create_website == 'true' || github.event.client_payload.create_website == 'true' }}
         steps:
 
-            -   uses: actions/checkout@v6
+            -   uses: actions/checkout@v4
+
+            -   uses: astral-sh/setup-uv@v5
 
             -   name: Download results
                 uses: actions/download-artifact@v6
@@ -246,9 +255,12 @@ jobs:
 
             -   name: Create Virtual Environment
                 run: |
-                    python3 -m venv .venv
+                    uv venv .venv
                     source .venv/bin/activate
-                    pip3 install -r requirements.txt
+
+            -   name: Install feelpp-benchmarking
+                run: uv pip install feelpp-benchmarking
+
             -   name: Merge website configs
                 run: |
                     source .venv/bin/activate
diff --git a/.github/workflows/benchmark_deploy.yml b/.github/workflows/benchmark_deploy.yml
new file mode 100644
index 0000000..f01dc5f
--- /dev/null
+++ b/.github/workflows/benchmark_deploy.yml
@@ -0,0 +1,91 @@
+name: Benchmark Deploy
+
+on:
+    pull_request:
+        types: [closed]
+
+jobs:
+    accepted:
+        if: github.event.pull_request.merged == true && contains(github.event.pull_request.labels.*.name, 'new-benchmark')
+        runs-on: self-feelpp
+        env:
+            GIRDER_API_KEY: ${{ secrets.GIRDER }}
+        name: Move to production
+        steps:
+        -   uses: astral-sh/setup-uv@v5
+
+        -   uses: actions/checkout@v4
+
+        -   name: Create Virtual Environment
+            run: |
+                uv venv .venv
+                source .venv/bin/activate
+
+        -   name: Install feelpp-benchmarking
+            run: uv pip install feelpp-benchmarking
+
+        -   name: Download stage reports
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder download -gid $staging_folder_id -o ./tmp/ -d
+
+        -   name: Download Production config
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder download -gid $production_website_config_id -o ./configs_tmp/ -fn production_config.json
+
+        -   name: Merge stage configs
+            run: |
+                source .venv/bin/activate
+                merge-json-configs -fp "./tmp/**/website_config.json" -o ./configs_tmp/stage_config.json -u
+
+        -   name: Update Stage Config
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                update-stage-config -stag ./configs_tmp/stage_config.json -prod ./configs_tmp/production_config.json -prodid $production_folder_id
+
+        -   name: Merge stage and prod configs
+            run: |
+                source .venv/bin/activate
+                merge-json-configs -fp "./configs_tmp/**/*.json" -o ./configs_tmp/website_config.json
+
+        -   name: Upload New Website config
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder upload --item ./configs_tmp/website_config.json --girder_id $production_folder_id
+
+        -   name: Cleanup stage folder
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder move -oid $staging_folder_id -nid $accepted_folder_id
+
+    denied:
+        if: github.event.pull_request.merged == false && contains(github.event.pull_request.labels.*.name, 'new-benchmark')
+        runs-on: self-feelpp
+        env:
+            GIRDER_API_KEY: ${{ secrets.GIRDER }}
+
+        name: Move to denied
+        steps:
+        -   uses: actions/checkout@v4
+
+        -   uses: astral-sh/setup-uv@v5
+
+        -   name: Create Virtual Environment
+            run: |
+                uv venv .venv
+                source .venv/bin/activate
+
+        -   name: Install feelpp-benchmarking
+            run: uv pip install feelpp-benchmarking
+
+        -   name: Cleanup stage folder
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder move -oid $staging_folder_id -nid $denied_folder_id
\ No newline at end of file
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5ff47d4..fcaf535 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -3,183 +3,119 @@ name: CI
 on:
   push:
     branches:
-      - '**' # Push events on all branches
-    paths-ignore:
-      - '.github/workflows/init.yml'
+      - "**"
     tags:
-      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10 including semver
+      - "v*"
 
 jobs:
+  build:
+    runs-on: self-feelpp
+
+    name: Build deb packages
+    if: ${{ !contains(github.event.head_commit.message, 'build skip') }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Configure
+        run: cmake --preset default
+
+      - name: Build
+        run: cmake --build --preset default
 
-  tests:
+      - name: Test
+        if: "!contains(github.event.head_commit.message, 'skip tests')"
+        run: ctest --preset default
+
+      - name: Package
+        run: cmake --build --preset default -t package
+
+      - name: Upload
+        uses: actions/upload-artifact@v5
+        with:
+          name: deb-artifacts
+          path: build/default/assets/feelpp-app-*.deb
+
+  docker:
     runs-on: self-feelpp
-    name: integration-tests
-    if: ${{ !contains(github.event.head_commit.message, 'tests skip') }}
+    needs: build
+    name: Build and push docker image
+    if: ${{ github.ref_name == 'master' || startsWith(github.ref ,'refs/tags/v') || contains(github.event.head_commit.message, '[build container]') }}
+    outputs:
+      tag: ${{ steps.tag_extractor.outputs.tag }}
     steps:
-    - uses: actions/checkout@v6
-
-    - name: Install Python dependencies
-      run: |
-        python -m venv .venv
-        source .venv/bin/activate
-        python3 -m pip install --upgrade pip
-        python3 -m pip install pytest
-        python3 -m pip install -r requirements.txt
-
-    - name: Unit tests
-      run: |
-        source .venv/bin/activate
-        # python3 -m pytest
-      # env:
-        # GIRDER_API_KEY: ${{secrets.GIRDER}}
-
-    # - name: Compile applications
-    #   run: |
-    #     cmake --preset default
-    #     cmake --build --preset default
-
-    - name: Test benchmarks
-      run: |
-        source .venv/bin/activate
-        feelpp-benchmarking-exec -mc src/config/gaya/gaya.json -bc src/app-feelpp-discr-1/thermal_bridges_case_3.json -pc src/app-feelpp-discr-1/heat_plots.json
-        echo $?
-
-    # - name: Dry-run reports
-      # run: |
-        # source .venv/bin/activate
-        # feelpp-benchmarking-render --config-file reports/website_config.json
-
-    # - name: Check files
-    #   run: | #TODO: check if not empty (maybe)
-    #     nb_rfm_report_files=$(ls -1q reports/parallelSum/parallel_sum/default|wc -l)
-    #     nb_doc_reports=$(ls -1q docs/modules/ROOT/pages/reports/|wc -l)
-    #     if [ "$nb_rfm_report_files" -ne 1 ] || [ "$nb_doc_reports" -ne 1 ]; then
-    #       echo "Reports where not rendered."
-    #       exit 1
-    #     fi
-
-  docs:
-    runs-on: self-antora
-    name: Build Antora Site
-    needs: tests
-    if: ${{ !contains(github.event.head_commit.message, 'docs skip') }}
+      - uses: actions/checkout@v4
+
+      - name: Download
+        uses: actions/download-artifact@v6
+        with:
+          name: deb-artifacts
+          path: artifacts/
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        env:
+          DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,index
+        with:
+          images: |
+            ghcr.io/numpex/apps-feelpp
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+          labels: |
+            org.opencontainers.image.url="https://github.com/numpex/apps-feelpp"
+            org.opencontainers.image.source="https://github.com/numpex/apps-feelpp"
+            org.opencontainers.image.authors="Cemosis <contact@cemosis.fr>"
+
+      - name: Extract tag
+        id: tag_extractor
+        run: |
+          FIRST_TAG=$(echo "${{ steps.meta.outputs.tags }}" | tr ' ' '\n' | head -n 1)
+          echo "tag=$FIRST_TAG" >> "$GITHUB_OUTPUT"
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.CR_PAT }}
+
+      - name: Build Image
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64
+          context: artifacts
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          file: ./Dockerfile
+
+  apptainer :
+    runs-on: self-feelpp
+    name: Build and Push apptainer image
+    needs: docker
+    env:
+      apptainer: /opt/apptainer/latest/bin/apptainer
     steps:
-
-    - uses: actions/checkout@v6
-
-    - name: Install credentials
-      run: echo https://$GITHUB_OAUTH:@github.com > $HOME/.git-credentials
-      env:
-        GITHUB_OAUTH: ${{ secrets.CR_PAT_WORKFLOW }}
-
-    - name: Install NPM dependencies
-      run: npm ci --verbose
-
-    # - name: Download
-    #   uses: actions/download-artifact@v4
-    #   with:
-    #     name: wheel-artifacts
-    #     path: dist/
-
-    - name: Install Python dependencies
-      run: |
-          python -m venv .venv
-          source .venv/bin/activate
-
-    # - name: Download website config
-    #   run: |
-    #     source .venv/bin/activate
-    #     # source ./girder_deploy_config.sh
-    #     # feelpp-girder download --girder_id=$production_website_config_id --output_dir=./tmp/ --filename=website_config.json
-    #   env:
-    #     GIRDER_API_KEY: ${{secrets.GIRDER}}
-
-    # - name: Render reports
-    #   run: |
-    #     source .venv/bin/activate
-    #     feelpp-benchmarking-render --config-file=./tmp/website_config.json
-      # env:
-        # GIRDER_API_KEY: ${{ secrets.GIRDER }}
-
-    - name: Build Antora Site
-      run: |
-          source .venv/bin/activate
-          npm run antora || true
-          npm run antora || true
-
-    - name: Deploy
-      if: ${{ github.ref_name == 'main' }}
-      uses: JamesIves/github-pages-deploy-action@v4
-      with:
-          branch: gh-pages # The branch the action should deploy to.
-          folder: public # The folder the action should deploy.
-
-  # deliver:
-  #   runs-on: self-feelpp
-  #   name: Build docker, tag and push
-  #   steps:
-  #   - uses: actions/checkout@v4
-
-  #   - name: Docker meta
-  #     id: meta
-  #     uses: docker/metadata-action@v5
-  #     with:
-  #       images: |
-  #         ghcr.io/feelpp/benchmarking
-  #       tags: |
-  #         type=ref,event=branch
-  #         type=ref,event=pr
-  #         type=semver,pattern={{version}}
-  #         type=semver,pattern={{major}}.{{minor}}
-
-  #   - name: Set up QEMU
-  #     uses: docker/setup-qemu-action@v3
-
-  #   - name: Set up Docker Buildx
-  #     uses: docker/setup-buildx-action@v3
-
-  #   - name: Login to GitHub Container Registry
-  #     uses: docker/login-action@v3
-  #     with:
-  #       registry: ghcr.io
-  #       username: ${{ github.repository_owner }}
-  #       password: ${{ secrets.CR_PAT }}
-
-  #   - name: Build container image
-  #     uses: docker/build-push-action@v6
-  #     with:
-  #       push: ${{ github.event_name != 'pull_request' }}
-  #       tags: ${{ steps.meta.outputs.tags }}
-  #       labels: ${{ steps.meta.outputs.labels }}
-  #       file: ./Dockerfile
-
-  # release:
-  #   runs-on: self-feelpp
-  #   name: Release
-  #   needs: [tests]
-  #   if: startsWith(github.ref ,'refs/tags/v')
-  #   permissions:
-  #     contents: write
-  #     id-token: write
-  #   steps:
-  #     - uses: actions/checkout@v4
-
-  #     - name: Download Wheel Packages
-  #       uses: actions/download-artifact@v4
-  #       with:
-  #         name: wheel-artifacts
-  #         path: dist/
-
-  #     - name: Create Release
-  #       uses: softprops/action-gh-release@v2
-  #       with:
-  #         files: dist/*.whl
-  #         draft: false
-  #         prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') || contains(github.ref, 'preview')}}
-  #         name: Release ${{ github.ref_name }}
-  #         generate_release_notes: true
-  #         tag_name: ${{ github.ref }}
-  #         token: ${{ secrets.GITHUB_TOKEN }}
-
-  #     - name: Publish package distributions to PyPI
-  #       uses: pypa/gh-action-pypi-publish@release/v1
+      - name: Login to GHCR
+        run: |
+          ${{ env.apptainer }} remote login  -u ${{ github.repository_owner }} -p ${{ secrets.CR_PAT }} oras://ghcr.io
+
+      - name: Get docker image ${{ needs.docker.outputs.tag }}
+        run: |
+          echo "Using tag: ${{ needs.docker.outputs.tag }}"
+          ${{ env.apptainer }} pull -F apps-feelpp.sif docker://${{ needs.docker.outputs.tag }}
+          ls -lrt
+
+      - name: Push apptainer image ${{ needs.docker.outputs.tag }} to ghcr.io
+        run: |
+          echo "Using tag: ${{ needs.docker.outputs.tag }}"
+          ${{ env.apptainer }} push apps-feelpp.sif oras://${{ needs.docker.outputs.tag }}-sif
diff --git a/.github/workflows/website_deploy.yml b/.github/workflows/website_deploy.yml
new file mode 100644
index 0000000..a48692c
--- /dev/null
+++ b/.github/workflows/website_deploy.yml
@@ -0,0 +1,62 @@
+name: Website Deploy
+
+on:
+    push:
+        branches:
+            - 'main'
+    pull_request:
+        branches: ['main']
+    workflow_dispatch:
+
+jobs:
+    docs:
+        runs-on: self-antora
+        name: Build Antora Site
+        if: "!contains(github.event.head_commit.message, 'docs skip')"
+        steps:
+        -   uses: actions/checkout@v4
+
+        -   name: Install credentials
+            run: echo https://$GITHUB_OAUTH:@github.com > $HOME/.git-credentials
+            env:
+                GITHUB_OAUTH: ${{ secrets.CR_PAT }}
+
+        -   uses: astral-sh/setup-uv@v5
+
+        -   name: Install NPM dependencies
+            run: npm install
+
+        -   name: Create Virtual Environment
+            run: |
+                uv venv .venv
+                source .venv/bin/activate
+
+        -   name: Install feelpp-benchmarking
+            run: uv pip install feelpp-benchmarking
+
+        -   name: Download website config
+            run: |
+                source .venv/bin/activate
+                source ./girder_deploy_config.sh
+                feelpp-girder download --girder_id=$production_website_config_id --output_dir=./tmp/ --filename=website_config.json
+            env:
+                GIRDER_API_KEY: ${{secrets.GIRDER}}
+
+        -   name: Render reports
+            run: |
+                source .venv/bin/activate
+                feelpp-benchmarking-render --config-file=./tmp/website_config.json
+            env:
+                GIRDER_API_KEY: ${{ secrets.GIRDER }}
+
+        -   name: Build Antora Site
+            run: |
+                source .venv/bin/activate
+                npm run antora
+
+        -   name: Deploy
+            uses: JamesIves/github-pages-deploy-action@v4
+            # if: ${{ github.ref_name == 'main' }}
+            with:
+                branch: gh-pages
+                folder: public
diff --git a/.gitignore b/.gitignore
index 852aaa3..013934b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -94,5 +94,10 @@ outputs/
 **/.spack-env/*
 spack.lock
 
+benchmark/*
 
-benchmark/*
\ No newline at end of file
+#Docs
+docs/modules/ROOT/pages/
+!docs/modules/ROOT/pages/index.adoc
+
+tmp/
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
index de690f1..4aa859d 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,12 +1,14 @@
 # -*- mode: Dockerfile -*-
 
-FROM ghcr.io/feelpp/feelpp:jammy
+FROM ghcr.io/feelpp/feelpp:noble
 
 USER root
 COPY . /home/feelpp/
 RUN ls -lrtR /home/feelpp
 
-RUN dpkg -i /home/feelpp/*.deb 
+RUN apt-get update && apt-get install -y /home/feelpp/*.deb
 
 USER feelpp
 
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD feelpp_app_io --help > /dev/null 2>&1 || exit 1
diff --git a/benchmark b/benchmark
deleted file mode 120000
index 69d7b69..0000000
--- a/benchmark
+++ /dev/null
@@ -1 +0,0 @@
-../benchmark/
\ No newline at end of file
diff --git a/docs/antora.yml b/docs/antora.yml
index a1ae035..66b8390 100644
--- a/docs/antora.yml
+++ b/docs/antora.yml
@@ -14,4 +14,5 @@ asciidoc:
     python: Python
     cpp: C++
 nav:
-  - modules/ROOT/nav.adoc
\ No newline at end of file
+  - modules/ROOT/nav.adoc
+  - modules/documentation/nav.adoc
\ No newline at end of file
diff --git a/docs/antora/supplemental-ui/css/figures.css b/docs/antora/supplemental-ui/css/figures.css
new file mode 100644
index 0000000..e0aed62
--- /dev/null
+++ b/docs/antora/supplemental-ui/css/figures.css
@@ -0,0 +1,78 @@
+.figure-container {
+    position: relative;
+    margin: 1.5rem auto;
+    padding: 1rem;
+    background-color: #fff;
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.08);
+}
+
+.subfigure-container {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: #f9f9f9;
+    padding: 1rem;
+    border: 1px solid #ddd;
+    border-top: none;
+    border-radius: 0 0 8px 8px;
+}
+
+.subfigure-container.active {
+    position: relative;
+    opacity: 1;
+    pointer-events: auto;
+    z-index: 1;
+}
+
+.subfigure-container.inactive {
+    opacity: 0;
+    pointer-events: none;
+    z-index: 0;
+}
+
+/* Tabs container: display buttons inline with a bottom border to indicate grouping */
+.tabs-container {
+    display: flex;
+    border-bottom: 2px solid #007acc;
+    margin-bottom: 0.5rem;
+}
+
+/* Figure tab button styling */
+.figure-tab {
+    background: transparent;
+    border: none;
+    outline: none;
+    padding: 0.5rem 1rem;
+    margin-right: 0.3rem;
+    font-size: 1rem;
+    color: #007acc;
+    cursor: pointer;
+    border-radius: 4px 4px 0 0;
+    transition: background-color 0.2s ease, color 0.2s ease;
+}
+
+.figure-tab:hover,
+.figure-tab.active {
+    background-color: #007acc;
+    color: #fff;
+}
+
+.export-container button {
+    background-color: #007acc;
+    color: #fff;
+    border: none;
+    padding: 0.4rem 0.8rem;
+    margin-right: 0.4rem;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    transition: background-color 0.2s ease;
+}
+
+.export-container button:hover {
+    background-color: #005fa3;
+}
\ No newline at end of file
diff --git a/docs/antora/supplemental-ui/css/table.css b/docs/antora/supplemental-ui/css/table.css
new file mode 100644
index 0000000..ffbdf67
--- /dev/null
+++ b/docs/antora/supplemental-ui/css/table.css
@@ -0,0 +1,3 @@
+.scrollable {
+  overflow-x: auto;
+}
\ No newline at end of file
diff --git a/docs/antora/supplemental-ui/js/figure-helper.js b/docs/antora/supplemental-ui/js/figure-helper.js
new file mode 100644
index 0000000..4d31618
--- /dev/null
+++ b/docs/antora/supplemental-ui/js/figure-helper.js
@@ -0,0 +1,55 @@
+function downloadData(data, filename) {
+    if (data.length == 1) {
+        if (data[0].content.length == 1) {
+            d = data[0].content[0];
+            const blob = new Blob([d.data], { type: "plain/text;charset=utf-8" });
+            downloadBlob(blob, `${d.title}.${data[0].format}`);
+        }
+        else {
+            downloadFilesAsZip(
+                [{ format: data[0].format, content: data[0].content }],
+                filename
+            );
+        }
+    }
+    else if (data.length > 1) {
+        downloadFilesAsZip(data, filename);
+    }
+    else {
+        alert("No data to download");
+    }
+}
+
+
+function downloadFilesAsZip(data, zipFilename) {
+    const zip = new JSZip();
+    data.forEach((d) => {
+        d.content.forEach((c) => {
+            const filename = `${c.title}.${d.format}`;
+            zip.file(filename, c.data);
+        });
+    });
+    zip.generateAsync({ type: "blob" }).then((blob) => downloadBlob(blob, zipFilename));
+}
+
+function downloadBlob(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+
+function switchTab(button, tabIndex) {
+    const figureContainer = button.closest('.figure-container');
+    figureContainer.querySelectorAll('.subfigure-container').forEach(subfig => {
+        subfig.classList.remove('active');
+        subfig.classList.add('inactive');
+    });
+    const activeSubfig = figureContainer.querySelector(`.subfigure-container[data-subfigure='${tabIndex}']`);
+    activeSubfig.classList.add('active');
+    activeSubfig.classList.remove('inactive');
+}
diff --git a/docs/antora/supplemental-ui/js/table-filter-sort.js b/docs/antora/supplemental-ui/js/table-filter-sort.js
new file mode 100644
index 0000000..bc98a9c
--- /dev/null
+++ b/docs/antora/supplemental-ui/js/table-filter-sort.js
@@ -0,0 +1,71 @@
+// table-filter-sort.js
+(function () {
+  function filterTable(table, input) {
+    if (!table || !input) return;
+
+    input.addEventListener("input", () => {
+      const term = input.value.toLowerCase();
+      const rows = table.querySelectorAll("tbody tr");
+      rows.forEach(row => {
+        row.style.display = row.textContent.toLowerCase().includes(term) ? "" : "none";
+      });
+    });
+  }
+
+  function sortTable(table) {
+    if (!table) return;
+
+    const headers = table.querySelectorAll("thead th");
+    headers.forEach((header, index) => {
+      header.style.cursor = "pointer";
+
+      header.addEventListener("click", () => {
+        const tbody = table.querySelector("tbody");
+        const rows = Array.from(tbody.querySelectorAll("tr"));
+        const asc = header.dataset.sortOrder !== "asc";
+
+        // reset arrows
+        headers.forEach(h => {
+          h.textContent = h.textContent.replace(/[\u25B2\u25BC]/g, "").trim();
+          delete h.dataset.sortOrder;
+        });
+
+        // set arrow
+        header.dataset.sortOrder = asc ? "asc" : "desc";
+        header.textContent += asc ? " ▲" : " ▼";
+
+        // sort rows
+        rows.sort((a, b) => {
+          const ta = a.children[index].textContent.trim();
+          const tb = b.children[index].textContent.trim();
+          const na = parseFloat(ta);
+          const nb = parseFloat(tb);
+
+          if (!isNaN(na) && !isNaN(nb)) return asc ? na - nb : nb - na;
+          return asc ? ta.localeCompare(tb) : tb.localeCompare(ta);
+        });
+
+        rows.forEach(r => tbody.appendChild(r));
+      });
+    });
+  }
+
+  /**
+   * Initialize a table with sorting & filtering
+   * @param {HTMLElement} table - the table element
+   * @param {string} inputId - ID of the input element
+   */
+  function initTable(table, inputId) {
+    const input = document.getElementById(inputId);
+    if (!table || !input) {
+      console.warn("Table or input not found", table, inputId);
+      return;
+    }
+
+    filterTable(table, input);
+    sortTable(table);
+  }
+
+  // expose globally
+  window.initTable = initTable;
+})();
diff --git a/docs/antora/supplemental-ui/partials/footer-content.hbs b/docs/antora/supplemental-ui/partials/footer-content.hbs
index f20f705..37ab140 100644
--- a/docs/antora/supplemental-ui/partials/footer-content.hbs
+++ b/docs/antora/supplemental-ui/partials/footer-content.hbs
@@ -19,3 +19,8 @@
         </span>
     </div>
 </footer>
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+<script src="{{{uiRootPath}}}/js/figure-helper.js"></script>
+<script src="{{{uiRootPath}}}/js/table-filter-sort.js"></script>
+
diff --git a/docs/antora/supplemental-ui/partials/header-content.hbs b/docs/antora/supplemental-ui/partials/header-content.hbs
index c4b7c6c..f7c1a97 100644
--- a/docs/antora/supplemental-ui/partials/header-content.hbs
+++ b/docs/antora/supplemental-ui/partials/header-content.hbs
@@ -1,3 +1,6 @@
+<link rel="stylesheet" href="{{{uiRootPath}}}/css/figures.css">
+<link rel="stylesheet" href="{{{uiRootPath}}}/css/table.css">
+
 <header class="header">
     <nav class="navbar navbar-expand-sm bg-dark navbar-dark navbar-template-project" style="border-top: 4px solid #9E9E9E">
         <div class="navbar-brand">
diff --git a/docs/modules/ROOT/nav.adoc b/docs/modules/ROOT/nav.adoc
index d9f6673..2782717 100644
--- a/docs/modules/ROOT/nav.adoc
+++ b/docs/modules/ROOT/nav.adoc
@@ -1,4 +1 @@
-* xref:ROOT:index.adoc[Apps-Feelpp]
-* xref:ROOT:overview.adoc[Overview]
-* xref:ROOT:software-and-demonstrators.adoc[Software and demonstrators]
-* xref:ROOT:add_a_case.adoc[Add a case]
\ No newline at end of file
+* xref:ROOT:index.adoc[Apps-Feelpp]
\ No newline at end of file
diff --git a/docs/modules/ROOT/pages/examples/index.adoc b/docs/modules/ROOT/pages/examples/index.adoc
deleted file mode 100644
index fe0b2c0..0000000
--- a/docs/modules/ROOT/pages/examples/index.adoc
+++ /dev/null
@@ -1,2 +0,0 @@
-= Examples
-:page-layout: case-study
\ No newline at end of file
diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc
index fde3993..f8a76a9 100644
--- a/docs/modules/ROOT/pages/index.adoc
+++ b/docs/modules/ROOT/pages/index.adoc
@@ -1,4 +1,42 @@
-= Apps-Feelpp
-:page-layout: toolboxes
-:page-tags: catalog, catalog-index
-:docdatetime: 2025-07-10T13:37:50
+:imagesprefix:
+ifdef::env-github,env-browser,env-vscode[:imagesprefix: ../images/]
+= feelpp.benchmarking
+:page-layout: manuals
+:page-cards-tag: benchmark,report,machine,application,usecase,example
+:page-tags: dashboard_index
+:page-cards-within-module: false
+:docdatetime: 2026-01-19T17:16:05
+
+- Feel++ Benchmarking Version : 4.0.0
+
+== Overview
+
+=== Latest benchmarks
+
+
+
+
+
+
+
+[.scrollable]
+--
+[cols="^1,^2,^1,^1,^1, options="header"]
+|===
+| Status | Date | machine | application | Use Case
+
+|🟢 | 2025-12-09 10:30:47 | gaya | feelpp_app_io | eye-mesh
+|🟢 | 2025-12-09 10:27:36 | gaya | feelpp_app_io | eye-mesh
+
+|===
+--
+
+++++
+<input type="text" class="filter-button" id="filterParamTable" placeholder="Filter testcases..." style="margin-bottom:0.5em;padding:0.3em;width:50%;">
+<script>
+  document.addEventListener('DOMContentLoaded', () => {
+    const table = document.querySelector('.scrollable table');
+    initTable(table, 'filterParamTable');
+  });
+</script>
+++++
diff --git a/docs/modules/documentation/nav.adoc b/docs/modules/documentation/nav.adoc
new file mode 100644
index 0000000..0042575
--- /dev/null
+++ b/docs/modules/documentation/nav.adoc
@@ -0,0 +1,4 @@
+
+* xref:documentation:overview.adoc[Overview]
+* xref:documentation:software-and-demonstrators.adoc[Software and demonstrators]
+* xref:documentation:add_a_case.adoc[Add a case]
\ No newline at end of file
diff --git a/docs/modules/ROOT/pages/add_a_case.adoc b/docs/modules/documentation/pages/add_a_case.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/add_a_case.adoc
rename to docs/modules/documentation/pages/add_a_case.adoc
diff --git a/docs/modules/ROOT/pages/env/antora.adoc b/docs/modules/documentation/pages/env/antora.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/antora.adoc
rename to docs/modules/documentation/pages/env/antora.adoc
diff --git a/docs/modules/ROOT/pages/env/cmake.adoc b/docs/modules/documentation/pages/env/cmake.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/cmake.adoc
rename to docs/modules/documentation/pages/env/cmake.adoc
diff --git a/docs/modules/ROOT/pages/env/githubactions.adoc b/docs/modules/documentation/pages/env/githubactions.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/githubactions.adoc
rename to docs/modules/documentation/pages/env/githubactions.adoc
diff --git a/docs/modules/ROOT/pages/env/jupyter.adoc b/docs/modules/documentation/pages/env/jupyter.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/jupyter.adoc
rename to docs/modules/documentation/pages/env/jupyter.adoc
diff --git a/docs/modules/ROOT/pages/env/rename.adoc b/docs/modules/documentation/pages/env/rename.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/rename.adoc
rename to docs/modules/documentation/pages/env/rename.adoc
diff --git a/docs/modules/ROOT/pages/env/vscode.adoc b/docs/modules/documentation/pages/env/vscode.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/env/vscode.adoc
rename to docs/modules/documentation/pages/env/vscode.adoc
diff --git a/docs/modules/ROOT/pages/overview.adoc b/docs/modules/documentation/pages/overview.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/overview.adoc
rename to docs/modules/documentation/pages/overview.adoc
diff --git a/docs/modules/ROOT/pages/quickstart.adoc b/docs/modules/documentation/pages/quickstart.adoc
similarity index 97%
rename from docs/modules/ROOT/pages/quickstart.adoc
rename to docs/modules/documentation/pages/quickstart.adoc
index 96f7b7c..2943d9c 100644
--- a/docs/modules/ROOT/pages/quickstart.adoc
+++ b/docs/modules/documentation/pages/quickstart.adoc
@@ -60,4 +60,4 @@ Using DevContainers in Visual Studio Code offers several benefits:
 - **Isolation and Dependency Management**: DevContainers isolate your project dependencies from your local machine, reducing conflicts and simplifying dependency management.
 - **Easy Extension Installation**: DevContainers automatically install the specified extensions, making it easy to set up the required tools and configurations for your project.
 
-NOTE: Make sure your Docker daemon is running and accessible from the terminal to use DevContainers in Visual Studio Code.
+NOTE: Make sure your Docker daemon is running and accessible from the terminal to use DevContainers in Visual Studio Code.
\ No newline at end of file
diff --git a/docs/modules/ROOT/pages/software-and-demonstrators.adoc b/docs/modules/documentation/pages/software-and-demonstrators.adoc
similarity index 100%
rename from docs/modules/ROOT/pages/software-and-demonstrators.adoc
rename to docs/modules/documentation/pages/software-and-demonstrators.adoc
diff --git a/netlify-build.sh b/netlify-build.sh
index c3c01b2..56e8e38 100755
--- a/netlify-build.sh
+++ b/netlify-build.sh
@@ -1,3 +1,18 @@
 #!/usr/bin/env bash
 
-antora --html-url-extension-style=indexify site.yml
\ No newline at end of file
+python3 -m venv .venv
+source .venv/bin/activate
+pip3 install feelpp-benchmarking
+
+npm i
+source ./girder_deploy_config.sh
+if [[ $HEAD == *"new-benchmark"* ]]; then
+    echo "Downloading Staging benchmarks"
+    feelpp-girder download -gid $staging_folder_id -o ./tmp/ -d
+    merge-json-configs -fp "./tmp/**/website_config.json" -o ./tmp/website_config.json -u
+else
+    echo "Downloading Production benchmarks"
+    feelpp-girder download -gid $production_website_config_id -o ./tmp/ -fn website_config.json
+fi
+feelpp-benchmarking-render --config-file=./tmp/website_config.json
+npx antora --stacktrace generate --cache-dir cache --clean --html-url-extension-style=indexify site.yml
diff --git a/package-lock.json b/package-lock.json
index cd36e5d..ef846d6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,7 +14,7 @@
                 "@antora/site-generator": "~3.1.14",
                 "@antora/site-generator-default": "~3.1.14",
                 "@asciidoctor/core": "~2.2.8",
-                "@feelpp/asciidoctor-extensions": "1.0.0-rc.13",
+                "@feelpp/asciidoctor-extensions": "1.0.0-rc.15",
                 "asciidoctor": "~2.2.8",
                 "asciidoctor-jupyter": "^0.7.0",
                 "asciidoctor-kroki": "^0.18.1",
@@ -361,9 +361,9 @@
             }
         },
         "node_modules/@feelpp/asciidoctor-extensions": {
-            "version": "1.0.0-rc.13",
-            "resolved": "https://registry.npmjs.org/@feelpp/asciidoctor-extensions/-/asciidoctor-extensions-1.0.0-rc.13.tgz",
-            "integrity": "sha512-brDULLvvzMDtrmFfDXT9nZoPIpzJ+cIwsWVnJ6rQVz0HZkd1MDUm+LcsDMduwUbezFTRpuu98sYTiIpbZmEfAw=="
+            "version": "1.0.0-rc.15",
+            "resolved": "https://registry.npmjs.org/@feelpp/asciidoctor-extensions/-/asciidoctor-extensions-1.0.0-rc.15.tgz",
+            "integrity": "sha512-HcZxT2EJa/UMtFsfLJmznA508Wv3nZxIL4HQccUDFCTALJn0Ez01eWyZYFXk2ye0Cfs9P4a37JZJB7dJDTX8BQ=="
         },
         "node_modules/@iarna/toml": {
             "version": "2.2.5",
@@ -3486,9 +3486,9 @@
             }
         },
         "@feelpp/asciidoctor-extensions": {
-            "version": "1.0.0-rc.13",
-            "resolved": "https://registry.npmjs.org/@feelpp/asciidoctor-extensions/-/asciidoctor-extensions-1.0.0-rc.13.tgz",
-            "integrity": "sha512-brDULLvvzMDtrmFfDXT9nZoPIpzJ+cIwsWVnJ6rQVz0HZkd1MDUm+LcsDMduwUbezFTRpuu98sYTiIpbZmEfAw=="
+            "version": "1.0.0-rc.15",
+            "resolved": "https://registry.npmjs.org/@feelpp/asciidoctor-extensions/-/asciidoctor-extensions-1.0.0-rc.15.tgz",
+            "integrity": "sha512-HcZxT2EJa/UMtFsfLJmznA508Wv3nZxIL4HQccUDFCTALJn0Ez01eWyZYFXk2ye0Cfs9P4a37JZJB7dJDTX8BQ=="
         },
         "@iarna/toml": {
             "version": "2.2.5",
diff --git a/package.json b/package.json
index 04454c3..7e7cb2f 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
         "@antora/site-generator": "~3.1.14",
         "@antora/site-generator-default": "~3.1.14",
         "@asciidoctor/core": "~2.2.8",
-        "@feelpp/asciidoctor-extensions": "1.0.0-rc.13",
+        "@feelpp/asciidoctor-extensions": "1.0.0-rc.15",
         "asciidoctor": "~2.2.8",
         "asciidoctor-jupyter": "^0.7.0",
         "asciidoctor-kroki": "^0.18.1",
diff --git a/rename.sh b/rename.sh
deleted file mode 100644
index 132bfda..0000000
--- a/rename.sh
+++ /dev/null
@@ -1,122 +0,0 @@
-#! /bin/bash
-
-# This script is used to rename the project from myproject to something else.
-
-create_name(){
-    string=$1
-    # Use parameter expansion to get the second part of the string
-    second_part="${string#*/}"
-    echo "$second_part"
-}
-create_short_name() {
-    name=$1
-    # Convert the name to lowercase and remove spaces
-    short_name=$(echo "$name" | tr '[:upper:]' '[:lower:]' | sed 's/ //g')
-
-    # Get the first word
-    first_word=$(echo "${short_name%%-*}")
-    #echo "First word: $first_word"
-    # Get the other words and their first letters
-    other_words=$(echo "${short_name}" | tr '-' '\n' | cut -c1 | tr -d '\n')
-    #echo "Other words: $other_words"
-    # Combine the first word and other letters to create a shorter name
-    #shorter_name="${first_word}-${other_words}"
-    shorter_name="${other_words}"
-
-    # Print the shorter name
-    echo "$shorter_name"
-}
-create_title() {
-    name=$1
-# Convert the name to lowercase and remove spaces
-short_name=$(echo "$name" | tr '[:upper:]' '[:lower:]' | sed 's/ //g')
-
-# Replace hyphens with spaces
-short_name=${short_name//-/ }
-
-# Use parameter expansion to uppercase the first letter of each word
-uppercase_name=$(echo "$short_name" | awk '{for(i=1;i<=NF;i++)sub(/./,toupper(substr($i,1,1)),$i)}1')
-
-
-    # Print the shorter name
-    echo "$uppercase_name"
-}
-
-# This script is used to rename the project from myproject to something else.
-if [ -z "$1" ]; then
-    echo "Usage: $0 <projectname> <projecttitle> <shortprojectname> <appname>"
-    exit 1
-elif [ "$1" == "-h" -o "$1" == "--help" ]; then
-    echo "Usage: $0 <projectname> <projecttitle> <shortprojectname> <appname>"
-    exit 1
-elif [ "$1" == "-r" ]; then
-    in_default_projectname="project"
-    read -p "What is the name of the project ? [$in_default_projectname]: " projectname
-    projectname=${projectname:-$in_default_projectname}
-
-    in_default_titlename="$projectname"
-    read -p "What is the title of the project? [$in_default_titlename]" projecttitle
-    projecttitle=${projecttitle:-$in_default_titlename}
-
-    in_default_shortname="p"
-    read -p "What is the short name of the project? []" shortprojectname
-    shortprojectname=${shortprojectname:-$in_default_shortname}
-
-    in_default_appname="myapp"
-    read -p "What is the name of the first application? [$in_default_appname]" appname
-    appname=${appname:-$in_default_appname}
-else
-    projectname=$( create_name $1 )
-    projecttitle=$(create_title ${projectname})
-    shortprojectname=$( create_short_name $projectname )
-    appname="app"
-    projectname_="${projectname//-/_}"
-
-fi
-
-echo "     project name: $projectname"
-echo "    project title: $projecttitle"
-echo "project shortname: $shortprojectname" 
-echo "         app name: $appname"
-
-if [ "$1" == "-r" ]; then
-    PS3="Do you wish to rename this project?"
-    select yn in Yes No
-    do
-        case $yn in
-            Yes ) echo "Ok lets go!"; break;;
-            No ) exit;;
-        esac
-    done
-fi
-
-export projectname
-export projectname_
-export projecttitle
-export shortprojectname
-export appname
-
-files=( "README.adoc" "README.md" "CMakeLists.txt" "src/CMakeLists.txt" 
-        "src/cpp/.tests.laplacian"  
-        "src/cpp/.tests.toolbox"
-        "site.yml" 
-        "docs/antora.yml" 
-        "package.json"
-        "package-lock.json"
-        "pyproject.toml"
-        "docs/modules/ROOT/pages/index.adoc" 
-        ".github/workflows/ci.yml" )
-for i in "${files[@]}"
-do
-    echo "processing renaming in $i ...."
-    perl -077pi.bak -e 's/feelpp-project/$ENV{'projectname'}/sg' $i
-    perl -077pi.bak -e 's/feelpp_project/$ENV{'projectname_'}/sg' $i
-    perl -077pi.bak -e 's/Feel\+\+ Template Project/$ENV{'projecttitle'}/sg' $i
-    perl -077pi.bak -e 's/\"fp\"/"$ENV{'shortprojectname'}"/sg' $i
-    perl -077pi.bak -e 's/myapp/$ENV{'appname'}/sg' $i
-done
-git mv src/python/feelpp/project src/python/feelpp/$projectname_
-
-
-
-
diff --git a/requirements.txt b/requirements.txt
deleted file mode 100644
index 809bc3f..0000000
--- a/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-feelpp-benchmarking
\ No newline at end of file
diff --git a/site.yml b/site.yml
index 53175cb..21845b4 100644
--- a/site.yml
+++ b/site.yml
@@ -9,7 +9,7 @@ content:
 ui:
   supplemental_files: ./docs/antora/supplemental-ui
   bundle:
-    url: https://github.com/feelpp/antora-ui/releases/latest/download/ui-bundle.zip
+    url: https://github.com/feelpp/antora-ui/releases/download/v0.46/ui-bundle.zip
     snapshot: true
 output:
   clean: true
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 4fa60a2..113bb2a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,7 +1,3 @@
-feelpp_add_testcase(cases PREFIX fp CATEGORY feelpp)
-add_subdirectory(cases/laplacian)
-
-add_subdirectory(example)
-add_subdirectory(app-feelpp-discr-1.old)
+add_compile_options(-U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3)
 add_subdirectory(app-feelpp-io)
 add_subdirectory(app-feelpp-distance)
diff --git a/src/app-feelpp-discr-1.old/CMakeLists.txt b/src/app-feelpp-discr-1.old/CMakeLists.txt
deleted file mode 100644
index c7e6810..0000000
--- a/src/app-feelpp-discr-1.old/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-
-set(ORDERS 1 2 3)
-set(DIM 2 3)
-foreach(order ${ORDERS})
-foreach(dim ${DIM})
-        feelpp_add_application(discr_heat_${dim}DP${order} SRCS discr-heat.cpp ../utils/report.hpp LINK_LIBRARIES Feelpp::feelpp_toolbox_heat_lib DEFS ORDER=${order} FEELPP_DIM=${dim})
-    endforeach()
-endforeach()
diff --git a/src/app-feelpp-discr-1.old/README.adoc b/src/app-feelpp-discr-1.old/README.adoc
deleted file mode 100644
index 85891b4..0000000
--- a/src/app-feelpp-discr-1.old/README.adoc
+++ /dev/null
@@ -1,9 +0,0 @@
-# app-feelpp-discr-1
-
-Solve a PDE (heat,solid mech) with different discretisation methods from low to high order
-
-
-[source, bash]
-----
-feelpp-benchmarking-exec --machine-config src/config/default/default.json --custom-rfm-config src/config/default/default.py --benchmark-config src/app-feelpp-discr-1/heat2DP1.json --plots-config src/app-feelpp-discr-1/plots.json
-----
\ No newline at end of file
diff --git a/src/app-feelpp-discr-1.old/discr-heat.cpp b/src/app-feelpp-discr-1.old/discr-heat.cpp
deleted file mode 100644
index 3c7a38e..0000000
--- a/src/app-feelpp-discr-1.old/discr-heat.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-#include <feel/feelcore/environment.hpp>
-#include <feel/feelmodels/heat/heat.hpp>
-#include "../utils/report.hpp"
-
-#ifndef FEELPP_DIM // Default value for IDE satisfaction, values are set in CMakeLists
-#define ORDER 1
-#define FEELPP_DIM 2
-#endif
-
-
-int main(int argc, char** argv)
-{
-    using namespace Feel;
-    po::options_description myoptions("my options");
-    myoptions.add( toolboxes_options("heat") );
-    myoptions.add_options()
-        ( "output-dir", Feel::po::value<std::string>()->default_value("") )
-        ( "report", Feel::po::value<std::string>()->default_value("scalability.json") )
-    ;
-
-    double time_solve, time_export;
-
-    Environment env( _argc=argc, _argv=argv,
-                     _desc=myoptions,
-                     _about=about(_name="update_toolbox",
-                                  _author="Feel++ Consortium",
-                                  _email="feelpp-devel@feelpp.org"));
-
-    Feel::cout << fmt::format("Running app-feelpp-discr-1 (heat toolbox) in {}D, with the discretization P{}", FEELPP_DIM, ORDER) << std::endl;
-
-    typedef FeelModels::Heat< Simplex<FEELPP_DIM, 1>,
-                              Lagrange<ORDER, Scalar, Continuous, PointSetFekete> > model_type;
-    std::shared_ptr<model_type> heat( new model_type("heat") );
-    // init the toolbox
-    heat->init();
-    heat->printAndSaveInfo();
-
-    // solve
-    tic();
-    heat->solve();
-    time_solve = toc("solve");
-    tic();
-    heat->exportResults();
-    time_export = toc("export results");
-
-    const fs::path output_dir_option = Environment::expand(soption("output-dir"));
-    const fs::path outputDir = (output_dir_option == "") ? fs::current_path() : output_dir_option;
-
-    Report report( outputDir, soption("report") );
-
-    const auto measures = heat->postProcessMeasures();
-    auto values = measures.values();
-    for (const auto& [key, val] : values)
-    {
-        Feel::cout << key << " : " << val << std::endl;
-    }
-
-    report.setMeasure("Norm_error-evaluated_L2-error", values["Norm_error-evaluated_L2-error"]);
-    report.setMeasure("time_solve", time_solve);
-    report.setMeasure("time_export", time_export);
-
-    report.exportMeasures();
-
-    Feel::cout << "[SUCCESS]" << std::endl;
-
-    return 0;
-}
diff --git a/src/app-feelpp-discr-1.old/heat2DP1.json b/src/app-feelpp-discr-1.old/heat2DP1.json
deleted file mode 100644
index cedd4c8..0000000
--- a/src/app-feelpp-discr-1.old/heat2DP1.json
+++ /dev/null
@@ -1,51 +0,0 @@
-{
-    "executable": "{{machine.input_dataset_base_dir}}/build/default/src/app-feelpp-discr-1/feelpp_app_discr_heat_2DP1",
-    "use_case_name": "heat2DP1",
-    "timeout":"0-0:5:0",
-    "output_directory": "{{machine.output_app_dir}}/feelpp_app_discr_heat_2DP1",
-    //Application options
-    "options": [
-        "--gmsh.hsize {{parameters.hsize.value}}",
-        "--output-dir {{output_directory}}/{{instance}}/",
-        "--report scalability.json",
-        "--config-file /nvme0/saigre/feelpp-app/src/cases/square/square.cfg",
-        "--directory {{output_directory}}/{{instance}}/"
-    ],
-    //Files containing execution times
-    "scalability": {
-        "directory": "{{output_directory}}/{{instance}}/",
-        "stages": [
-            {
-                "name":"",
-                "filepath": "scalability.json",
-                "format": "json",
-                "variables_path":"*"
-            }
-        ]
-    },
-    // Resources for the test
-    "resources":{
-        "tasks":"{{parameters.tasks.value}}",
-        "exclusive_access":false
-    },
-    // Test validation (Only stdout supported at the moment)
-    "sanity": {
-        "success": ["[SUCCESS]"],
-        "error": ["[OOPSIE]", "Error", "[Error]"]
-    },
-    // Test parameters
-    "parameters": [
-        {
-            "name": "tasks",
-            "sequence": [ 1, 2, 4 ]
-        },
-        {
-            "name":"hsize",
-            "linspace":{
-                "min":0.02,
-                "max":0.005,
-                "n_steps":4
-            }
-        }
-    ]
-}
\ No newline at end of file
diff --git a/src/app-feelpp-discr-1.old/plots.json b/src/app-feelpp-discr-1.old/plots.json
deleted file mode 100644
index 544c99b..0000000
--- a/src/app-feelpp-discr-1.old/plots.json
+++ /dev/null
@@ -1,70 +0,0 @@
-{
-    "plots":[
-        {
-            "title": "Absolute performance",
-            "plot_types": [ "stacked_bar", "grouped_bar" ],
-            "transformation": "performance",
-            "variables": [ "time_solve" ],
-            "names": ["Time"],
-            "xaxis":{
-                "parameter":"tasks",
-                "label":"Number of tasks"
-            },
-            "yaxis":{"label":"Solving time (s)"},
-            "secondary_axis":{
-                "parameter":"hsize",
-                "label":"h"
-            }
-        },
-        {
-            "title": "Absolute performance",
-            "plot_types": [ "stacked_bar", "grouped_bar" ],
-            "transformation": "performance",
-            "variables": [ "time_export" ],
-            "names": ["Time"],
-            "xaxis":{
-                "parameter":"tasks",
-                "label":"Number of tasks"
-            },
-            "yaxis":{"label":"Export time (s)"},
-            "secondary_axis":{
-                "parameter":"hsize",
-                "label":"h"
-            }
-        },
-        {
-            "title": "Absolute performance",
-            "plot_types": [ "stacked_bar", "table" ],
-            "transformation": "performance",
-            "variables": [ "time_solve" ],
-            "names": ["Time"],
-            "xaxis":{
-                "parameter":"hsize",
-                "label":"N"
-            },
-            "yaxis":{"label":"Execution time (s)"},
-            "secondary_axis":{
-                "parameter":"tasks",
-                "label":"Number of tasks"
-            }
-        },
-        {
-            "title": "Speedup",
-            "plot_types": [ "scatter" ],
-            "transformation": "speedup",
-            "variables": [ "time_solve" ],
-            "names": ["Time"],
-            "xaxis": {
-                "parameter": "tasks",
-                "label": "Number of tasks"
-            },
-            "yaxis": {
-                "label": "Execution time (s)"
-            },
-            "secondary_axis":{
-                "parameter":"hsize",
-                "label":"h"
-            }
-        }
-    ]
-}
\ No newline at end of file
diff --git a/src/app-feelpp-discr-1/README.adoc b/src/app-feelpp-discr-1/README.adoc
deleted file mode 100644
index c70faea..0000000
--- a/src/app-feelpp-discr-1/README.adoc
+++ /dev/null
@@ -1,13 +0,0 @@
-= App feelpp-discr-1
-
-== Benchmark: ThermalBridgesENISO10211
-
-[source, bash]
-----
-feelpp-benchmarking-exec --machine-config src/config/gaya/gaya.json --benchmark-config src/app-feelpp-discr-1/thermal_bridges_case_3.json --plots-config src/app-feelpp-discr-1/heat_plots.json --website -rc src/config/gaya/reframe.py
-----
-
-[source, bash]
-----
-feelpp-benchmarking-render --plot-configs src/app-feelpp-discr-1/heat_plots.json --patch-reports gaya:all:all:all -sp
-----
\ No newline at end of file
diff --git a/src/app-feelpp-discr-1/thermal_bridges_case_3.json b/src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges.json
similarity index 56%
rename from src/app-feelpp-discr-1/thermal_bridges_case_3.json
rename to src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges.json
index 39929f8..f505651 100644
--- a/src/app-feelpp-discr-1/thermal_bridges_case_3.json
+++ b/src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges.json
@@ -1,16 +1,17 @@
 {
-    "executable": "/data/home/saigre/feelpp/build/default/toolboxes/heat/feelpp_toolbox_heat",
+    "executable": "feelpp_toolbox_heat",
     "output_directory": "{{machine.output_app_dir}}/toolboxes/heat/ThermalBridgesENISO10211/Case3",
     "use_case_name": "ThermalBridgesENISO10211",
-    "timeout":"0-01:10:00",
+    "timeout":"0-00:20:00",
     "resources":{
         "tasks":"{{parameters.resources.tasks.value}}",
-        "exclusive_access":"{{parameters.resources.exclusive_access.value}}"
+        "exclusive_access":true,
+        "memory":"{{parameters.memory.value}}"
     },
     "input_file_dependencies":{
-        "solver_cfg":"benchmark/{{use_case_name}}/{{parameters.solver.value}}.cfg",
-        "mesh_json":"benchmark/{{use_case_name}}/partitioning/case3/{{parameters.mesh.value}}/case3_p{{parameters.resources.tasks.value}}.json",
-        "mesh_hdf5":"benchmark/{{use_case_name}}/partitioning/case3/{{parameters.mesh.value}}/case3_p{{parameters.resources.tasks.value}}.h5"
+        "solver_cfg":"feelpp_toolboxes/{{use_case_name}}/{{parameters.solver.value}}.cfg",
+        "mesh_json":"feelpp_toolboxes/{{use_case_name}}/partitioning/case3/{{parameters.mesh.value}}/case3_p{{parameters.resources.tasks.value}}.json",
+        "mesh_hdf5":"feelpp_toolboxes/{{use_case_name}}/partitioning/case3/{{parameters.mesh.value}}/case3_p{{parameters.resources.tasks.value}}.h5"
     },
     "platforms": {
         "apptainer":{
@@ -22,16 +23,11 @@
                 "--home {{machine.output_app_dir}}",
                 "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}",
                 "--env OMP_NUM_THREADS=1"
-            ],
-            "append_app_option":[]
-        },
-        "builtin":{
-            "input_dir":"{{machine.input_dataset_base_dir}}",
-            "append_app_option":[]
+            ]
         }
     },
     "options": [
-        "--config-files /usr/share/feelpp/data/testcases/toolboxes/heat/cases/Building/ThermalBridgesENISO10211/case3.cfg",
+        "--config-files /usr/share/feelpp/data/testcases/toolboxes/heat/cases/Building/ThermalBridgesENISO10211/case3.cfg {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.solver_cfg}}",
         "--directory {{output_directory}}/{{instance}}",
         "--repository.case {{use_case_name}}",
         "--heat.scalability-save=1",
@@ -42,8 +38,8 @@
     "additional_files":{
         "parameterized_descriptions_filepath":"{{output_directory}}/{{instance}}/{{use_case_name}}/heat.information.adoc",
         "custom_logs":[
-            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/{{executable}}.INFO",
-            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/{{executable}}.WARNING"
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_heat.INFO",
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_heat.WARNING"
         ]
     },
     "scalability": {
@@ -70,61 +66,67 @@
                 }
             },
             {
-                "name": "Outputs",
+                "name":"Outputs",
                 "filepath": "heat.measures/values.csv",
                 "format": "csv",
-                "units" :{
+                "units":{
                     "*":"W"
                 }
-            },
+            }
+        ],
+        "custom_variables": [
             {
-                "name": "Journal",
-                "filepath": "journal.json",
-                "format": "json",
-                "variables_path": "Mesh.heat.loadMesh_times.*"
+                "name":"Total",
+                "columns":["Constructor_init","Solve_solve","PostProcessing_exportResults" ],
+                "op":"sum",
+                "unit":"s"
             }
         ]
     },
-    "sanity": {
-        "success": [],
-        "error": []
-    },
     "parameters": [
         {
             "name": "resources",
             "zip":[
                 {
                     "name":"tasks",
-                    "sequence":[64, 128, 256]
-                    //, 512]
-                },
-                {
-                    "name":"exclusive_access",
-                    "repeat":{"value":true, "count":10}
+                    "sequence": [1,2,4,8,16,32,64,128,256,384,512]
                 }
             ]
         },
         {
             "name":"mesh",
-            "sequence":["M1", "M2", "M3"],
+            "sequence":["M1","M2","M3"],
             "conditions":{
-                "M1":[{ "resources.tasks":[64, 128, 256, 512] }],
-                "M2":[{ "resources.tasks":[64, 128, 256, 512] }],
-                "M3":[{ "resources.tasks":[256, 512] }]
+                "M1": [ {"resources.tasks":[ 1,2,4,8,16,32,64,128 ] } ],
+                "M2": [ {"resources.tasks":[ 1,2,4,8,16,32,64,128 ] } ],
+                "M3": [ {"resources.tasks":[ 32,64,128,256,384 ] } ]
             }
         },
         {
-            "name":"discretization",
-            "sequence":["P1", "P2"],
+            // P1 -> M1: <50, M2: 50 , M3: 400
+            // P2 -> M1: <100, M2:<200, M3: 1200 (to check)
+            // P3 -> M1: <200, M2: 1000: M3: ???
+            "name":"memory",
+            "sequence": [50, 200,400,1200],
             "conditions":{
-                "P1":[{ "resources.tasks":[64, 128, 256, 512] }],
-                "P2":[{ "resources.tasks":[64, 128, 256, 512] }],
-                "P3":[{ "resources.tasks":[256, 512] }]
-            }
+                 "50": [ { "discretization": ["P1"], "mesh": ["M1","M2"] } ],
+                 "200": [ { "discretization": ["P2"], "mesh": ["M1","M2"] }, { "discretization": ["P3"], "mesh": ["M1"] } ],
+                 "400": [ { "discretization": ["P1"], "mesh": ["M3"] } ],
+                 "1200": [ { "discretization": ["P2"], "mesh": ["M3"] }, { "discretization": ["P3"], "mesh": ["M2"] } ]
+              }
+         },
+        {
+            "name":"discretization",
+            "sequence":["P1","P2","P3"]
+            // "conditions":{
+            //     "P1":[{ "resources.tasks":[64,128] }],
+            //     "P2":[{ "resources.tasks":[] }],
+            //     "P3":[{ "resources.tasks":[] }]
+            // }
         },
         {
             "name": "solver",
             "sequence": ["gamg"]
         }
     ]
-}
\ No newline at end of file
+}
diff --git a/src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges_plots.json b/src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges_plots.json
new file mode 100644
index 0000000..68ae531
--- /dev/null
+++ b/src/app-feelpp-discr-1/ThermalBridgesENISO10211/heat_thermalbridges_plots.json
@@ -0,0 +1,576 @@
+{
+    "data":[
+        {
+            "name":"ext_parameter_table","ref":"parameter_table",
+            "table_options":{
+                "computed_columns":{
+                    "description_link":"f'link:descriptions/{row[\"testcases.hashcode\"]}.html[Description]'"
+                }
+            }
+        },
+        {
+            "name":"mesh_stats",
+            "columns":[
+                {"name":"Tag","values":["M1","M2","M3"]},
+                {"name":"# points","values":[194000,1400000,10600000]},
+                {"name":"# edges","values":[1300000,9780000,75300000]},
+                {"name":"# faces","values":[2460000,16600000,129000000]},
+                {"name":"# elements","values":[1060000,16600000,129000000]},
+                {"name":"P1","values":[194000,1400000,10600000]},
+                {"name":"P2","values":[1490000,11200000,85900000]},
+                {"name":"P3","values":[4960000,37500000,290000000]}
+            ],
+            "table_options":{
+                "format":{
+                    "# points":"%.2E",
+                    "# edges":"%.2E",
+                    "# faces":"%.2E",
+                    "# elements":"%.2E",
+                    "P1":"%.2E",
+                    "P2":"%.2E",
+                    "P3":"%.2E"
+                }
+            }
+        },
+        {
+            "name":"demonstrator_descr",
+            "columns":[
+                {
+                    "name":"Field",
+                    "values":[
+                        "id", "name", "Partners", "PC", "Responsible (Permanent)", "WP7 Engineer", "work_package","application_type", "purpose",
+                        "Method-Algorithm WP1", "Method-Algorithm WP2", "Method-Algorithm WP3", "Method-Algorithm WP4", "Method-Algorithm WP5", "Method-Algorithm WP6", "WP7",
+                        "outputs", "metrics", "status", "Benchmark scope", "Framework", "parallel_framework", "spec_due", "proto_due", "repo_url"
+                    ]
+                },
+                {
+                    "name":"Details",
+                    "values":[
+                        "app-feelpp-discr-1", "Discretization", "Unistra", "PC1 - ExaMA, PC2 - ExaSoft", "V. Chabannes; C. Prud'homme", "Javier Cladellas (UNISTRA)", "WP1, WP3",
+                        "extended-mini-app", "Solve a PDE (heat, solid mech) with different discretization methods from low to high order", "unstructured mesh, finite element, dG/hdG, cG, spectral element",
+                        "", "domain decomposition methods, Krylov solver, preconditioning", "", "", "", "", "Gmsh, JSON config JSON small-data, JSON reports, inhouse, Markdown or Asciidoc",
+                        "benchmark-verification, strong-scalability, weak-scalability, io-scaling", "benchmark-ready", "full-system, method-verification, solver-scaling", "Feel++, PETSc",
+                        "MPI, Kokkos", "6/15/2025", "7/1/2025", "https://github.com/numpex/apps-feelpp"
+                    ]
+                }
+            ]
+        }
+    ],
+    "contents": [
+        {
+            "type":"section",
+            "title":"Demonstrator: Elliptic linear PDE: CG",
+            "contents": [
+                {
+                    "type":"text",
+                    "text":"This demonstrator solves an elliptic linear PDE (heat equation) using a continuous Galerkin approach."
+                },
+                { "type":"table", "ref":"demonstrator_descr" },
+                {
+                    "type":"section",
+                    "title":"Description of the benchmark",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"The benchmark known as _thermal bridges_ is an example of an application that enables us to validate numerical simulation tools using Feel++. We have developed tests based on the ISO 10211:2017 standard (ISO 10211:2017 - Thermal bridges in building construction — Heat flows and surface temperatures — Detailed calculations, 2017), which provides methodologies for evaluating thermal bridges in building construction."
+                        },
+                        {
+                            "type":"text",
+                            "text": "Thermal bridges are areas within a building envelope where heat flow is different compared to adjacent areas, often resulting in increased heat loss or unwanted condensation. The standard is intended to ensure that thermal bridges simulation are accurately computed. It provides reference values (and tolerance) on heat temperature and heat flux at several location of the geometry."
+                        },
+                        {
+                            "type":"text",
+                            "text": "At the mathematical level, this application requires finding the numerical solution of an elliptic linear PDE (i.e. the heat equation). We employ a finite element method based on continuous Lagrange Finite Element of order 1,2 and 3 (denoted by stem:[\\mathbb{P}_1,\\mathbb{P}_2,\\mathbb{P}_3]). And we analyzed the execution time of the main components of the simulation."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The following figure represents the geometry of this benchmark and the domain decomposition by material."
+                        },
+                        {
+                            "type":"grid",
+                            "columns":2,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-thermalbridges-geom.png",
+                                    "caption":"Thermal Bridges benchmarks - geometry and materials"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-thermalbridges-geom2.png",
+                                    "caption":"Thermal Bridges benchmarks - geometry and materials"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmark Execution Summary",
+                    "contents": [
+                        {
+                            "type":"section",
+                            "title":"Session",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Hostname: @{session_info.hostname}@",
+                                        "User: @{session_info.hostname}@",
+                                        "Time Start: @{session_info.time_start}@",
+                                        "Time End: @{session_info.time_end}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Cases",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Total: @{session_info.num_cases}@ ",
+                                        "Failures: @{session_info.num_failures}@",
+                                        "Runs: @{runs | length}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Parametrization",
+                            "contents":[
+                                {
+                                    "type":"table",
+                                    "ref": "ext_parameter_table",
+                                    "layout":{
+                                        "column_order":["result","testcases.hashcode","resources.tasks","memory","mesh", "discretization","solver", "testcases.time_total", "description_link","logs_link"],
+                                        "rename":{
+                                            "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash",
+                                            "result":"", "description_link":"", "logs_link":""
+                                        }
+                                    },
+                                    "style":{
+                                        "column_align":{ "result":"center" },
+                                        "column_width":{ "result":1,"logs_link":1,"description_link":2},
+                                        "classnames":["scrollable","sortable"]
+                                    },
+                                    "filter":{ "placeholder":"Filter testcases..." }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text": "This benchmark was performed on the @{runs.0.testcases.0.system}@ supercomputer, using feelpp.benchmaring (*v.{feelpp_benchmarking_version}*). The performance tools integrated into the Feel++-toolboxes framework were used to measure the execution time."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The metrics measured are the execution time of the main components of the simulation. We enumerate these parts in the following:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Init*: load mesh from filesystem and initialize heat toolbox (finite element context and algebraic data structure)",
+                                "*Assembly*: calculate and assemble the matrix and rhs values obtained using the finite element method",
+                                "*Solve*: the linear system by using a preconditioned GMRES.",
+                                "*PostProcess*: compute validation measures (temperature at points and heat flux) and export on the filesystem a visualization format (EnsighGold) of the solution."
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "Meshes: We have generated three levels of mesh called _M1_, _M2_ and _M3_. These meshes are stored in GMSH format. The statistics can be found in table below. We  have also prepared for each mesh level a collection of partitioned mesh. The format used is an in-house mesh format of Feel++ based on JSON+HDF5 file type. The Gmsh meshes and the partitioned meshes can be found on our Girder database management, in the Feel++ collections.",
+                                        "Setup: Use standard setup of Feel++ toolboxes. It corresponds to a cfg file and JSON file. These config files are present in the Github of feelpp.",
+                                        "Sif image: _feelpp:v0.111.0-preview.10-noble-sif_ (stored in the Github registry of Feel++)"
+                                    ]
+                                },
+                                { "type":"table", "ref":"mesh_stats" }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Output Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The output includes the computed values of validation measure in CSV files format, export visualization files (mesh, partitioning, temperature), and the time taken to perform each simulation step. Metric:"
+                                },
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "_benchmark-verification_",
+                                        "_strong-scalability_",
+                                        "_weak-scalability_",
+                                        "_io-scaling_ : time taken by the application to read meshes, and to write the solution on disk (especially reading)."
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results Summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"The thermal bridges benchmark has been executed on the Discoverer supercomputer at Unistra for the three mesh refinement levels (M1, M2, M3) using finite element approximations of order 1, 2, and 3. The results demonstrate both the accuracy of the numerical method through comparison with ISO 10211:2017 reference values, and the scalability of the implementation across multiple processors."
+                        },
+                        {
+                            "type":"section",
+                            "title":"Numerical solution",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The figure below shows the computed temperature field and the mesh partitioning used for parallel computation. The temperature distribution exhibits the expected heat transfer patterns through the thermal bridge, with the coldest regions in blue and the warmest in red. The partitioning visualization (right panel) demonstrates the load balancing strategy employed by the domain decomposition method, where different colors represent different processor domains."
+                                },
+                                {
+                                    "type":"grid",
+                                    "columns":2,
+                                    "align":"center",
+                                    "justify":"center",
+                                    "contents":[
+                                        {
+                                            "type":"image",
+                                            "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-thermalbridges-solution.png",
+                                            "caption":"Thermal bridges benchmarks - temperature solution"
+                                        },
+                                        {
+                                            "type":"image",
+                                            "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-thermalbridges-pid.png",
+                                            "caption":"Thermal bridges benchmarks - partitioning example"
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Mesh convergence",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The convergence study validates the numerical accuracy of the Feel++ implementation against the reference values provided by the ISO 10211:2017 standard. Figure 10.3 presents the convergence of key validation measures as a function of mesh refinement level."
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"The results demonstrate excellent agreement with reference values (shown as red dashed lines) for all three finite element orders (stem:[\\mathbb{P}_1,\\mathbb{P}_2,\\mathbb{P}_3]). Key observations include:"
+                                },
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "*Heat flux measurements*: All three polynomial orders converge to the reference values for heat flow measurements in the stem:[\\alpha], stem:[\\beta], and stem:[\\gamma] environments (46.09 W, 13.89 W, and 59.98 W respectively).",
+                                        "*Temperature measurements*: The minimum surface temperature in the stem:[\\alpha] environment converges to the reference value of 11.32°C across all mesh levels.",
+                                        "*Convergence rates*: Higher-order finite elements (stem:[\\mathbb{P}_2] and stem:[\\mathbb{P}_3]) achieve better accuracy on coarser meshes, demonstrating the efficiency of high-order methods for smooth solutions.",
+                                        "*Tolerance compliance*: All computed values fall within the tolerances specified by the ISO standard, confirming the correctness of the implementation."
+                                    ]
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"The benchmark metric _benchmark-verification_ confirms that the Feel++ thermal toolbox meets the accuracy requirements for building thermal analysis applications."
+                                },
+                                //TODO: Use grid when supported
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Convergence of validation measures (Heat flux)",
+                                        "plot_types": [ "scatter" ],
+                                        "xaxis": { "parameter": "mesh", "label": "mesh levels" },
+                                        "yaxis": { "label": "Heat flow [W]" },
+                                        "color_axis":{ "parameter": "discretization", "label":"Discretization" },
+                                        "secondary_axis":{
+                                            "parameter": "perfvalue",
+                                            "label": "Environment",
+                                            "filter": [
+                                                {"Outputs_Normal_Heat_Flux_alpha":"Alpha"},
+                                                {"Outputs_Normal_Heat_Flux_beta":"Beta"},
+                                                {"Outputs_Normal_Heat_Flux_gamma":"Gamma"}
+                                            ]
+                                        },
+                                        "aggregations":[ {"column":"resources.tasks","agg":"max"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Convergence of validation measures (Surface Temperatures)",
+                                        "plot_types": [ "scatter" ],
+                                        "xaxis": { "parameter": "mesh", "label": "mesh levels" },
+                                        "yaxis": { "label": "Temperature [°C]" },
+                                        "color_axis":{ "parameter": "discretization", "label":"Discretization" },
+                                        "secondary_axis":{
+                                            "parameter": "perfvalue",
+                                            "label": "Surface Temperature",
+                                            "filter":[
+                                                {"Outputs_Points_alpha_max_field_temperature":"Alpha (max)"},
+                                                {"Outputs_Points_alpha_min_field_temperature":"Alpha (min)"},
+                                                {"Outputs_Points_beta_max_field_temperature":"Beta (max)"},
+                                                {"Outputs_Points_beta_min_field_temperature":"Beta (min)"}
+                                            ]
+                                        },
+                                        "aggregations":[ {"column":"resources.tasks","agg":"max"} ]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Times of execution",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"The performance analysis focuses on the scalability of the main computational components: initialization, assembly, solving, and post-processing. Execution times were measured on the Discoverer supercomputer at Unistra for strong scalability tests, where the problem size remains constant while increasing the number of processors."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The figures in this section present both grouped and stacked bar charts showing the execution time breakdown for each mesh level and polynomial order. Key performance insights include:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Initialization*: The mesh loading and toolbox initialization shows good scalability, with decreasing times as processor count increases. This validates the efficiency of the parallel mesh partitioning strategy.",
+                                "*Assembly*: The finite element assembly phase represents a significant portion of total time and scales well for all mesh levels. Higher-order elements ( stem:[\\mathbb{P}_3] ) require more assembly time due to increased quadrature points and local matrix sizes.",
+                                "*Post-processing*: The export and validation phase (orange bars) remains relatively constant across processor counts, as it involves I/O operations that are less amenable to parallelization.",
+                                "*Strong scalability*: The total execution time decreases as the number of processors increases from 1 to 96, demonstrating effective parallel efficiency. The speedup is particularly pronounced for the larger meshes (M2 and M3) where the computational workload per processor remains substantial.",
+                                "*Load balancing*: The consistent performance across different processor counts indicates effective domain decomposition and minimal load imbalance."
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"The benchmark metrics _strong-scalability_ and _weak-scalability_ confirm that the Feel++ implementation achieves efficient parallel performance suitable for large-scale thermal analysis applications."
+                        },
+
+                        {
+                            "type": "section",
+                            "title": "P1 Discretization Performance",
+                            "contents": [
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Performance (P1)",
+                                        "plot_types": [ "grouped_bar" ],
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P1"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Speedup (P1)",
+                                        "plot_types": [ "scatter" ],
+                                        "transformation": "speedup",
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "Speedup" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P1"} ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "P2 Discretization Performance",
+                            "contents": [
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Performance (P2)",
+                                        "plot_types": [ "grouped_bar" ],
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P2"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Speedup (P2)",
+                                        "plot_types": [ "scatter" ],
+                                        "transformation": "speedup",
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "Speedup" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P2"} ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "P3 Discretization Performance",
+                            "contents": [
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Performance (P3)",
+                                        "plot_types": [ "grouped_bar" ],
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P3"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Speedup (P3)",
+                                        "plot_types": [ "scatter" ],
+                                        "transformation": "speedup",
+                                        "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "Speedup" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P3"} ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Scalability on I/O",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The I/O scalability analysis examines the performance of mesh loading and solution export operations as the number of processors and mesh size vary. The benchmark metric io-scaling measures the time required for file system operations during initialization and post-processing phases."
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"Key I/O performance characteristics observed:"
+                                },
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "*Parallel mesh loading*: The pre-partitioned mesh format (JSON+HDF5) enables efficient parallel loading, with read times scaling inversely with processor count. The initialization times shown in the performance charts demonstrate this scalability.",
+                                        "*Export operations*: Writing visualization files (EnSight Gold format) exhibits limited scalability due to file system contention when multiple processors write simultaneously. This is evident in the relatively constant post-processing times across different processor counts.",
+                                        "*Mesh size impact*: Larger meshes (M3 with 10.5M vertices) show more pronounced I/O bottlenecks compared to smaller meshes (M1 with 193K vertices), as the absolute amount of data written increases significantly.",
+                                        "*Recommendations*: For production runs, using collective I/O strategies and reducing the frequency of visualization exports can significantly improve overall performance. The HDF5-based mesh format provides good parallel I/O performance for mesh loading operations."
+                                    ]
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"These I/O characteristics are typical for large-scale finite element simulations and inform best practices for configuring output frequencies in production simulations."
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Solver Metrics",
+                    "contents": [
+                        {
+                            "type": "plot",
+                            "plot": {
+                                "title": "Algebraic-solve execution time",
+                                "plot_types": [ "grouped_bar","marked_scatter" ],
+                                "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                "yaxis": { "label": "execution time (s)" },
+                                "color_axis":{ "parameter":"mesh", "label":"Mesh" },
+                                "secondary_axis":{ "parameter":"discretization", "label":"Discretization" },
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:Solve_algebraic-solve"} ]
+                            }
+                        },
+                        {
+                            "type": "plot",
+                            "plot": {
+                                "title":"Number of iterations of GMRES",
+                                "plot_types":["scatter","marked_scatter"],
+                                "xaxis":{ "parameter":"resources.tasks", "label":"Number of tasks" },
+                                "yaxis":{ "label":"Number of iterations" },
+                                "color_axis":{ "parameter":"mesh", "label":"Mesh" },
+                                "secondary_axis":{ "parameter":"discretization", "label":"Discretization" },
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:Solve_ksp-niter"} ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-discr-1/heat_plots.json b/src/app-feelpp-discr-1/heat_plots.json
deleted file mode 100644
index f8b55b2..0000000
--- a/src/app-feelpp-discr-1/heat_plots.json
+++ /dev/null
@@ -1,95 +0,0 @@
-{
-    "plots": [
-        {
-            "title": "Validation measures",
-            "plot_types": [ "scatter" ],
-            "transformation": "performance",
-            "variables": [
-                "Outputs_Normal_Heat_Flux_alpha", "Outputs_Normal_Heat_Flux_beta", "Outputs_Normal_Heat_Flux_gamma",
-                "Outputs_Points_alpha_max_field_temperature", "Outputs_Points_alpha_min_field_temperature",
-                "Outputs_Points_beta_max_field_temperature", "Outputs_Points_beta_min_field_temperature",
-                "Outputs_Statistics_temperature_alpha_max", "Outputs_Statistics_temperature_alpha_min",
-                "Outputs_Statistics_temperature_beta_max", "Outputs_Statistics_temperature_beta_min"
-            ],
-            "names": [ ],
-            "xaxis": { "parameter": "mesh", "label": "mesh levels" },
-            "yaxis": { "label": "Heat flow [W]" },
-            "color_axis":{ "parameter": "discretization", "label": "Discretization" },
-            "secondary_axis":{ "parameter": "performance_variable", "label": "Measures" },
-            "aggregations": [ {"column": "resources.tasks", "agg": "filter:128"} ]
-        },
-        {
-            "title": "General Performance (P1)",
-            "plot_types": ["stacked_bar", "grouped_bar"],
-            "transformation": "performance",
-            "variables": ["Constructor_init","Solve_solve","PostProcessing_exportResults"],
-            "names": ["Constructor", "solve", "PostProcessing" ],
-            "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
-            "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
-            "yaxis": { "label": "execution time (s)" },
-            "color_axis":{ "parameter": "performance_variable", "label": "Performance variable" },
-            "aggregations": [ {"column": "discretization", "agg": "filter:P1"} ]
-        },
-        {
-            "title": "General Performance (P2)",
-            "plot_types": ["stacked_bar", "grouped_bar"],
-            "transformation": "performance",
-            "variables": ["Constructor_init","Solve_solve","PostProcessing_exportResults"],
-            "names": ["Constructor", "solve", "PostProcessing" ],
-            "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
-            "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
-            "yaxis": { "label": "execution time (s)" },
-            "color_axis":{ "parameter": "performance_variable", "label": "Performance variable" },
-            "aggregations": [ {"column": "discretization", "agg": "filter:P2"} ]
-        },
-        {
-            "title": "General Performance (P3)",
-            "plot_types": ["stacked_bar", "grouped_bar"],
-            "transformation": "performance",
-            "variables": ["Constructor_init","Solve_solve","PostProcessing_exportResults"],
-            "names": ["Constructor", "solve", "PostProcessing" ],
-            "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
-            "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
-            "yaxis": { "label": "execution time (s)" },
-            "color_axis":{ "parameter": "performance_variable", "label": "Performance variable" },
-            "aggregations": [ {"column": "discretization", "agg": "filter:P3"} ]
-        },
-        {
-            "title": "Reading mesh measures",
-            "plot_types": ["grouped_bar", "stacked_bar", "scatter"],
-            "transformation": "performance",
-            "variables": ["Journal_readElements_time","Journal_readPoints_time","Journal_readStats_time"],
-            "names": ["read elements", "read points", "read stats" ],
-            "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
-            "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
-            "yaxis": { "label": "execution time (s)" },
-            "color_axis":{ "parameter": "performance_variable", "label": "Performance variable" },
-            "aggregations": [ {"column": "discretization", "agg": "filter:P1"} ]
-        },
-        {
-            "title": "Number of iterations of GMRES",
-            "plot_types": ["scatter"],
-            "transformation": "performance",
-            "variables": ["Solve_ksp-niter"],
-            "names": ["ksp"],
-            "xaxis":{
-                "parameter": "resources.tasks",
-                "label": "Number of tasks"
-            },
-            "yaxis":{
-                "label": "Number of iterations"
-            },
-            "color_axis":{
-                "parameter": "mesh",
-                "label": "Mesh"
-            },
-            "secondary_axis":{
-                "parameter": "discretization",
-                "label": "Discretization"
-            },
-            "aggregations": [
-                {"column": "performance_variable","agg": "filter:Solve_ksp-niter"}
-            ]
-        }
-    ]
-}
\ No newline at end of file
diff --git a/src/app-feelpp-distance/CMakeLists.txt b/src/app-feelpp-distance/CMakeLists.txt
index 4438a24..abf37b8 100644
--- a/src/app-feelpp-distance/CMakeLists.txt
+++ b/src/app-feelpp-distance/CMakeLists.txt
@@ -1 +1,2 @@
-feelpp_add_application(distance SRCS distance.cpp DEFS FEELPP_DIM=3)
\ No newline at end of file
+feelpp_add_application(distance SRCS distance.cpp DEFS FEELPP_DIM=3)
+install(TARGETS feelpp_app_distance RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
\ No newline at end of file
diff --git a/src/app-feelpp-distance/feelpp-distance.json b/src/app-feelpp-distance/feelpp-distance.json
index 3ad300b..08d684f 100644
--- a/src/app-feelpp-distance/feelpp-distance.json
+++ b/src/app-feelpp-distance/feelpp-distance.json
@@ -1,87 +1,84 @@
 {
-  "executable": "$PWD/build/default/src/app-feelpp-distance/feelpp_app_distance",
-  "output_directory": "{{machine.output_app_dir}}/app-feelpp-distance/distance",
-  "use_case_name": "distance",
-  "timeout": "0-02:00:00",
-  "resources": {
-    "tasks": "{{parameters.tasks.value}}",
-    "exclusive_access": false
-  },
-  "input_file_dependencies": {
-    "config": "src/app-feelpp-distance/dist2.cfg",
-    "geometry": "src/app-feelpp-distance/dist.geo"
-  },
-  "platforms": {
-    "apptainer": {
-      "image": {
-        "filepath": "{{machine.containers.apptainer.image_base_dir}}/feelpp-noble.sif"
-      },
-      "input_dir": "/input_data",
-      "options": [
-        "--home {{machine.output_app_dir}}",
-        "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}",
-        "--env OMP_NUM_THREADS=1"
-      ],
-      "append_app_option": []
+    "executable": "feelpp_app_distance",
+    "use_case_name": "cube",
+    "output_directory": "{{machine.output_app_dir}}/app_feelpp_distance/cube",
+    "timeout": "0-00:10:00",
+    "resources": {
+        "tasks": "{{parameters.tasks.value}}",
+        "exclusive_access": true
     },
-    "builtin": {
-      "input_dir": "{{machine.input_dataset_base_dir}}",
-      "append_app_option": []
-    }
-  },
-  "options": [
-    "--directory {{output_directory}}/{{instance}}/{{use_case_name}}",
-    "--h {{parameters.h.value}}",
-		"--M {{parameters.M.value}}",
-    "--repository.append.np 0",
-    "--config-file $PWD/{{input_file_dependencies.config}}"
-  ],
-  "additional_files": {
-    "custom_logs": [
-      "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/{{executable}}.INFO",
-      "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/{{executable}}.WARNING"
-    ]
-  },
-  "scalability": {
-    "directory": "{{output_directory}}/{{instance}}/{{use_case_name}}",
-    "clean_directory": true,
-    "stages": [
-      {
-        "name": "times",
-        "filepath": "measures.json",
-        "format": "json",
-        "variables_path": "time.*",
-        "units": {
-          "*": "s"
-        }
-      },
-			{
-        "name": "errors",
-        "filepath": "measures.json",
-        "format": "json",
-        "variables_path": "error.*",
-        "units": {
-          "*": "s"
+    "input_file_dependencies": {
+        "config": "$PWD/src/app-feelpp-distance/dist2.cfg",
+        "geometry": "$PWD/src/app-feelpp-distance/dist.geo"
+    },
+    "platforms": {
+        "apptainer":{
+            "image": {
+                "filepath":"{{machine.containers.apptainer.image_base_dir}}/apps-feelpp.sif"
+            },
+            "input_dir":"/input_data",
+            "options": [
+                "--home {{machine.output_app_dir}}",
+                "--bind $PWD/src/app-feelpp-distance/:{{platforms.apptainer.input_dir}}",
+                "--env OMP_NUM_THREADS=1"
+            ]
+        },
+        "builtin": {
+            "input_dir": "$PWD/src/app-feelpp-distance"
         }
-      }
-    ]
-  },
-  "sanity": {
-    "success": [],
-    "error": []
-  },
-  "parameters": [
-    {
-      "name": "tasks",
-			"sequence": [1, 2, 4, 8, 16, 32, 64, 128, 256]
     },
-    {
-      "name": "h",
-      "sequence": [0.12, 0.06, 0.03, 0.015]
+    "options": [
+        "--directory {{output_directory}}/{{instance}}/{{use_case_name}}",
+        "--h {{parameters.h.value}}",
+        "--M {{parameters.M.value}}",
+        "--repository.append.np 0",
+        "--config-file {{input_file_dependencies.config}}"
+    ],
+    "additional_files": {
+        "custom_logs": [
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_app_distance.INFO",
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_app_distance.WARNING"
+        ]
     },
-    {
-      "name": "M",
-      "sequence": [1000, 1500, 2000, 2500]
-    }
-	]
+    "scalability": {
+        "directory": "{{output_directory}}/{{instance}}/{{use_case_name}}",
+        "clean_directory": false,
+        "stages": [
+            {
+                "name": "times",
+                "filepath": "measures.json",
+                "format": "json",
+                "variables_path": "time.*",
+                "units": { "*": "s" }
+            },
+            {
+                "name": "errors",
+                "filepath": "measures.json",
+                "format": "json",
+                "variables_path": "error.*",
+                "units": { "*": "s" }
+            }
+        ]
+    },
+    "sanity": {
+        "success": [],
+        "error": []
+    },
+    "parameters": [
+        {
+            "name": "tasks",
+            // "sequence": [ 1,2,4,8,16,32,64,128,256]
+            "sequence": [ 1]
+        },
+        {
+            "name": "h",
+            // "sequence": [ 0.12, 0.06, 0.03, 0.015 ]
+            "sequence": [ 0.12]
+        },
+        {
+            "name": "M",
+            // "sequence": [ 1000, 1500, 2000, 2500]
+            "sequence": [ 1000]
+        }
+    ]
 }
\ No newline at end of file
diff --git a/src/app-feelpp-distance/plots.json b/src/app-feelpp-distance/plots.json
index ac0d56a..235b898 100644
--- a/src/app-feelpp-distance/plots.json
+++ b/src/app-feelpp-distance/plots.json
@@ -1,160 +1,301 @@
 {
-  "plots": [
-    {
-      "title": "Errors BVH",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["errors_L2_error_BVH"],
-      "names": ["BVH"],
-      "xaxis":{
-        "parameter": "M",
-        "label": "M"
-      },
-      "yaxis":{
-        "label": "Error"
-      },
-      "color_axis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "secondary_axis":{
-        "parameter": "tasks",
-        "label": "number of tasks"
-      }
-    },
-    {
-      "title": "Errors BVH",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["errors_L2_error_BVH"],
-      "names": ["BVH"],
-      "xaxis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "yaxis":{
-        "label": "Error"
-      },
-      "color_axis":{
-        "parameter": "M",
-        "label": "M"
-      },
-      "secondary_axis":{
-        "parameter": "tasks",
-        "label": "number of tasks"
-      }
-    },
-    {
-      "title": "Errors FMM",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["errors_L2_error_FMM"],
-      "names": ["FMM"],
-      "xaxis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "yaxis":{
-        "label": "Error"
-      },
-      "color_axis":{
-        "parameter": "M",
-        "label": "M"
-      },
-      "secondary_axis":{
-        "parameter": "tasks",
-        "label": "tasks"
-      }
-    },
+    "contents": [
+        {
+            "type":"section",
+            "title":"Compute distance to a range of entities",
+            "contents":[
+                {
+                    "type":"text",
+                    "text":"This mini-app computes signed distance fields on unstructured meshes, a fundamental operation in level-set methods, shape optimization, and computational geometry. Unlike the PDE solver demonstrators in other benchmarks, it compares algorithmic approaches (Fast Marching Method vs. BVH-based ray tracing) rather than discretization methods."
+                },
+                {
+                    "type":"text",
+                    "text":"The following table describes the specefications of the application"
+                },
+                { "type":"table", "ref":"demonstrator_descr" },
+                {
+                    "type":"section",
+                    "title":"Description of the benchmark",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"We consider the unit cube stem:[ [0, 1]^3 ] discretized by an unstructured tetrahedral mesh. Let stem:[h] denote the mesh size, controlling the total number of vertices stem:[N]. For each mesh vertex stem:[\\mathbf{x}_i] , our goal is to compute the Euclidean distance"
+                        },
+                        {
+                            "type":"latex",
+                            "latex":"\\begin{equation*}\n d(\\mathbf{x}_i) = \\min_{\\mathbf{y} \\in \\partial ([0,1]^3) }  ||\\mathbf{x}_i  - \\mathbf{y} ||_2 \\end{equation*}"
+                        },
+                        {
+                            "type":"text",
+                            "text":"The exact analytical distance on the unit cube is"
+                        },
+                        {
+                            "type":"latex",
+                            "latex":"\\begin{equation*}\n  d_{\\text{exact}}(x,y,z) = \\min{ {x, 1-x, y, 1-y,z, 1-z} }  \\end{equation*}"
+                        },
+                        {
+                            "type":"text",
+                            "text":"We compare two numerical strategies to build a continuous piecewise-linear (P1) distance field over the mesh."
+                        },
+                        {
+                            "type":"text",
+                            "text":"More details can be found in (Van Landeghem, 2025)."
+                        },
+                        {
+                            "type":"section",
+                            "title":"Fast-Marching Method (FMM)",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "*Initialization*: Tag all boundary vertices of the mesh as known with stem:[d = 0].",
+                                        "*Propagation*: Maintain a narrowband of trial vertices adjacent to known ones. Repeatedly extract the trial vertex with the minimal tentative distance, mark it known, and update neighboring trial vertices by solving local upwind discretization of the eikonal equation stem:[|| \\nabla d = 1 ||].",
+                                        "*Output*: A P1 scalar field stem:[d_h(\\mathbf{x})] approximating the true distance"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Ray-Tracing with BVH",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "*Preprocessing*: Build a Bounding Volume Hierarchy (BVH) over the mesh boundary faces or directly on the analytic cube faces.",
+                                        "*Directional Sampling*: Since the cube geometry is known, but the nearest boundary direction is unknown, for each vertex stem:[\\mathbf{x}_i] we uniformly sample directions on the unit sphere. Let stem:[M] be the number of rays per point, which becomes a key parameter for accuracy and cost.",
+                                        "*Ray Casting*: For each sampled direction, cast a ray from stem:[\\mathbf{x}_i] into the BVH and record the intersection distance. The estimated distance is the minimum over all sampled rays: stem:[d_h (\\mathbf{x}_i) = \\min_{1 \\le j \\le M}{t_j}], where stem:[t_j] is the distance alog ray stem:[j] to the boundary.",
+                                        "*Output*: A P1 field stem:[d_h(\\mathbf{x})] by assigning the computed distance at each vertex."
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmark Execution Summary",
+                    "contents": [
+                        {
+                            "type":"section",
+                            "title":"Session",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Hostname: @{session_info.hostname}@",
+                                        "User: @{session_info.user}@",
+                                        "Time Start: @{session_info.time_start}@",
+                                        "Time End: @{session_info.time_end}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Cases",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Total: @{session_info.num_cases}@ ",
+                                        "Failures: @{session_info.num_failures}@",
+                                        "Runs: @{runs | length}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Parametrization",
+                            "contents":[
+                                {
+                                    "type":"table",
+                                    "ref": "parameter_table",
+                                    "layout":{
+                                        "column_order":["result","testcases.hashcode","tasks","M", "h", "testcases.time_total", "logs_link"],
+                                        "rename":{
+                                            "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash",
+                                            "result":"", "logs_link":""
+                                        }
+                                    },
+                                    "style":{
+                                        "column_align":{ "result":"center" },
+                                        "column_width":{ "result":1,"logs_link":1},
+                                        "classnames":["scrollable","sortable"]
+                                    },
+                                    "filter":{ "placeholder":"Filter testcases..." }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text": "This benchmark was performed on the @{runs.0.testcases.0.system}@ supercomputer, using feelpp.benchmaring (*v.{feelpp_benchmarking_version}*)."
+                        },
+                        {
+                            "type":"text",
+                            "text":"Let stem:[d_h] be the discrete distance field computed by either method. We compute the error norms"
+                        },
+                        {
+                            "type":"latex",
+                            "latex":"\\begin{equation*}\n  || d_h - d_{\\text{exact}} ||_{L^2} = ( \\sum_{i=1}^{N}(d_h(\\mathbf{x}_i) - d_{\\text{exact}(\\mathbf{x}_i)} )^2 )^{1/2} \\end{equation*}"
+                        },
+                        {
+                            "type":"latex",
+                            "latex":"\\begin{equation*}\n || d_h - d_{\\text{exact}} ||_{L^\\infty}  = \\max_{i=1,...,N} |d_h(\\mathbf{x}_i) - d_{\\text{exact}}(\\mathbf{x}_i)|  \\end{equation*}"
+                        },
+                        {
+                            "type":"text",
+                            "text":"We perform a convergence study over meshes with stem:[h = h_0, h_0/2, h_0/4, ...] , verifying that FMM yields stem:[O(h)] convergence, while ray tracing achieves machine precision at vertices."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data:",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "Meshes: we use cubic meshes with various discretization sizes: stem:[h = 0.12, 0.06, 0.03, 0.015].",
+                                        "Setup: the FMM method is provided by the core library of Feel++, and the BVH implementation uses Feel++ functionality. More details can be found in (Van Landeghem, 2025)."
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Output Data:",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The output data monitored are the stem:[L^2] error committed by the two methods on the benchmark, as described in Equation in section <<Benchmarking Tools Used>>, as well as the time of execution to compute the distance for all points stem:[\\mathbf{x}_i] in the mesh."
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"We present results for the benchmark described above. In the figure (a) below, we show the exact distance between each point of the cube to the border. The cube is vertically half-sliced."
+                        },
+                        {
+                            "type":"text",
+                            "text":"Figure (b) and Figure (c) show the distribution of the pointwise error for FMM and BVH, respectively. For this specific plot, we took stem:[h = 0.06] and stem:[M = 1500]. We note that the BVH method results in a smaller global error, while it is more localized for the FMM method."
+                        },
+                        {
+                            "type":"grid",
+                            "columns":3,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-distance-exact.png",
+                                    "caption":"Exact distance stem:[d_{\\text{exact}}]"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-distance-errorFMM.png",
+                                    "caption":"Error by the method FMM: stem:[ | d_{\\text{FMM}} - d_{\\text{exact}} |]"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-distance-errorBVH.png",
+                                    "caption":"Error by the method BVH: stem:[ | d_{\\text{BVH}} - d_{\\text{exact}} |]"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"We now present some results of convergence. Note that in some cases (very fine meshes or large numbers of rays), the BVH method did not finish due to memory requirements."
+                        },
+                        {
+                            "type":"text",
+                            "text":"We show in figures below the evolution of the time taken by the two methods according to the number of parallel processes used. The first result is that FMM takes less time than BVH, independently of the configuration. We also see that when more cores are used, we do not see improvement in the time of execution."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Execution time (BVH and FMM) by number of tasks",
+                                "plot_types":["marked_scatter"],
+                                "xaxis":{"parameter":"tasks","label":"Number of tasks"},
+                                "yaxis":{"label":"Time [s]"},
+                                "color_axis":{ "parameter": "h", "filter":["0.12","0.06"] },
+                                "secondary_axis":{"parameter":"perfvalue", "filter":[
+                                    {"times_time_BVH":"BVH"},
+                                    {"times_time_FMM":"FMM"}
+                                ]},
+                                "aggregations":[ {"column":"M","agg":"max"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Comparison of speedup for BVH and FMM",
+                                "transformation":"speedup",
+                                "plot_types":["marked_scatter"],
+                                "xaxis":{"parameter":"tasks","label":"Number of tasks"},
+                                "yaxis":{"label":"Speedup"},
+                                "color_axis":{ "parameter": "h", "filter":["0.12","0.06"] },
+                                "secondary_axis":{"parameter":"perfvalue", "filter":[
+                                    {"times_time_BVH":"BVH"},
+                                    {"times_time_FMM":"FMM"}
+                                ]},
+                                "aggregations":[ {"column":"M","agg":"max"} ]
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"Now, we focus on the impact of the number of ray cast in the BVH method. Figure below displays the evolution of the L2 error depending on the number of ray M, for various sizes of mesh. We see that the precision of the method for this specific benchmark is not impacted by this parameter. On the other hand, we see that it is impacted by the size of the mesh."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Evolution of BVH error by number of ray casts",
+                                "plot_types":["scatter"],
+                                "xaxis":{"parameter":"M","label":"Number of rays"},
+                                "yaxis":{"label":"$\\text{Error} L^2$"},
+                                "color_axis":{ "parameter": "h" },
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:errors_L2_error_BVH"} ]
 
-
-    {
-      "title": "Time BVH",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["times_time_BVH"],
-      "names": ["BVH"],
-      "xaxis":{
-        "parameter": "tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "secondary_axis":{
-        "parameter": "M",
-        "label": "M"
-      }
-    },
-    {
-      "title": "Time FMM",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["times_time_FMM"],
-      "names": ["FMM"],
-      "xaxis":{
-        "parameter": "tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "secondary_axis":{
-        "parameter": "M",
-        "label": "M"
-      }
-    },
-    {
-      "title": "Speedup BVH",
-      "plot_types": ["scatter"],
-      "transformation": "speedup",
-      "variables": ["times_time_BVH"],
-      "names": ["BVH"],
-      "xaxis":{
-        "parameter": "tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "secondary_axis":{
-        "parameter": "M",
-        "label": "M"
-      }
-    },
-    {
-      "title": "Speedup FMM",
-      "plot_types": ["scatter"],
-      "transformation": "speedup",
-      "variables": ["times_time_FMM"],
-      "names": ["BVH"],
-      "xaxis":{
-        "parameter": "tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "h",
-        "label": "h"
-      },
-      "secondary_axis":{
-        "parameter": "M",
-        "label": "M"
-      }
-    }
-  ]
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"Precisely, the next figure shows the convergence regarding the size of the discretization, we see a convergence at the order 1.5. "
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Convergence of the error against mesh size.",
+                                "plot_types":["scatter"],
+                                "xaxis":{"parameter":"h"},
+                                "yaxis":{"label":"$\\text{Error} L^2$"},
+                                "color_axis":{ "parameter": "M" },
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:errors_L2_error_BVH"} ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
 }
\ No newline at end of file
diff --git a/src/app-feelpp-io/CMakeLists.txt b/src/app-feelpp-io/CMakeLists.txt
index 94d6999..e050f2e 100644
--- a/src/app-feelpp-io/CMakeLists.txt
+++ b/src/app-feelpp-io/CMakeLists.txt
@@ -1 +1,2 @@
 feelpp_add_application(io SRCS feelpp-io.cpp)
+install(TARGETS feelpp_app_io RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
diff --git a/src/app-feelpp-io/feelpp-io.cpp b/src/app-feelpp-io/feelpp-io.cpp
index 7e3124e..49d6e7f 100644
--- a/src/app-feelpp-io/feelpp-io.cpp
+++ b/src/app-feelpp-io/feelpp-io.cpp
@@ -28,14 +28,17 @@ int run()
            time_export = 0;
     const int nRun = ioption( "nrun" );
 
+    int nPoints, nEdges, nFaces, nDofs;
+
     for (int i=0; i<nRun; ++i)
     {
         tic();
         auto mesh = loadMesh( _mesh=new mesh_t);
         time_loadMesh += toc("loadMesh");
-        // Feel::cout << "nPoints = " << mesh->numGlobalPoints() << std::endl;
-        // Feel::cout << "nEdged = " << mesh->numGlobalEdges() << std::endl;
-        // Feel::cout << "nFaces = " << mesh->numGlobalFaces() << std::endl;
+
+        nPoints = mesh->numGlobalPoints();
+        nEdges = mesh->numGlobalEdges();
+        nFaces = mesh->numGlobalFaces();
 
         tic();
         auto Xh = Pch<ORDER>(mesh);     // Scalar function space
@@ -45,6 +48,7 @@ int run()
         auto Xhv = Pchv<ORDER>(mesh);
         time_createFunctionSpaceV += toc("create vectorial function space");
         // Feel::cout << "nDof = " << Xh->nDof() << std::endl;
+        nDofs = Xh->nDof();
 
         auto u = Xh->element(Px() * Px() + 4 * Py() + cos(Pz()));
         auto uV = Xhv->element( "{x+y+z,x+y+z,x+y+z}:x:y:z" );
@@ -98,6 +102,11 @@ int run()
         std::ofstream ofs("time_measures.json");
         ofs << time_measures.dump(2);
         ofs.close();
+
+        std::ofstream ofsMeshSize("mesh_stats.csv");
+        ofsMeshSize << "nPoints,nEdges,nFaces,nDofs\n";
+        ofsMeshSize << nPoints << ","<< nEdges << "," << nFaces << "," << nDofs;
+        ofsMeshSize.close();
     }
 
     return 0;
@@ -110,7 +119,7 @@ int main(int argc, char** argv)
 
     po::options_description myoptions("my options");
     myoptions.add_options()
-        ( "nrun", Feel::po::value<int>()->default_value(10) )
+        ( "nrun", Feel::po::value<int>()->default_value(1) )
         ( "dimension", Feel::po::value<int>()->default_value(3) )
         ( "discretization", Feel::po::value<std::string>()->default_value("P1") )
     ;
diff --git a/src/app-feelpp-io/feelpp-io.json b/src/app-feelpp-io/feelpp-io.json
index 03c3a97..1da2e11 100644
--- a/src/app-feelpp-io/feelpp-io.json
+++ b/src/app-feelpp-io/feelpp-io.json
@@ -1,40 +1,38 @@
 {
-    "executable": "$PWD/build/default/src/app-feelpp-io/feelpp_app_io",
+    "executable": "feelpp_app_io",
     "output_directory": "{{machine.output_app_dir}}/app-feelpp-io/io",
-    "use_case_name": "eye-mesh",
-    "timeout":"0-01:00:00",
+    "use_case_name": "eye2brain",
+    "timeout":"0-00:30:00",
     "resources":{
-        "tasks":"{{parameters.resources.tasks.value}}",
-        "exclusive_access":"{{parameters.resources.exclusive_access.value}}"
+        "tasks":"{{parameters.tasks.value}}",
+        "exclusive_access":true
     },
     "input_file_dependencies":{
-        "mesh_json":"benchmark/Eye2Brain/mesh/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.resources.tasks.value}}.json",
-        "mesh_hdf5":"benchmark/Eye2Brain/mesh/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.resources.tasks.value}}.h5"
+        "mesh_json":"feelpp_toolboxes/eye/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.tasks.value}}.json",
+        "mesh_hdf5":"feelpp_toolboxes/eye/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.tasks.value}}.h5"
     },
     "platforms": {
         "apptainer":{
             "image": {
-                "filepath":"{{machine.containers.apptainer.image_base_dir}}/feelpp-noble.sif"
+                "filepath":"{{machine.containers.apptainer.image_base_dir}}/apps-feelpp.sif"
             },
             "input_dir":"/input_data",
             "options": [
                 "--home {{machine.output_app_dir}}",
                 "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}",
                 "--env OMP_NUM_THREADS=1"
-            ],
-            "append_app_option":[]
+            ]
         },
         "builtin":{
-            "input_dir":"{{machine.input_dataset_base_dir}}",
-            "append_app_option":[]
+            "input_dir":"{{machine.input_dataset_base_dir}}"
         }
     },
     "options": [
         "--directory {{output_directory}}/{{instance}}/{{use_case_name}}",
         "--discretization {{parameters.discretization.value}}",
         "--repository.append.np 0",
-        "--gmsh.filename $PWD/{{input_file_dependencies.mesh_json}}",
-        "--nrun 2"
+        "--gmsh.filename {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.mesh_json}}",
+        "--nrun 1"
     ],
     "additional_files":{
         "custom_logs":[
@@ -47,42 +45,34 @@
         "clean_directory":true,
         "stages": [
             {
-                "name": "timeMeasures",
+                "name": "",
                 "filepath": "time_measures.json",
                 "format": "json",
                 "variables_path": "time.*",
                 "units": { "*": "s"}
+            },
+            {
+                "name":"meshStats",
+                "filepath":"mesh_stats.csv",
+                "format":"csv"
             }
         ]
     },
-    "sanity": {
-        "success": [],
-        "error": []
-    },
     "parameters": [
         {
-            "name": "resources",
-            "zip":[
-                {
-                    "name":"tasks",
-                    "sequence":[1, 2, 4, 8, 16, 64, 96, 128, 256]
-                },
-                {
-                    "name":"exclusive_access",
-                    "repeat":{"value": true, "count": 10}
-                }
-            ]
+            "name":"tasks",
+            "sequence":[1,64,128]
         },
         {
             "name":"mesh",
-            "sequence":["M2", "M3", "M4", "M5"],
+            "sequence":["M2","M3","M4","M5"],
             "conditions":{
-                "M5":[{ "resources.tasks":[1, 2, 4, 8, 16, 64, 96] }]
+                "M5":[{"discretization":["P1","P2"]}]
             }
         },
         {
             "name":"discretization",
-            "sequence":["P1", "P2", "P3", "P4", "P5", "P6"]
+            "sequence":["P1","P2","P3","P4","P5","P6"]
         }
     ]
 }
diff --git a/src/app-feelpp-io/plots.json b/src/app-feelpp-io/plots.json
index 5a3af2b..342f1af 100644
--- a/src/app-feelpp-io/plots.json
+++ b/src/app-feelpp-io/plots.json
@@ -1,316 +1,447 @@
 {
-  "plots": [
-    {
-      "title": "Time to load Mesh",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_loadMesh"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to generate function space",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_functionSpace"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to generate vectorial function space",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_functionSpaceV"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to export Mesh",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveMesh"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to write field on disk",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveField"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to write vector field on disk",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveFieldV"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
-    {
-      "title": "Time to write data on disk",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_export"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      }
-    },
+    "data":[
+        {
+            "name":"mesh_nDof_stats", "ref":"reframe_df",
+            "table_options":{
+                "filter":[
+                    { "column":"perfvalue", "op":"in", "value":["meshStats_nDofs"] }
+                ],
+                "pivot":{
+                    "index":["mesh"], "columns":["discretization"], "values":"value", "agg":"mean"
+                }
+            }
+        },
+        {
+            "name":"mesh_stats", "ref":"reframe_df",
+            "table_options":{
+                "filter":[
+                    { "column":"perfvalue", "op":"in", "value":["meshStats_nPoints","meshStats_nEdges","meshStats_nFaces"] }
+                ],
+                "pivot":{
+                    "index":["mesh"], "columns":["perfvalue"], "values":"value", "agg":"mean"
+                },
+                "format":{
+                    "meshStats_nPoints":"%i",
+                    "meshStats_nEdges":"%i",
+                    "meshStats_nFaces":"%i"
+                }
+            }
+        },
+        {
+            "name":"demonstrator_descr",
+            "columns":[
+                {
+                    "name":"Field",
+                    "values":[
+                        "id", "name", "Partners", "PC", "Responsible", "WP7 Engineer", "work_package", "application_type",
+                        "purpose", "Method-Algorithm WP1", "Method-Algorithm WP2", "Method-Algorithm WP3", "Method-Algorithm WP4",
+                        "Method-Algorithm WP5", "Method-Algorithm WP6", "WP7", "outputs", "metrics", "status", "Benchmark scope",
+                        "Framework", "parallel_framework", "spec_due", "proto_due", "repo_url"
+                    ]
+                },
+                {
+                    "name":"Details",
+                    "values":[
+                        "app-feelpp-io", "Test I/O at large scale", "Unistra", "PC1 - ExaMA, PC2 - ExaSoft",
+                        "(Permanent) V. Chabannes, C. Prud'homme", "Thomas Saigre, Javier Cladellas (UNISTRA)",
+                        "WP1, WP6", "mini-app", "Benchmark parallel I/O performance for mesh loading andfield export operations",
+                        "finite element spaces, mesh partitioning", " ", " ", " ", " ", "parallel I/O, HDF5, file system performance",
+                        " ", "HDF5 data files, VTK/EnSight exports, JSON performance metrics", "io-scaling, strong-scalability",
+                        "benchmark-ready", "io-performance, scaling-analysis", "Feel++, PETSc", "MPI", "6/15/2025", "7/1/2025",
+                        "https://github.com/numpex/apps-feelpp"
+                    ]
+                }
+            ]
+        }
+    ],
+    "contents":[
+        {
+            "type":"section",
+            "title":"Mini App: Test I/O at large scale",
+            "contents":[
+                {
+                    "type":"text",
+                    "text":"This mini-app tests large-scale I/O for Feel++. The I/O operations measured here are representative of those performed in the demonstrators, where mesh loading and field export can become performance bottlenecks for large-scale simulations."
+                },
+                {
+                    "type":"text",
+                    "text":"The following table describes the specefications of the application"
+                },
+                { "type":"table", "ref":"demonstrator_descr" },
+                {
+                    "type":"section",
+                    "title":"Description of the benchmark",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"This mini-app repeats the following steps a given number of times:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "Load a mesh stem:[\\mathcal{M}] with discretization size stem:[h]",
+                                "Create a function space stem:[X_h = P_{c,h}^d] for the desired discretization order stem:[d]",
+                                "Create a vector-valued function space stem:[ \\mathbf{X}_h = ( P_{c,h}^d )^3 ]",
+                                "Create a vector stem:[u \\in X_h] and export it to disk",
+                                "Create a vector stem:[\\mathbf{u} \\in \\mathbf{X}_h] and export it to disk",
+                                "Write the loaded mesh to disk"
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"Exports are performed in two ways: _(i)_ write at format HDF5 on the disk directly, _(ii)_ use the _exporter_ functionality of Feel++. For the second, we provide more details. The two fields are interpolated to a stem:[\\mathbb{P}_1] field before being saved on the disk. The mesh is also exported in this process. The time measured is the time to perform projections of stem:[u] and stem:[\\mathbf{u}] and to save the files."
+                        },
+                        {
+                            "type":"text",
+                            "text":"This whole process is iterated a given number of times."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmark Execution Summary",
+                    "contents": [
+                        {
+                            "type":"section",
+                            "title":"Session",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Hostname: @{session_info.hostname}@",
+                                        "User: @{session_info.hostname}@",
+                                        "Time Start: @{session_info.time_start}@",
+                                        "Time End: @{session_info.time_end}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Cases",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "ref":"reframe_json",
+                                    "items":[
+                                        "Total: @{session_info.num_cases}@ ",
+                                        "Failures: @{session_info.num_failures}@",
+                                        "Runs: @{runs | length}@"
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Parametrization",
+                            "contents":[
+                                {
+                                    "type":"table",
+                                    "ref": "parameter_table",
+                                    "layout":{
+                                        "column_order":["result","testcases.hashcode","tasks","mesh", "discretization", "testcases.time_total", "logs_link"],
+                                        "rename":{ "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash", "result":"", "logs_link":"" }
+                                    },
+                                    "style":{
+                                        "column_align":{ "result":"center" },
+                                        "column_width":{ "result":1,"logs_link":1},
+                                        "classnames":["scrollable","sortable"]
+                                    },
+                                    "filter":{ "placeholder":"Filter testcases..." }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text": "This benchmark was performed on the @{runs.0.testcases.0.system}@ supercomputer, using feelpp.benchmaring (*v.{feelpp_benchmarking_version}*). The performance tools integrated into the Feel++-toolboxes framework were used to measure the execution time."
+                        },
+                        {
+                            "type":"text",
+                            "text":"This mini app can be run with any mesh family. The results presented in this document are obtained with a 3D mesh of a realistic geometry of a human eyeball (Saigre, Prud'Homme, & Szopos, 2024), with various level of refinement. The steps to obtain this mesh, stemming from a human eyeball CAD are presented in (Chabannes et al., 2024). The figure below presents the mesh, and the level disparity of the refinement according to the region considered."
+                        },
+                        {
+                            "type":"image",
+                            "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-eyemesh.png",
+                            "caption":"Mesh discretization, with the various regions of the eye."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "Meshes: We have generated meshes of various refinement levels, denoted _M2_ to _M5_. The characteristics of the meshes, as well as the number of degrees of freedom for various discretization orders, are presented in Table below. All meshes are pre-partitioned with the application _feelpp_mesh_partitionner_ (https://docs.feelpp.org/user/latest/using/tools/mesh_partitioner.html)",
+                                        "Setup: use the function provided by the library Feel++, such as mesh manipulation and data exporter. The full source code is available in _src_ directory of the GitHub repository _apps-feelpp_.",
+                                        "Sif image: _feelpp:v0.111.0-preview.10-noble-sif_ (stored in the GitHub registry of Feel++)"
+                                    ]
+                                },
+                                {
+                                    "type":"table",
+                                    "ref":"mesh_stats",
+                                    "layout":{
+                                        "column_order":["mesh","meshStats_nPoints","meshStats_nEdges","meshStats_nFaces"],
+                                        "rename":{
+                                            "mesh":"Mesh", "meshStats_nPoints":"# Points", "meshStats_nEdges":"# Edges", "meshStats_nFaces":"# Faces"
+                                        }
+                                    },
+                                    "style":{
+                                        "column_align":{ "mesh":"center","meshStats_nPoints":"center","meshStats_nEdges":"center","meshStats_nFaces":"center"},
+                                        "column_width":{ "mesh":1 }
+                                    }
+                                },
+                                //Currently cant put it on the same table due to supported operation limitations
+                                {
+                                    "type":"table",
+                                    "ref":"mesh_nDof_stats",
+                                    "layout":{
+                                        "rename":{ "mesh":"Mesh" }
+                                    },
+                                    "style":{
+                                        "column_align":{ "mesh":"center" },
+                                        "column_width":{ "mesh":1 }
+                                    }
+                                }
 
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Output Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The monitored quantities are the average times for each of the steps run in the loop described above: _(i) time_loadMesh_, the time taken by the application to load the mesh from the disk; _(ii) time_createFunctionSpace_, the time taken to create the functional space stem:[X_h] or order stem:[d]; _(iii) time_saveMesh_, the time taken to write the mesh data on the disk, in a new file; _(iv) time_export_, the time to export the vector stem:[u \\in X_h] to disk, using the exporter functionality of Feel++. The times are stored in a JSON file during execution."
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text":"We present in the figures below results over the mesh family for various numbers of parallel tasks. The mini-app is run on the cluster @{runs.0.testcases.0.system}@. The results presented are obtained with the degree of discretization stem:[\\mathbb{P}_1]. Similar behavior is observed for other discretization orders. "
+                        },
+                        {
+                            "type":"text",
+                            "text":"Note that some points are missing, either because the memory required exceeded what was available on a compute node, or because the iterative process took longer than the job timeout."
+                        },
+                        {
+                            "type":"text",
+                            "text":"We see that mesh reading and function-space creation scale well with the number of parallel processes with a limit reached at np = 96 for the small meshes."
+                        },
+                        {
+                            "type":"text",
+                            "text":"Conversely, the steps writing data to disk do not scale with more parallel processes. Times increase or stagnate This loss of performance stems from coordination among parallel processes when writing to a single destination. Because the mesh is pre-partitioned, the reading step does not suffer the same issue."
+                        },
 
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "Load Mesh",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:loadMesh"} ]
+                            }
+                        },
 
 
-    {
-      "title": "Time to load mesh",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_loadMesh"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-    {
-      "title": "Time to create function space",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_functionSpace"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-        {
-      "title": "Time to create vectorial function space",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_functionSpaceV"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-    {
-      "title": "Time to save mesh",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveMesh"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-    {
-      "title": "Time to write field on disk",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveField"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-        {
-      "title": "Time to write vector field on disk",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_saveFieldV"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    },
-    {
-      "title": "Time to export field",
-      "plot_types": ["scatter"],
-      "transformation": "performance",
-      "variables": ["timeMeasures_export"],
-      "names": ["ksp"],
-      "xaxis":{
-        "parameter": "discretization",
-        "label": "Discretization"
-      },
-      "yaxis":{
-        "label": "Time [s]"
-      },
-      "color_axis":{
-        "parameter": "mesh",
-        "label": "Mesh"
-      },
-      "secondary_axis":{
-        "parameter": "resources.tasks",
-        "label": "Number of tasks"
-      }
-    }
-  ]
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "Save Mesh as HDF5 on disk ",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveMesh"} ]
+                            }
+                        },
+
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Create function space } X_h$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:functionSpace"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Create vector function space } \\mathbf{X}_h$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:functionSpaceV"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Export the field } u \\text{ as HDF5 format on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveField"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Export the vector field } \\mathbf{u} \\text{ as HDF5 format on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveFieldV"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Ensight export of the vectors } u \\text{ and } \\mathbf{u} \\text{ and the mesh on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "tasks", "label": "np" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"discretization","label":"Discretization"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:export"} ]
+                            }
+                        },
+
+                        {
+                            "type":"text",
+                            "text":"Now, we present in the next figures the evolution of the time taken by each step, depending on the degree of discretization considered. Specifically, we can see that the mesh manipulation is indeed independent of the degree of discretization."
+                        },
+                        {
+                            "type":"text",
+                            "text":"Conversely, other steps are impacted by the discretization order through the increased number of degrees of freedom (see table in <<Input Data>> section). We can see that time increases roughly linearly with order, with a larger increase for disk writes."
+                        },
+
+
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "Load Mesh",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:loadMesh"} ]
+                            }
+                        },
+
+
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "Save Mesh as HDF5 on disk ",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveMesh"} ]
+                            }
+                        },
+
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Create function space } X_h$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:functionSpace"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Create vector function space } \\mathbf{X}_h$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:functionSpaceV"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Export the field } u \\text{ as HDF5 format on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveField"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Export the vector field } \\mathbf{u} \\text{ as HDF5 format on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:saveFieldV"} ]
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title": "$\\text{Ensight export of the vectors } u \\text{ and } \\mathbf{u} \\text{ and the mesh on disk}$",
+                                "plot_types": [ "scatter","grouped_bar" ],
+                                "xaxis": { "parameter": "discretization", "label": "Order of discretization" },
+                                "yaxis": { "label": "Time [s]" },
+                                "secondary_axis":{"parameter":"tasks","label":"np"},
+                                "color_axis": { "parameter": "mesh", "label": "Mesh"},
+                                "aggregations":[ {"column":"perfvalue","agg":"filter:export"} ]
+                            }
+                        }
+
+                    ]
+                }
+            ]
+        }
+    ]
 }
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain.json b/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain.json
new file mode 100644
index 0000000..ece0fb6
--- /dev/null
+++ b/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain.json
@@ -0,0 +1,113 @@
+{
+    "executable": "feelpp_toolbox_heatfluid",
+    "output_directory": "{{machine.output_app_dir}}/toolboxes/heatfluid/eye",
+    "use_case_name": "eye2brain",
+    "timeout":"0-00:30:00",
+    "resources":{
+        "tasks":"{{parameters.tasks.value}}",
+        "exclusive_access":true
+    },
+    "input_file_dependencies":{
+        "case_cfg":"feelpp_toolboxes/eye/eye-{{parameters.position.value}}.cfg",
+        "solver_cfg":"feelpp_toolboxes/eye/pc_{{parameters.solver.value}}.cfg",
+        "mesh_json":"feelpp_toolboxes/eye/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.tasks.value}}.json",
+        "mesh_hdf5":"feelpp_toolboxes/eye/{{parameters.mesh.value}}/Eye_Mesh3D_p{{parameters.tasks.value}}.h5"
+    },
+    "platforms": {
+        "apptainer":{
+            "image": {
+                "filepath":"{{machine.containers.apptainer.image_base_dir}}/feelpp-noble.sif"
+            },
+            "input_dir":"/input_data/",
+            "options": [
+                "--home {{machine.output_app_dir}}",
+                "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}"
+            ]
+        },
+        "builtin":{
+            "input_dir":"{{machine.input_dataset_base_dir}}"
+        }
+    },
+    "options": [
+        "--config-files {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.case_cfg}} {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.solve_cfg}}",
+        "--directory {{output_directory}}/{{instance}}",
+        "--repository.case {{use_case_name}}",
+        "--case.discretization=P2-P2P1",
+        "--fail-on-unknown-option 1",
+        "--heat-fluid.scalability-save=1",
+        "--heat-fluid.heat.scalability-save=1",
+        "--heat-fluid.fluid.scalability-save=1",
+        "--repository.append.np 0",
+        "--heat-fluid.json.patch='{\"op\": \"replace\",\"path\": \"/Meshes/heatfluid/Import/filename\",\"value\": \"{{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.mesh_json}}\" }'"
+    ],
+    "additional_files":{
+        "description_filepath":"{{output_directory}}/description.adoc",
+        "parameterized_descriptions_filepath":"{{output_directory}}/{{instance}}/{{use_case_name}}/heatfluid.information.adoc",
+        "custom_logs":[
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_thermoelectric.INFO",
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_thermoelectric.WARNING"
+        ]
+    },
+    "scalability": {
+        "directory": "{{output_directory}}/{{instance}}/{{use_case_name}}",
+        "clean_directory":true,
+        "stages": [
+            {
+                "name": "Constructor",
+                "filepath": "heat-fluid.scalibility.HeatFluidConstructor.data",
+                "format": "tsv"
+            },
+            {
+                "name": "PostProcessing",
+                "filepath": "heat-fluid.scalibility.HeatFluidPostProcessing.data",
+                "format": "tsv"
+            },
+            {
+                "name": "Solve",
+                "filepath": "heat-fluid.scalibility.HeatFluidSolve.data",
+                "format": "tsv",
+                "units":{
+                    "*":"s",
+                    "snes-niter":"iter"
+                }
+            },
+            {
+                "name":"Measures",
+                "filepath":"heatfluid.measures/values.csv",
+                "format":"csv",
+                "units":{
+                    "*":"K"
+                }
+            }
+        ],
+        "custom_variables": [
+            {
+                "name":"Solve_assembly",
+                "columns":[ "Solve_algebraic-newton-initial-guess", "Solve_algebraic-jacobian",  "Solve_algebraic-residual" ],
+                "op":"sum",
+                "unit":"s"
+            }
+        ]
+    },
+    "parameters": [
+        {
+            "name": "tasks",
+            "sequence": [128,256,384,512]
+            // "sequence": [128]
+        },
+        {
+            "name": "mesh",
+            // "sequence": ["M0"]
+            "sequence": ["M0","M1", "M2","M2", "M4","M5","M6"]
+        },
+        {
+            "name": "position",
+            // "sequence": ["prone"]
+            "sequence": ["prone","standing","supine"]
+        },
+        {
+            "name": "solver",
+            "sequence": ["simple"]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain_plots.json b/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain_plots.json
new file mode 100644
index 0000000..048ec97
--- /dev/null
+++ b/src/app-feelpp-toolbox/heatfluid/eye2brain/heatfluid_eye2brain_plots.json
@@ -0,0 +1,293 @@
+{
+    "data":[
+        {
+            "name":"ext_parameter_table","ref":"parameter_table",
+            "table_options":{
+                "computed_columns":{
+                    "description_link":"f'link:descriptions/{row[\"testcases.hashcode\"]}.html[Description]'"
+                }
+            }
+        },
+        {
+            "name":"mesh_stats",
+            "columns":[
+                {"name":"Tag","values":["Mr0","Mr1","Mr2","Mr3","Mr4","Mr5","Mr6"]},
+                {"name":"hmin","values":[0.000125, 0.000137, 0.0000654, 0.0000329, 0.0000255, 0.0000312, 0.0000282]},
+                {"name":"hmax","values":[  0.00400, 0.00363, 0.0016, 0.000959, 0.000529, 0.00015, 0.000000994]},
+                {"name":"hmean","values":[0.000923, 0.000772, 0.000467, 0.000417, 0.000288, 0.000277, 0.000184]},
+                {"name":"# elements", "values":[ 192000, 282000, 747000, 1400000, 6040000, 43900000, 151000000]},
+                {"name":"T","values":[37470, 51753,131000, 242000, 1030000, 7370000, 25200000]},
+                {"name":"u","values":[84966, 117000, 590000, 708000, 1020000, 4620000, 14700000]},
+                {"name":"p","values":[4615, 6155, 28548, 34304, 48534, 205000, 637000] }
+            ],
+            "table_options":{
+                "format":{
+                    "hmin":"%.2E", "hmax":"%.2E", "hmean":"%.2E",
+                    "# elements":"%.2E", "T":"%.2E", "u":"%.2E","p":"%.2E"
+                }
+            }
+        }
+    ],
+    "contents":[
+        {
+            "type":"section",
+            "title":"Benchmark Execution Summary",
+            "contents": [
+                {
+                    "type":"section",
+                    "title":"Session",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Hostname: @{session_info.hostname}@",
+                                "User: @{session_info.hostname}@",
+                                "Time Start: @{session_info.time_start}@",
+                                "Time End: @{session_info.time_end}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Cases",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Total: @{session_info.num_cases}@ ",
+                                "Failures: @{session_info.num_failures}@",
+                                "Runs: @{runs | length}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Parametrization",
+                    "contents":[
+                        {
+                            "type":"table",
+                            "ref": "ext_parameter_table",
+                            "layout":{
+                                "column_order":["result","testcases.hashcode","tasks", "mesh","position","solver", "testcases.time_total", "description_link","logs_link"],
+                                "rename":{
+                                    "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash",
+                                    "result":"", "description_link":"", "logs_link":""
+                                }
+                            },
+                            "style":{
+                                "column_align":{ "result":"center" },
+                                "column_width":{ "result":1,"logs_link":1,"description_link":2},
+                                "classnames":["scrollable","sortable"]
+                            },
+                            "filter":{ "placeholder":"Filter testcases..." }
+                        }
+                    ]
+                }
+            ]
+        },
+
+
+        {
+            "type":"section",
+            "title":"Benchmark: Thermo-Electric Coupling",
+            "contents":[
+                {
+                    "type":"section",
+                    "title":"Description",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"This benchmark models the steady aqueous humor (AH) flow in the posterior and anterior chambers of the human eyeball, coupled with the overall heat transfer, adapted from (Ooi & Ng, 2008; Abdelhafid, Guidoboni, Okumura, Koizumi, & Srinivas, 2021). The full model description is available in (Saigre, Prud'Homme, Szopos, & Chabannes, 2024). It it run with the toolbox heatfluid of Feel++."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"This benchmark was done using feelpp.benchmarking, version *{feelpp_benchmarking_version}*"
+                        },
+                        {
+                            "type":"text",
+                            "text":"The following tools were used for performance profiling and analysis:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Feel++*:the performance tools integrated into the Feel++ framework were used to measure the execution time.",
+                                "*Gaya*: the benchmark was performed on the Gaya supercomputer"
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"The metrics measured are the execution time to: (i) load and initialize the mesh that is already partitioned on the disk, (ii) initialize the data structures, (iii) assembly algebraic objects of the linear system, (iv) solve the non-linear algebraic system, and (v) export the results."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The input dataset consists of a family of 3D tetrahedral meshes generated through the process described in (Chabannes et al., 2024), and denoted Mr0 to Mr6, with an increasing number of elements. Table 4.9 presents the characteristics of these meshes. The mesh Mr4 is presented in Figure 4.17, amond results. The input data also provides the configuration files necessary to run the simulations."
+                                },
+                                {
+                                    "type":"table", "ref":"mesh_stats",
+                                    "caption":"Table 4.9: Characteristics of meshes used for the convergence study and number of degrees of freedom for temperature T, velocity u, and pressure fields p, with the discretization P1 - P2 P1."
+                                }
+                            ]
+                        },
+
+                        {
+                            "type":"section",
+                            "title":"Output Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The output includes the computed temperature, velocity, and pressure fields for each mesh, stored in HDF5 format, as well as the time taken to perform each step of the simulation."
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Data Repository",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"All input and output datasets are available in a Zenodo repository (Saigre, Prud'homme, Szopos, & Chabannes, 2024), accessible through DOI: 10.5281/ZENODO. 13886143."
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results Summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"We show in Figure 4.17 the distribution of the computed temperature over the eyeball in the standing position on a vertical cut. The temperature is higher at the back part of the eye, as this part is inside the human body, while the front part, where heat exchanges with the ambient air are present, is colder. The temperature distribution is consistent with previous findings from literature (Ooi & Ng, 2008; Wang, Qian, Song, Zhang, & Liu, 2016). Moreover, we present in Figure 4.18 the results of the simulation for various postural orientations of the eye, namely standing, prone, and supine positions. The main striking result is the difference in the flow patterns: it follows the gravitational force and is more important in the standing position (Figure 4.18a). Moreover, we notice the formation of Krukenberg's spindle and phenomena of recirculation in the anterior chamber, as observed in the literature (Abdelhafid et al., 2021; Wang et al., 2016). These results have been obtained with the mesh Mr4 and the P1-P2 P1 discretization."
+                        },
+                        {
+                            "type":"grid",
+                            "columns":1,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-heatfluid-resheat.png",
+                                    "caption":"Figure 4.17: Distribution of the computed temperature over the eyeball in the standing position, on a vertical cut. Mesh discretization is also presented"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"grid",
+                            "columns":3,
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-heatfluid-flowstanding.png",
+                                    "caption":"Standing position"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-heatfluid-flowprone.png",
+                                    "caption":"Prone position"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-heatfluid-flowsupine.png",
+                                    "caption":"Supine position"
+                                }
+                            ]
+
+                        },
+                        {
+                            "type":"text",
+                            "text":"The results of the benchmark are summarized in Figure 4.19a and Figure 4.19b, showing the computational time and relative computational time for each component of the simulation, respectively. The results are presented for the three biggest meshed of the family, namely Mr4, Mr5, and Mr6. Note that for Mr6, the simulation dit not complete on 1 node (128 cores) due to memory limitations."
+                        },
+                        {
+                            "type":"text",
+                            "text":"We observe that the resolution of the non-linear algebraic system is the most time-consuming part of the simulation, followed by the assembly of the linear system. Moreover, even though the relative time is globally similar when the number of cores is increased, we note a decrease in the absolute time for various components of the simulation, except for the Post process part, which involves writing the results to disk. The assembly time remains significant compared to other parts of the simulation, with a noticeable increase in the time spent resolving the non-linearsystem , which forms the largest portion of the computation. As the number of cores increases, we also observe a proportional increase in time dedicated to I/O operations, particularly in the Post process phase, due to the larger volumes of data being written to disk."
+                        }
+                    ]
+                },
+
+                {
+                    "type":"section",
+                    "title":"Challenges Identified",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"Several challenges were encountered during the benchmarking process:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Memory Usage*: Memory usage should be better monitored espcially when creating the solver and preconditioner objects.",
+                                "*Parallelization Inefficiencies*: We need to test on large configuration in terms of mesh sizes and number of cores as well as increase the polynomial order to identify potential parallelization and I/O bottlenecks."
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results",
+                    "contents":[
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Computational time for the coupled heat-fluid testcase",
+                                "plot_types":["stacked_bar"],
+                                "xaxis":{"parameter":"tasks","label":"Nproc"},
+                                "yaxis":{"label":"Computational time[s]"},
+                                "secondary_axis":{"parameter":"mesh","label":"Mesh"},
+                                "color_axis":{"label":"Step",
+                                    "filter":[
+                                        {"Constructor_initMesh":"initMesh"},
+                                        {"Constructor_matrixVector":"Data Structures"},
+                                        {"Solve_assembly":"Assembly"},
+                                        {"Solve_solve":"Solve"},
+                                        {"PostProcessing_exportResults":"Post Process"}
+                                    ]
+                                }
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Computational time for the coupled heat-fluid testcase",
+                                "plot_types":["stacked_bar"],
+                                "xaxis":{"parameter":"tasks","label":"Nproc"},
+                                "transformation":"relative_performance",
+                                "yaxis":{"label":"Computational time[s]"},
+                                "secondary_axis":{"parameter":"mesh","label":"Mesh"},
+                                "color_axis":{"label":"Step",
+                                    "filter":[
+                                        {"Constructor_initMesh":"initMesh"},
+                                        {"Constructor_matrixVector":"Data Structures"},
+                                        {"Solve_assembly":"Assembly"},
+                                        {"Solve_solve":"Solve"},
+                                        {"PostProcessing_exportResults":"Post Process"}
+                                    ]
+                                }
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10.json b/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10.json
new file mode 100644
index 0000000..fdd63da
--- /dev/null
+++ b/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10.json
@@ -0,0 +1,97 @@
+{
+    "executable":"feelpp_toolbox_solid",
+    "output_directory": "{{machine.output_app_dir}}/toolboxes/solid/NAFEMSLE10",
+    "use_case_name": "NAFEMS_LE10",
+    "timeout":"0-00:20:00",
+    "resources":{
+        "tasks":"{{parameters.tasks.value}}",
+        "exclusive_access":true
+    },
+    "input_file_dependencies":{
+        "case_cfg":"feelpp_toolboxes/{{use_case_name}}/le10.cfg",
+        "mesh_json":"feelpp_toolboxes/{{use_case_name}}/{{parameters.mesh.value}}/le10_p{{parameters.tasks.value}}.json",
+        "mesh_hdf5":"feelpp_toolboxes/{{use_case_name}}/{{parameters.mesh.value}}/le10_p{{parameters.tasks.value}}.h5"
+    },
+
+    "platforms": {
+        "apptainer":{
+            "image": {
+                "filepath":"{{machine.containers.apptainer.image_base_dir}}/feelpp-noble.sif"
+            },
+            "input_dir":"/input_data",
+            "options": [
+                "--home {{machine.output_app_dir}}",
+                "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}",
+                "--env OMP_NUM_THREADS=1"
+            ]
+        },
+        "builtin":{
+            "input_dir":"{{machine.input_dataset_base_dir}}"
+        }
+    },
+    "options": [
+        "--config-files {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.case_cfg}}",
+        "--directory {{output_directory}}/{{instance}}",
+        "--repository.case {{use_case_name}}",
+        "--solid.scalability-save=1",
+        "--repository.append.np 0",
+        "--case.discretization {{parameters.discretization.value}}",
+        "--solid.json.patch='{\"op\": \"replace\",\"path\": \"/Meshes/solid/Import/filename\",\"value\": \"{{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.mesh_json}}\" }'"
+    ],
+    "additional_files":{
+        "parameterized_descriptions_filepath":"{{output_directory}}/{{instance}}/{{use_case_name}}/solid.information.adoc",
+        "custom_logs":[
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_solid.INFO",
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_solid.WARNING"
+        ]
+    },
+    "scalability": {
+        "directory": "{{output_directory}}/{{instance}}/{{use_case_name}}",
+        "clean_directory":false,
+        "stages": [
+            {
+                "name": "Constructor",
+                "filepath": "solid.scalibility.SolidMechanicsConstructor.data",
+                "format": "tsv"
+            },
+            {
+                "name": "PostProcessing",
+                "filepath": "solid.scalibility.SolidMechanicsPostProcessing.data",
+                "format": "tsv"
+            },
+            {
+                "name": "Solve",
+                "filepath": "solid.scalibility.SolidMechanicsSolve.data",
+                "format": "tsv"
+            },
+            {
+                "name": "Outputs",
+                "filepath": "solid.measures/values.csv",
+                "format": "csv",
+                "units": { "*": "Pa" }
+            }
+        ],
+        "custom_variables": [
+            {
+                "name":"Total",
+                "columns":["Constructor_init","Solve_solve","PostProcessing_exportResults" ],
+                "op":"sum",
+                "unit":"s"
+            }
+        ]
+    },
+    "parameters": [
+        {
+            "name":"tasks",
+            "sequence": [32,64,128,256,384,512]
+        },
+        {
+            "name":"mesh",
+            "sequence":["M1","M2","M3"]
+        },
+        {
+            "name":"discretization",
+            "sequence":["P1","P2"]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10_plot.json b/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10_plot.json
new file mode 100644
index 0000000..b6cf53f
--- /dev/null
+++ b/src/app-feelpp-toolbox/solid/nafemsle10/elasticity_nafemsle10_plot.json
@@ -0,0 +1,359 @@
+{
+    "data":[
+        {
+            "name":"ext_parameter_table","ref":"parameter_table",
+            "table_options":{
+                "computed_columns":{
+                    "description_link":"f'link:descriptions/{row[\"testcases.hashcode\"]}.html[Description]'"
+                }
+            }
+        },
+        {
+            "name":"mesh_stats",
+            "columns":[
+                {"name":"Tag","values":["M2","M3","M4"]},
+                {"name":"# points","values":[324000,2430000,18800000]},
+                {"name":"# edges","values":[2250000,17200000,135000000]},
+                {"name":"# faces","values":[3800000,29400000,232000000]},
+                {"name":"# elements","values":[1870000,14600000,116000000]},
+                {"name":"P1","values":[973000,7280000,56400000]},
+                {"name":"P2","values":[7720000,59000000,462000000]}
+            ],
+            "table_options":{
+                "format":{
+                    "# points":"%.2E", "# edges":"%.2E", "# faces":"%.2E", "# elements":"%.2E",
+                    "P1":"%.2E", "P2":"%.2E"
+                }
+            }
+        }
+    ],
+    "contents":[
+        {
+            "type":"section",
+            "title":"Benchmark Execution Summary",
+            "contents": [
+                {
+                    "type":"section",
+                    "title":"Session",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Hostname: @{session_info.hostname}@",
+                                "User: @{session_info.hostname}@",
+                                "Time Start: @{session_info.time_start}@",
+                                "Time End: @{session_info.time_end}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Cases",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Total: @{session_info.num_cases}@ ",
+                                "Failures: @{session_info.num_failures}@",
+                                "Runs: @{runs | length}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Parametrization",
+                    "contents":[
+                        {
+                            "type":"table",
+                            "ref": "ext_parameter_table",
+                            "layout":{
+                                "column_order":["result","testcases.hashcode","tasks","mesh", "discretization", "testcases.time_total", "description_link","logs_link"],
+                                "rename":{
+                                    "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash",
+                                    "result":"", "description_link":"", "logs_link":""
+                                }
+                            },
+                            "style":{
+                                "column_align":{ "result":"center" },
+                                "column_width":{ "result":1,"logs_link":1,"description_link":2},
+                                "classnames":["scrollable","sortable"]
+                            },
+                            "filter":{ "placeholder":"Filter testcases..." }
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type":"section",
+            "title":"Benchmark: Linear elasticity: NAFEMS LE10",
+            "contents":[
+                {
+                    "type":"section",
+                    "title":"Description",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"The NAFEMS LE10 benchmark is a reference test designed to assess the capabilities of finite element analysis (FEM) software for modeling bending structures. This benchmark is part of the NAFEMS benchmarks, commonly used to verify the accuracy and reliability of numerical simulation codes in mechanical and civil engineering."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The LE10 benchmark aims to test the ability of software to solve a beam bending problem in the context of structural analysis. It aims to compare the results obtained by simulation software with analytical or theoretical results, as well as with other calculation methods."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The benchmark consists of analyzing a thin plate in flexion subjected to given loads and fixed to some edges. The underlying physics model used is a linear elasticity model. At the numeric level, we use the continuous Galerkin method with Lagrange finite element of order 1 and 2. The validation of the NAFEMS LE10 benchmark asks to compute the normal stress in the y direction at a point of the geometry."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text": "The benchmark was performed on the @{runs.0.testcases.0.system}@ supercomputer (see Section 10.1). The performance tools integrated into the Feel++-toolboxes framework were used to measure the execution time. Moreover, we need to note that we have used here Apptainer with Feel++ SIF image based on Ubuntu noble OS."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The metrics measured are the execution time of the main components of the simulation. We enumerate these parts in the following:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Init*: load mesh from filesystem and initialize solid toolbox (finite element context and algebraic data structure)",
+                                "*Assembly*: calculate and assemble the matrix and rhs values obtained using the finite element method",
+                                "*Solve*: the linear system by using a preconditioned GMRES. Results are presented in Section 6.2.3.2.",
+                                "*PostProcess*: compute validation measures (normal stress at a point) and export on the filesystem a visualization format (EnsighGold) of the solution and other fields of interest such as von Mises yield, Tresca criterion and principal stresses."
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "Meshes: We have generated three levels of mesh called M2, M3 and M4. These meshes are stored in GMSH format. The statistics can be found in Table 4.7. We have also prepared for each mesh level a collection of partitioned mesh. The format used is an in-house mesh format of Feel++ based on JSON+HDF5 file type. The Gmsh meshes and the partitioned meshes can be found on our Girder database management, in the Feel++ collections.",
+                                        "Setup: Use standard setup of Feel++ toolboxes. It corresponds to a cfg file and JSON file. These config files are present in the Github of feelpp.",
+                                        "Sif image: feelpp:v0.111.0-preview.10-noble-sif (stored in the Github registry of Feel++)"
+                                    ]
+                                },
+                                {
+                                    "type":"table", "ref":"mesh_stats"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Output Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The output includes the computed values of validation measure in CSV files format, export visualization files (mesh, partitioning, displacement, ...), and the time taken to perform each simulation step."
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results Summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"We start by showing Figure 4.9 that illustrate the numerical results quality of this in silico experiments. We can see the displacement filed and some quantities of interest in figs. 4.9a to 4.9c. Moreover, we have fig. 4.9d which show the validity and quality of the solution for each discretization."
+                        },
+
+                        {
+                            "type":"grid",
+                            "columns":3,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-nafems-le10-solution-tresca-wrap.png",
+                                    "caption":"Figure 4.9: NAFEMS LE10 benchmark - numerical solutions and convergence of validation measures compared to reference value"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-nafems-le10-solution-vonmises.png",
+                                    "caption":"Figure 4.9: NAFEMS LE10 benchmark - numerical solutions and convergence of validation measures compared to reference value"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-nafems-le10-solution-disp.png",
+                                    "caption":"Figure 4.9: NAFEMS LE10 benchmark - numerical solutions and convergence of validation measures compared to reference value"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"In terms of performance, we have plotted the execution times related to the WP1 context. These results, illustrating the Init, Assembly and PostProcess components, can be found in figs. 4.10 to 4.12. The behavior is very good, we can see the a good scalability, up to a limit as usual when the problem size become too small. We can notice some jump with the Init part in cases of large number tasks. We think that is due to filesystem load, particularly because we load the mesh file from non-fast storage. Outputs are written on fast storage but not input datasets because of reduced quota limits on this fast disk."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Challenges Identified",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"HPC experiments with other kinds of discretizations:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "Displacement/pressure formulation",
+                                "HDG method",
+                                "Nonlinear models"
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"Go to extreme HPC scale : Partitioning and IO issues"
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results",
+                    "contents":[
+                        {
+                            "type": "section",
+                            "title": "Convergence of validation measures",
+                            "contents":[
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Output measures (Normal Stress)",
+                                        "plot_types": [ "scatter" ],
+                                        "xaxis": { "parameter": "mesh", "label": "mesh levels" },
+                                        "yaxis": { "label": "Normal stress (\\sigma_yy ) [Pa]" },
+                                        "color_axis":{ "parameter": "discretization", "label":"Discretization" },
+                                        "secondary_axis":{
+                                            "parameter": "perfvalue",
+                                            "label": "Measures",
+                                            "filter": [ {"Outputs_Points_pointD_expr_sigma_yy":"Normal Stress"} ]
+                                        },
+                                        "aggregations":[ {"column":"tasks","agg":"min"} ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "P1 Discretization Performance",
+                            "contents": [
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Performance (P1)",
+                                        "plot_types": [ "grouped_bar","stacked_bar" ],
+                                        "xaxis": { "parameter": "tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P1"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Speedup (P1)",
+                                        "plot_types": [ "scatter" ],
+                                        "transformation": "speedup",
+                                        "xaxis": { "parameter": "tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "Speedup" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P1"} ]
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "P2 Discretization Performance",
+                            "contents": [
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Performance (P2)",
+                                        "plot_types": [ "grouped_bar","stacked_bar" ],
+                                        "xaxis": { "parameter": "tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P2"} ]
+                                    }
+                                },
+                                {
+                                    "type": "plot",
+                                    "plot": {
+                                        "title": "Speedup (P2)",
+                                        "plot_types": [ "scatter" ],
+                                        "transformation": "speedup",
+                                        "xaxis": { "parameter": "tasks", "label": "Number of tasks" },
+                                        "secondary_axis": { "parameter": "mesh", "label": "Mesh level" },
+                                        "color_axis":{
+                                            "parameter":"perfvalue",
+                                            "label":"Performance Variable",
+                                            "filter":[
+                                                {"Constructor_init":"Preprocessing"},
+                                                {"Solve_algebraic-assembly":"Algebraic assembly"},
+                                                {"Solve_algebraic-solve":"Algebraic solve"},
+                                                {"PostProcessing_exportResults":"Postprocess"}
+                                            ]
+                                        },
+                                        "yaxis": { "label": "Speedup" },
+                                        "aggregations":[ {"column":"discretization","agg":"filter:P2"} ]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31.json b/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31.json
new file mode 100644
index 0000000..3842d89
--- /dev/null
+++ b/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31.json
@@ -0,0 +1,86 @@
+{
+    "executable": "feelpp_toolbox_thermoelectric",
+    "output_directory": "{{machine.output_app_dir}}/toolboxes/thermoelectric/HL_31",
+    "use_case_name": "HL_31",
+    "timeout":"0-01:00:00",
+    "resources":{
+        "tasks":"{{parameters.tasks.value}}",
+        "exclusive_access":true
+    },
+    "input_file_dependencies":{
+        "case_cfg":"feelpp_toolboxes/{{use_case_name}}/HL-31.cfg",
+        "mesh_json":"feelpp_toolboxes/{{use_case_name}}/HL-31_p{{parameters.tasks.value}}.json",
+        "mesh_hdf5":"feelpp_toolboxes/{{use_case_name}}/HL-31_p{{parameters.tasks.value}}.h5"
+    },
+    "platforms": {
+        "apptainer":{
+            "image": {
+                "filepath":"{{machine.containers.apptainer.image_base_dir}}/feelpp-noble.sif"
+            },
+            "input_dir":"/input_data",
+            "options": [
+                "--home {{machine.output_app_dir}}",
+                "--bind {{machine.input_dataset_base_dir}}/:{{platforms.apptainer.input_dir}}",
+                "--env OMP_NUM_THREADS=1"
+            ]
+        },
+        "builtin":{
+            "input_dir":"{{machine.input_dataset_base_dir}}/feelpp_toolboxes/{{use_case_name}}/",
+            "append_app_option":[]
+        }
+    },
+    "options": [
+        "--config-files {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.case_cfg}}",
+        "--directory {{output_directory}}/{{instance}}",
+        "--repository.case {{use_case_name}}",
+        "--fail-on-unknown-option 1",
+        "--thermo-electric.scalability-save=1",
+        "--thermo-electric.heat.scalability-save=1",
+        "--thermo-electric.electric.scalability-save=1",
+        "--repository.append.np 0",
+        "--case.discretization {{parameters.discretization.value}}",
+        "--thermo-electric.json.patch='{\"op\": \"replace\",\"path\": \"/Meshes/thermoelectric/Import/filename\",\"value\": \"{{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.mesh_json}}\" }'"
+    ],
+    "additional_files":{
+        "parameterized_descriptions_filepath":"{{output_directory}}/{{instance}}/{{use_case_name}}/thermoelectric.information.adoc",
+        "custom_logs":[
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_thermoelectric.INFO",
+            "{{output_directory}}/{{instance}}/{{use_case_name}}/logs/feelpp_toolbox_thermoelectric.WARNING"
+        ]
+    },
+    "scalability": {
+        "directory": "{{output_directory}}/{{instance}}/{{use_case_name}}",
+        "clean_directory":true,
+        "stages": [
+            {
+                "name": "Constructor",
+                "filepath": "thermo-electric.scalibility.ThermoElectricConstructor.data",
+                "format": "tsv"
+            },
+            {
+                "name": "PostProcessing",
+                "filepath": "thermo-electric.scalibility.ThermoElectricPostProcessing.data",
+                "format": "tsv"
+            },
+            {
+                "name": "Solve",
+                "filepath": "thermo-electric.scalibility.ThermoElectricSolve.data",
+                "format": "tsv",
+                "units":{
+                    "*":"s",
+                    "ksp-niter":"iter"
+                }
+            }
+        ]
+    },
+    "parameters": [
+        {
+            "name": "tasks",
+            "sequence": [4,8,16,32,64,128,256]
+        },
+        {
+            "name": "discretization",
+            "sequence": ["P1","P2"]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31_plots.json b/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31_plots.json
new file mode 100644
index 0000000..168ec94
--- /dev/null
+++ b/src/app-feelpp-toolbox/thermoelectric/hifimagnet/thermoelectric_hl31_plots.json
@@ -0,0 +1,380 @@
+{
+    "data":[
+        {
+            "name":"ext_parameter_table","ref":"parameter_table",
+            "table_options":{
+                "computed_columns":{
+                    "description_link":"f'link:descriptions/{row[\"testcases.hashcode\"]}.html[Description]'"
+                }
+            }
+        },
+        {
+            "name":"mesh_stats",
+            "columns":[
+                {"name":"Tag","values":["M1"]},
+                {"name":"# points","values":[4310000]},
+                {"name":"# edges","values":[27900000]},
+                {"name":"# faces","values":[46000000]},
+                {"name":"# elements","values":[22400000]},
+                {"name":"P1 (Heat)","values":[4310000]},
+                {"name":"P2 (Heat)","values":[32200000]},
+                {"name":"P1 (electric)","values":[4300000]},
+                {"name":"P2 (electric)","values":[29500000]}
+            ],
+            "table_options":{
+                "format":{
+                    "# points":"%.2E", "# edges":"%.2E", "# faces":"%.2E", "# elements":"%.2E",
+                    "P1 (Heat)":"%.2E", "P2 (Heat)":"%.2E", "P1 (electric)":"%.2E", "P2 (electric)":"%.2E"
+                }
+            }
+        }
+    ],
+    "contents":[
+        {
+            "type":"section",
+            "title":"Benchmark Execution Summary",
+            "contents": [
+                {
+                    "type":"section",
+                    "title":"Session",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Hostname: @{session_info.hostname}@",
+                                "User: @{session_info.hostname}@",
+                                "Time Start: @{session_info.time_start}@",
+                                "Time End: @{session_info.time_end}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Cases",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Total: @{session_info.num_cases}@ ",
+                                "Failures: @{session_info.num_failures}@",
+                                "Runs: @{runs | length}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Parametrization",
+                    "contents":[
+                        {
+                            "type":"table",
+                            "ref": "ext_parameter_table",
+                            "layout":{
+                                "column_order":["result","testcases.hashcode","tasks", "discretization", "testcases.time_total", "description_link","logs_link"],
+                                "rename":{
+                                    "testcases.time_total":"Total Time (s)", "testcases.hashcode":"Hash",
+                                    "result":"", "description_link":"", "logs_link":""
+                                }
+                            },
+                            "style":{
+                                "column_align":{ "result":"center" },
+                                "column_width":{ "result":1,"logs_link":1,"description_link":2},
+                                "classnames":["scrollable","sortable"]
+                            },
+                            "filter":{ "placeholder":"Filter testcases..." }
+                        }
+                    ]
+                }
+            ]
+        },
+
+
+        {
+            "type":"section",
+            "title":"Benchmark: Thermo-Electric Coupling",
+            "contents":[
+                {
+                    "type":"section",
+                    "title":"Description",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"This benchmark models the temperature field and electric current distribution in an high field resistive magnet of the Laboratoire National des Champs Magnétiques Intenses. The magnet consist in a set of 14 copper alloys cylindrical tubes connected 2 by 2 into series by rings. In each tube, the current path is defined by 2 helical cuts of 0.2 mm width. The rings are machined to let water flow in between each tube in a channel of 0.8 mm. The magnet is operated at 12 MW with an imosed total current of 31 kA. The water flow in the magnet is about 140 l/s. The water cooling of the magnet is modelling by using Robin boundary conditions with parameters derived from classical correlation in thermo-hydraulics. A more detailled version of the full model is available in (Daversin Catty, 2016; Hild, 2020). The model is run with thermoelectric Feel++ toolbox. The geometry used in this benchmark performance is illustrated in Figure 4.13. This is a complex domain composed of a large number of components, with some very thin parts. "
+                        },
+                        {
+                            "type":"grid",
+                            "columns":2,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-geo.png",
+                                    "caption":"Figure 4.13: HL-31 benchmarks - geometry"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-geo-zoom.png",
+                                    "caption":"Figure 4.13: HL-31 benchmarks - geometry"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Benchmarking Tools Used",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"This benchmark was done using feelpp.benchmarking, version *{feelpp_benchmarking_version}*"
+                        },
+                        {
+                            "type":"text",
+                            "ref":"reframe_json",
+                            "text": "The benchmark was performed on the @{runs.0.testcases.0.system}@ supercomputer (see Section 10.1). The performance tools integrated into the Feel++-toolboxes framework were used to measure the execution time. Moreover, we need to say that we have used several Feel++ installations."
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Gaya*:native application from Ubuntu packages of Jammy OS.",
+                                "*Discoverer*: Apptainer with Feel++ SIF image based on Ubuntu Noble OS."
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"Note: the Feel++ version is identical but the dependencies (like Petsc) which are of course more recent with Noble."
+                        },
+                        {
+                            "type":"text",
+                            "text":"The metrics measured are the execution time of the main components of the simulation. We enumerate these parts in the following:"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "*Init*: load mesh from filesystem and initialize solid toolbox (finite element context and algebraic data structure)",
+                                "*Assembly*: calculate and assemble the matrix and rhs values obtained using the finite element method",
+                                "*Solve*: the linear system by using a preconditioned GMRES.",
+                                "*PostProcess*: Export on the filesystem a visualization format (EnsighGold) of the solution and other fields of interest such as current density and electric field."
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Input/Output Dataset Description",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"Input Data",
+                            "contents":[
+                                {
+                                    "type":"itemize",
+                                    "items":[
+                                        "Meshes: We have generated one mesh called M1. These meshes are stored in GMSH format. The statistics can be found in Table 4.6. We have also prepared for each mesh level a collection of partitioned mesh. The format used is an in-house mesh format of Feel++ based on JSON+HDF5 file type. The Gmsh meshes and the partitioned meshes can be found on our Girder database management, in the Feel++ collections.",
+                                        "Setup: Use standard setup of Feel++ toolboxes. It corresponds to a cfg file and JSON file. These config files are present in the Github of feelpp.",
+                                        "SIF image (Apptainer): feelpp:v0.111.0-preview.10-noble-sif (stored in the Githubregistry of Feel++)",
+                                        "Ubuntu package Jammy (Native) feelpp:v0.111.0-preview.10"
+                                    ]
+                                },
+                                {
+                                    "type":"table", "ref":"mesh_stats",
+                                    "caption":"HL-31 benchmark - Statistics on meshes and number of degrees of freedom with respect to finite element approximation"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Output Data",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"The output includes export visualization files (mesh, partitioning, temperature, elecric potential, current density, electric field, ...), the time taken to perform each simulation step and some integral quantities such a the total power dissipated by the magnet."
+                                }
+                            ]
+                        },
+                        {
+                            "type":"section",
+                            "title":"Data Repository",
+                            "contents":[
+                                {
+                                    "type":"text",
+                                    "text":"All inputdatasets are available in a unistra girder repository (collection HiFiMagnet, HL-31)."
+                                }
+                            ]
+                        }
+                    ]
+                },
+
+                {
+                    "type":"section",
+                    "title":"Results Summary",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"We can find in fig. 4.14 some examples of 3D visualization that represent fields obtained by solving the thermoelectric problem. We have the temperature solution and other quantities evaluated at PostProcess phase such as current density, electric potential, and electric fields."
+                        },
+                        {
+                            "type":"grid",
+                            "columns":2,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-temperature.png",
+                                    "caption":"(a) Temperature"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-current_density.png",
+                                    "caption":"(b) Current density"
+                                }
+                            ]
+                        },
+                        {
+                            "type":"grid",
+                            "columns":2,
+                            "align":"center",
+                            "justify":"center",
+                            "contents":[
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-potential_density_streamines.png",
+                                    "caption":"(c) Electric potential and current density on streamlines of electric field"
+                                },
+                                {
+                                    "type":"image",
+                                    "src":"https://raw.githubusercontent.com/numpex/exa-ma-d7.1/refs/heads/main/graphics/feelpp/feelpp-benchmark-HL-31-temperature-streamlines.png",
+                                    "caption":"(d) Temperature on streamlines of electric field"
+                                }
+                            ]
+                        },
+
+                        {
+                            "type":"text",
+                            "text":"The performance analysis has been done in two supercomputers, Gaya and Discoverer. For each of them, we have run the benchmark with discretizations P1 and P2. About the Feel++ distribution, we use native Ubuntu Jammy packages for Gaya, and Apptainer (with Ubuntu) for Discoverer. The results on these machines are illustrated in figs. 4.15 and 4.16 respectively. The measures presented are the time-consuming of simulation components related to WP1, namely Init, Assembly, and PostProcess. For the Solve component, we refer to section 6.2.3.3."
+                        },
+                        {
+                            "type":"text",
+                            "text":"In each case analyzed, we have very good scalability, in the sense that we reduced significantly the execution time by increasing the number of tasks. The Init phase is the most timeconsuming, with a limit quite high compared to others. This part contains the mesh reading from the disk, which can explain some bumps sometimes when require many HPC resources."
+                        },
+                        {
+                            "type":"text",
+                            "text":"To conclude, we can say that we successfully ran this benchmark case, and we are ready to go up to larger problems and more complex modeling."
+                        }
+                    ]
+                },
+
+                {
+                    "type":"section",
+                    "title":"Challenges Identified",
+                    "contents":[
+                        {
+                            "type":"text",
+                            "text":"HPC experiments with other kinds of discretizations"
+                        },
+                        {
+                            "type":"itemize",
+                            "items":[
+                                "Modelling: nonlinear, Maxwell, ...",
+                                "HDG method",
+                                "Geometry complexity"
+                            ]
+                        },
+                        {
+                            "type":"text",
+                            "text":"Go to extreme HPC scale: Partitioning and IO issues"
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Results",
+                    "contents":[
+                        {
+                            "type":"section",
+                            "title":"HL-31 benchmarks - Execution time of main simulation components",
+                            "contents":[
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title": "Performance by CPU tasks and Discretization",
+                                        "plot_types":["scatter","grouped_bar"],
+                                        "xaxis":{"parameter":"tasks","label":"Number of CPU core"},
+                                        "yaxis": { "label": "execution time (s)" },
+                                        "secondary_axis":{"parameter":"discretization", "label":"Discretization"},
+                                        "color_axis":{
+                                            "label":"Performance Variables",
+                                            "filter":[
+                                                {"Constructor_init": "Init"},
+                                                {"Constructor_createMesh": "Create Mesh"},
+                                                {"Constructor_createExporters": "Create Exporters"},
+                                                {"PostProcessing_exportResults": "Export"},
+                                                {"Solve_solve":"Solve"}
+                                            ]
+                                        }
+                                    }
+                                },
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title": "Speedup of main simulation components",
+                                        "plot_types":["scatter"],
+                                        "transformation":"speedup",
+                                        "xaxis":{"parameter":"tasks","label":"Number of CPU core"},
+                                        "yaxis": { "label": "Speedup" },
+                                        "secondary_axis":{"parameter":"discretization", "label":"Discretization"},
+                                        "color_axis":{
+                                            "label":"Performance Variables",
+                                            "filter":[
+                                                {"Constructor_init": "Init"},
+                                                {"Constructor_createMesh": "Create Mesh"},
+                                                {"Constructor_createExporters": "Create Exporters"},
+                                                {"PostProcessing_exportResults": "Export"},
+                                                {"Solve_solve":"Solve"}
+                                            ]
+                                        }
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "Solver Metrics",
+                            "contents": [
+                                // {
+                                //     "type": "plot",
+                                //     "plot": {
+                                //         "title": "Algebraic-solve execution time",
+                                //         "plot_types": [ "grouped_bar","marked_scatter" ],
+                                //         "xaxis": { "parameter": "resources.tasks", "label": "Number of tasks" },
+                                //         "yaxis": { "label": "execution time (s)" },
+                                //         "color_axis":{ "parameter":"mesh", "label":"Mesh" },
+                                //         "secondary_axis":{ "parameter":"discretization", "label":"Discretization" },
+                                //         "aggregations":[ {"column":"perfvalue","agg":"filter:Solve_algebraic-solve"} ]
+                                //     }
+                                // },
+                                // {
+                                //     "type": "plot",
+                                //     "plot": {
+                                //         "title":"Number of iterations of GMRES",
+                                //         "plot_types":["scatter","marked_scatter"],
+                                //         "xaxis":{ "parameter":"resources.tasks", "label":"Number of tasks" },
+                                //         "yaxis":{ "label":"Number of iterations" },
+                                //         "color_axis":{ "parameter":"mesh", "label":"Mesh" },
+                                //         "secondary_axis":{ "parameter":"discretization", "label":"Discretization" },
+                                //         "aggregations":[ {"column":"perfvalue","agg":"filter:Solve_ksp-niter"} ]
+                                //     }
+                                // }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/cases/electric/2d.cfg b/src/cases/electric/2d.cfg
deleted file mode 100644
index 555064e..0000000
--- a/src/cases/electric/2d.cfg
+++ /dev/null
@@ -1,15 +0,0 @@
-directory=feelpp-project/update
-
-myexpr=-(x*x+y*y)*sin(x*y):x:y
-
-[electric]
-mesh.filename=$cfgdir/2d.geo
-filename=$cfgdir/2d.json
-
-verbose_solvertimer=1
-pc-type=gamg
-ksp-monitor=1
-
-[electric.gmsh]
-hsize=0.1
-partition=1
diff --git a/src/cases/electric/2d.geo b/src/cases/electric/2d.geo
deleted file mode 100644
index ada4f9f..0000000
--- a/src/cases/electric/2d.geo
+++ /dev/null
@@ -1,17 +0,0 @@
-h=0.1;
-
-Point(1) = {0,0,0,h};
-Point(2) = {1,0,0,h};
-Point(3) = {0,1,0,h};
-Point(4) = {1,1,0,h};
-
-Line(1) = {1,2};
-Line(2) = {2,4};
-Line(3) = {4,3};
-Line(4) = {3,1};
-
-Line Loop(1) = {1,2,3,4};
-Plane Surface(1) = {1};
-
-Physical Surface("omega") = {1};
-Physical Line("gamma") = {1,2,3,4};
diff --git a/src/cases/electric/2d.json b/src/cases/electric/2d.json
deleted file mode 100644
index f278893..0000000
--- a/src/cases/electric/2d.json
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- mode: javascript -*-
-{
-    "Name":"update",
-    "ShortName":"update",
-    "Materials":
-    {
-        "omega":
-        {
-            "sigma":"-1"
-        }
-    },
-    "BoundaryConditions":
-    {
-        "electric-potential":
-        {
-            "Dirichlet":
-            {
-                "gamma":
-                {
-                    "expr":"sin(x*y):x:y"
-                }
-            }
-        }
-    },
-    "PostProcess":
-    {
-        "Exports":
-        {
-            "fields":["electric-potential","electric-field","pid"]
-        },
-        "Measures":
-        {
-            "Norm":
-            {
-                "potential-error":
-                {
-                    "type": "L2-error",
-                    "field": "electric-potential",
-                    "solution": "sin(x*y):x:y",
-                    "markers": "omega"
-                },
-                "field-error":
-                {
-                    "type": "L2-error",
-                    "field": "electric-field",
-                    "solution": "{y*cos(x*y),x*cos(x*y)}:x:y",
-                    "markers": "omega"
-                }
-            }
-        }
-    }
-}
diff --git a/src/cases/laplacian/CMakeLists.txt b/src/cases/laplacian/CMakeLists.txt
deleted file mode 100644
index 30ce83c..0000000
--- a/src/cases/laplacian/CMakeLists.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-# ##  TEMPLATE.txt.tpl; coding: utf-8 ---
-
-# Author(s): Christophe Prud'homme <christophe.prudhomme@feelpp.org>
-# Date: 2024-07-17
-#
-# Copyright (C) 2024 University of Strasbourg
-#
-# Distributed under the GPL(GNU Public License):
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-#
-macro(zip_files src dest)
-    # Ensure the destination directory exists
-    get_filename_component(dest_dir ${dest} DIRECTORY)
-    file(MAKE_DIRECTORY ${dest_dir})
-
-    # Collect all files in the source directory to ensure dependencies are tracked
-    file(GLOB_RECURSE src_files ${src}/* ${src}.json)
-    get_filename_component(src_dir ${src} NAME)
-    message(STATUS "src_dir=${src_dir}")
-
-    add_custom_command(
-        OUTPUT ${dest}
-        COMMAND ${CMAKE_COMMAND} -E chdir ${src}/.. ${CMAKE_COMMAND} -E tar "cf" ${dest} --format=zip ${src_dir} ${src_dir}.json
-        DEPENDS ${src_files}
-        COMMENT "Creating zip file ${dest}"
-    )
-endmacro()
-
-# Usage of the macro to zip the content of the 'fin' folder
-set(src_dir ${CMAKE_CURRENT_SOURCE_DIR}/fin)
-set(dest_zip ${CMAKE_BINARY_DIR}/datasets/fin.zip)
-
-# List of dataset directories
-set(datasets "fin" )
-
-# Loop over the datasets and create a zip for each
-foreach(dataset ${datasets})
-    set(src_dir ${CMAKE_CURRENT_SOURCE_DIR}/${dataset})
-    set(dest_zip ${CMAKE_BINARY_DIR}/datasets/dataset-${dataset}.zip)
-    zip_files(${src_dir} ${dest_zip})
-
-    # Add a custom target for each zip file
-    add_custom_target(zip_${dataset} ALL DEPENDS ${dest_zip})
-endforeach()
-
diff --git a/src/cases/laplacian/fin.json b/src/cases/laplacian/fin.json
deleted file mode 100644
index 4d27b4b..0000000
--- a/src/cases/laplacian/fin.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-    "name": "fin simulations",
-    "description": "Dataset for fin heat simulation cases",
-    "configurations": [
-        {
-            "filename": "fin1/fin2d.cfg",
-            "description": "Configuration for a 1 fin 2D simulation"
-        },
-        {
-            "filename": "fin4/fin2d.cfg",
-            "description": "Configuration for a 4 fins 2D simulation"
-        }
-    ],
-    "metadata": {
-        "author": "Feel++ Team",
-        "version": "1.0",
-        "date": "2024-06-24"
-    }
-}
\ No newline at end of file
diff --git a/src/cases/laplacian/fin/fin.geo b/src/cases/laplacian/fin/fin.geo
deleted file mode 100644
index e11c188..0000000
--- a/src/cases/laplacian/fin/fin.geo
+++ /dev/null
@@ -1,105 +0,0 @@
-SetFactory("OpenCASCADE");
-//+
-h = 0.05;
-
-Nfins=4;
-Lfins=2.5;
-dim=2;
-
-N = DefineNumber[ Nfins, Name "Parameters/N" ];
-L = DefineNumber[ Lfins, Name "Parameters/L" ];
-t = DefineNumber[ 0.25, Name "Parameters/t" ];
-d = DefineNumber[ 0.75, Name "Parameters/d" ];
-hmax=0.5;
-Mesh.CharacteristicLengthMax = hmax;
-
-If  ( dim == 2 )
-
-//+
-Rectangle(1) = {0, 0, 0, 1, N*(d+t)+t, 0};
-For r In {1:N}
-    Printf("fin = %g",r);
-    Rectangle(r+1) = {-L, r*(d+t), 0, 2*L+1, t, 0};
-EndFor
-
-S[]=BooleanFragments{ Surface{1}; Delete; }{ Surface{2:N+1}; Delete;};
-Characteristic Length{ PointsOf{ Surface{ : }; } } = h;
-
-If ( Nfins==1 )
-
-EndIf
-//+
-// Physical Surface (Sprintf("fin-%g",r)) = r+1;
-
-Physical Surface("Post") = {1:2*N};
-finid = 1;
-For r In {2*N+1:#S[]:2 }
-    Printf("Fin number %g %g ", r, finid);
-    Physical Surface(Sprintf("Fin_%g",finid)) = {r,r+1};
-    finid += 1;
-EndFor
-
-bdy[] = CombinedBoundary { Surface{:}; };
-
-Physical Curve("Gamma_ext") = bdy[0];
-
-For ii In { 1 : (#bdy[]-1) }
-    If (bdy[ii] != 4)
-        Printf("boundary number %g = %g", ii, Abs(bdy[ii]));
-        Physical Curve("Gamma_ext") += Abs(bdy[ii]);   
-    Else
-        Physical Curve("Gamma_root") = bdy[ii];
-    EndIf
-EndFor
-
-// Nfins = 1 2 cavities
-// If ( Nfins == 1 )
-//     Physical Curve("Cavity_1_1") = {1};
-//     Physical Curve("Cavity_1_2") = {10};
-// 
-//     Physical Curve("Cavity_2_1") = {3};
-//     Physical Curve("Cavity_2_2") = {13};
-// EndIf
-ElseIf ( dim == 3 )
-
-//+
-Box(1) = {0, 0, 0, 1, 1, N*(d+t)+t};
-For r In {1:N}
-    Printf("fin = %g",r);
-    Box(r+1) = {-L, -L, r*(d+t), 2*L+1, 2*L+1, t};
-EndFor
-
-S[]=BooleanFragments{ Volume{1}; Delete; }{ Volume{2:N+1}; Delete;};
-Characteristic Length{ PointsOf{ Surface{ : }; } } = h;
-
-//+
-// Physical Volume (Sprintf("fin-%g",r)) = r+1;
-
-Physical Volume("Post") = {1:2*N};
-finid = 1;
-For r In {2*N+1:#S[]:1 }
-    Printf("Fin number %g %g ", r, finid);
-    Physical Volume(Sprintf("Fin_%g",finid)) = { r };
-    finid += 1;
-EndFor
-
-bdy[] = CombinedBoundary { Volume{:}; };
-
-Physical Surface("Gamma_ext") = bdy[0];
-
-For ii In { 1 : (#bdy[]-1) }
-    If (bdy[ii] != 5)
-        Printf("boundary number %g = %g", ii, Abs(bdy[ii]));
-        Physical Surface("Gamma_ext") += Abs(bdy[ii]);   
-    Else
-        Physical Surface("Gamma_root") = bdy[ii];
-    EndIf
-EndFor
-
-// Mesh 2;
-// Show "*";
-
-
-EndIf
-// Mesh 2;
-// Show "*";
diff --git a/src/cases/laplacian/fin/fin1/fin2d.cfg b/src/cases/laplacian/fin/fin1/fin2d.cfg
deleted file mode 100644
index 98d7afa..0000000
--- a/src/cases/laplacian/fin/fin1/fin2d.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-specs=$cfgdir/../fin2d.json
-
-[gmsh]
-geo-variables-list=Nfins=1:dim=2
-
-[bdf]
-order=2
-time-step=0.5
-time-final=10
-steady=1
diff --git a/src/cases/laplacian/fin/fin2d.json b/src/cases/laplacian/fin/fin2d.json
deleted file mode 100644
index 8ac7d11..0000000
--- a/src/cases/laplacian/fin/fin2d.json
+++ /dev/null
@@ -1,103 +0,0 @@
-{
-    "Name": "Thermalfin 2D",
-    "ShortName": "thermalfin2d",
-    "Models": {
-        "laplacian": {
-            "name": "omega",
-            "Materials": [
-                "Post",
-                "Fin_1",
-                "Fin_2",
-                "Fin_3",
-                "Fin_4"
-            ]
-        }
-    },
-    "Meshes": {
-        "laplacian": {
-            "Import": {
-                "filename": "$cfgdir/../fin.geo",
-                "partition": 0
-            }
-        }
-    },
-    "Spaces": {
-        "laplacian": {
-            "Domain": {
-
-
-            }
-        }
-    },
-    "TimeStepping":
-    {
-        "laplacian" :{
-            "steady": false,
-            "order" : 1,
-            "start": 0.0,
-            "end": 10,
-            "step": 0.1
-        }
-    },
-    "Materials": {
-        "Post": {
-            "k": "1", 
-            "Cp": "1",
-            "rho": "1"
-        },
-        "Fin_1": {
-            "k": "1",
-            "Cp": "1",
-            "rho": "1"
-        },
-        "Fin_2": {
-            "k": "1",
-            "Cp": "1",
-            "rho": "1"
-        },
-        "Fin_3": {
-            "k": "1",
-            "Cp": "1",
-            "rho": "1"
-        },
-        "Fin_4": {
-            "k": "1",
-            "Cp": "1",
-            "rho": "1"
-        }
-    },
-    "InitialConditions": {
-        "laplacian": {
-            "temperature": {
-                "Expression": {
-                    "Tini": {
-                        "markers": [
-                            "Fin_1",
-                            "Fin_2",
-                            "Fin_3",
-                            "Fin_4",
-                            "Post"
-                        ],
-                        "expr": "0"
-                    }
-                }
-            }
-        }
-    },
-    "BoundaryConditions": {
-        "laplacian": {
-            "flux": {
-                "Gamma_root": {
-                    "expr": "1"
-                }
-            },
-            "convective_laplacian_flux": {
-                "Gamma_ext": {
-                    "h": "0.3",
-                    "Text": "0"
-                }
-            }
-        }
-    }
-
-}
diff --git a/src/cases/laplacian/fin/fin4/fin2d.cfg b/src/cases/laplacian/fin/fin4/fin2d.cfg
deleted file mode 100644
index e6fa211..0000000
--- a/src/cases/laplacian/fin/fin4/fin2d.cfg
+++ /dev/null
@@ -1,15 +0,0 @@
-specs=$cfgdir/../fin2d.json
-
-[gmsh]
-geo-variables-list=Nfins=4:dim=2
-hsize=0.025
-
-[bdf]
-order=2
-time-step=0.5
-time-final=10
-steady=1
-
-[exporter]
-static=true
-geometry=static
\ No newline at end of file
diff --git a/src/cases/square/square.cfg b/src/cases/square/square.cfg
deleted file mode 100644
index c72e25b..0000000
--- a/src/cases/square/square.cfg
+++ /dev/null
@@ -1,27 +0,0 @@
-
-directory=toolboxes/heat/h-convergence/square/
-
-case.dimension=2
-case.discretization=P1
-case.mode=h-convergence
-
-# [case.mode.h-convergence]
-# hsize=0.02
-# hsize=0.01
-# hsize=0.005
-
-# measures=Norm_error-evaluated_L2-error
-# measures=Norm_error-evaluated_H1-error
-# measures=Norm_error-evaluated_SemiH1-error
-# slopes=2
-# slopes=1
-# slopes=1
-
-[heat]
-filename=$cfgdir/square.json
-gmsh.hsize=0.01
-
-#verbose=1
-#verbose_solvertimer=1
-pc-type=gamg
-ksp-monitor=1
diff --git a/src/cases/square/square.geo b/src/cases/square/square.geo
deleted file mode 100644
index 191abd8..0000000
--- a/src/cases/square/square.geo
+++ /dev/null
@@ -1,21 +0,0 @@
-h = 0.1;
-xmin = 0;
-xmax = 1;
-ymin = 0;
-ymax = 1;
-Point(1) = {xmin,ymin,0.0,h};
-Point(2) = {xmax,ymin+0,0.0,h};
-Point(3) = {xmax+0,ymax,0.0,h};
-Point(4) = {xmin+0,ymax+0,0.0,h};
-Line(1) = {4,1};
-Line(2) = {1,2};
-Line(3) = {2,3};
-Line(4) = {3,4};
-Line Loop(5) = {1,2,3,4};
-Plane Surface(6) = {5};
-
-Physical Line("Left") = {1};
-Physical Line("Bottom") = {2};
-Physical Line("Right") = {3};
-Physical Line("Top") = {4};
-Physical Surface("Omega") = {6};
diff --git a/src/cases/square/square.json b/src/cases/square/square.json
deleted file mode 100644
index ea7edfa..0000000
--- a/src/cases/square/square.json
+++ /dev/null
@@ -1,112 +0,0 @@
-// -*- mode: javascript -*-
-{
-    "Name": "h-convergence heat square",
-    "Parameters":
-    {
-        "alpha":4,
-        "beta":1.5,
-        "exact_solution":"cos(alpha*pi*x)*sin(beta*pi*y):x:y:alpha:beta",
-        "grad_exact_solution":"{-alpha*pi*sin(alpha*pi*x)*sin(beta*pi*y), beta*pi*cos(alpha*pi*x)*cos(beta*pi*y)}:x:y:alpha:beta",
-        "laplacian_exact_solution":"-((alpha*pi)^2)*cos(alpha*pi*x)*sin(beta*pi*y)-((beta*pi)^2)*cos(alpha*pi*x)*sin(beta*pi*y):x:y:alpha:beta"
-    },
-    "Meshes":
-    {
-        "heat":
-        {
-            "Import":
-            {
-                "filename":"$cfgdir/square.geo"
-                //"hsize":0.001
-            }
-        }
-    },
-    "Materials":
-    {
-        "Omega":
-        {
-            "k":1
-        }
-    },
-    "Models":
-    {
-        "heat":
-        {
-            "setup": {
-                "heat-sources": {
-                    "expr":"-laplacian_exact_solution:laplacian_exact_solution"
-                }
-            }
-        }
-    },
-    "BoundaryConditions":
-    {
-        "heat":
-        {
-            "temperature":
-            {
-                "mybc":
-                {
-                    "markers":["Left","Bottom","Right","Top"],
-                    "expr":"exact_solution:exact_solution"
-                }
-            }
-        }
-    },
-    "PostProcess":
-    {
-        "heat":
-        {
-            "Exports":
-            {
-                "fields":["temperature","pid"],
-                "expr":
-                {
-                    "exact_solution":"exact_solution:exact_solution"
-                }
-            },
-            "Measures":
-            {
-                "Normal-Heat-Flux":
-                {
-                    "bottom":
-                    {
-                        "markers":"Top",
-                        "direction":"inward"
-                    }
-                },
-                "Norm":
-                {
-                    "error-evaluated":
-                    {
-                        "field":"temperature",
-                        "type":["L2-error","H1-error","SemiH1-error"],
-                        "solution":"exact_solution:exact_solution",
-                        "grad_solution":"{grad_exact_solution_0,grad_exact_solution_1}:grad_exact_solution_0:grad_exact_solution_1"
-                    }
-                }
-            },
-            "Checkers":
-            {
-                "Measures":
-                {
-                    "Norm_error-evaluated_L2-error":
-                    {
-                        "value":0,
-                        "tolerance":1e-2
-                    },
-                    "Norm_error-evaluated_H1-error":
-                    {
-                        "value":0,
-                        "tolerance":1
-                    },
-                    "Norm_error-evaluated_SemiH1-error":
-                    {
-                        "value":0,
-                        "tolerance":1
-                    }
-                }
-            }
-        }
-    }
-
-}
diff --git a/src/config/default/default.json b/src/config/default/default.json
deleted file mode 100644
index a40a71c..0000000
--- a/src/config/default/default.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "machine": "default",
-    "targets":["::"],
-    "execution_policy": "async",
-    "reframe_base_dir":"./build/reframe",
-    "reports_base_dir":"./reports/",
-    "input_dataset_base_dir":"$PWD",
-    "output_app_dir":"$PWD/outputs"
-}
\ No newline at end of file
diff --git a/src/config/default/default.py b/src/config/default/default.py
deleted file mode 100644
index fc3338b..0000000
--- a/src/config/default/default.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import socket
-
-hostname = socket.gethostname()
-
-site_configuration = {
-    'systems': [
-        {
-            'name': 'default',
-            'descr': 'Default system',
-            'hostnames': [f'{hostname}'],
-            'partitions': [
-                {
-                    'name': 'default',
-                    'scheduler': 'local',
-                    'launcher': 'mpiexec',
-                    'environs': ['default'],
-                    'processor': { 'num_cpus': 4 }
-                },
-            ]
-        }
-    ],
-    'environments': [
-        {
-            'name': 'default',
-            'modules': [],
-            'cc': 'clang',
-            'cxx': 'clang++',
-            'target_systems': ['default:default']
-        }
-    ]
-}
diff --git a/src/config/gaya/gaya.json b/src/config/gaya/gaya.json
deleted file mode 100644
index 9aae917..0000000
--- a/src/config/gaya/gaya.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-    "machine": "gaya",
-    "targets":["production::hpcx"],
-    "execution_policy": "async",
-    "reframe_base_dir":"./build/reframe",
-    "reports_base_dir":"./reports/",
-    "input_dataset_base_dir":"$PWD",
-    "output_app_dir":"$PWD/outputs"
-}
\ No newline at end of file
diff --git a/src/config/gaya/reframe.py b/src/config/gaya/reframe.py
deleted file mode 100644
index e592f9d..0000000
--- a/src/config/gaya/reframe.py
+++ /dev/null
@@ -1,137 +0,0 @@
-site_configuration = {
-    'systems': [
-        {
-            'name': 'gaya',
-            'descr': 'Gaya',
-            'hostnames': ['gaya'],
-            'modules_system': 'tmod4',
-            'partitions': [
-                {
-                    'name': 'production',
-                    'scheduler': 'squeue',
-                    'launcher': 'mpiexec',
-                    'max_jobs': 12,
-                    'access': ['--partition=production'],
-                    'environs': ['default','hpcx'],
-                    'prepare_cmds': [
-                        'source /etc/profile.d/modules.sh',
-                        "export PATH=/opt/apptainer/v1.3.5/apptainer/bin/:$PATH"
-                    ],
-                    'processor': {
-                        'num_cpus': 128
-                    },
-                    'resources': [
-                        {
-                            'name':'launcher_options',
-                            'options':['-bind-to','core']
-                        }
-                    ],
-                    'devices': [
-                        {
-                            'type': 'cpu',
-                            'num_devices': 4
-                        }
-                    ],
-                    'container_platforms':[
-                        {
-                            'type': 'Apptainer'
-                        }
-                    ],
-                    'extras':{
-                        'memory_per_node':500
-                    }
-                },
-                {
-                    'name': 'public',
-                    'scheduler': 'squeue',
-                    'launcher': 'mpiexec',
-                    'max_jobs': 8,
-                    'access': ['--partition=public'],
-                    'environs': ['default','hpcx'],
-                    'prepare_cmds': [
-                        'source /etc/profile.d/modules.sh',
-                        "export PATH=/opt/apptainer/v1.3.5/apptainer/bin/:$PATH"
-                    ],
-                    'processor': {
-                        'num_cpus': 128
-                    },
-                    'resources': [
-                        {
-                            'name':'launcher_options',
-                            'options':['-bind-to','core']
-                        }
-                    ],
-                    'devices': [
-                        {
-                            'type': 'cpu',
-                            'num_devices': 4
-                        }
-                    ],
-                    'container_platforms':[
-                        {
-                            'type': 'Apptainer'
-                        }
-                    ],
-                    'extras':{
-                        'memory_per_node':500
-                    }
-                },
-                {
-                    'name':'gpu',
-                    'scheduler':'squeue',
-                    'launcher':'mpiexec',
-                    'max_jobs':4,
-                    'access': ['--partition=gpu'],
-                    'environs': ['default'],
-                    'resources': [
-                        {
-                            'name': '_rfm_gpu',
-                            'options': ['--gres=gpu:{num_gpus_per_node}'],
-                        },
-                        {
-                            'name':'launcher_options',
-                            'options':['-bind-to','none']
-                        }
-                    ],
-                    'prepare_cmds': [
-                        'source /etc/profile.d/modules.sh',
-                        "export PATH=/opt/apptainer/v1.3.5/apptainer/bin/:$PATH"
-                    ],
-                    'processor': {
-                        'num_cpus': 32
-                    },
-                    'devices': [
-                        {
-                            'type': 'gpu',
-                            'num_devices': 3
-                        }
-                    ],
-                    'container_platforms':[
-                        {
-                            'type': 'Apptainer'
-                        }
-                    ],
-                    'extras':{
-                        'memory_per_node':256
-                    }
-                }
-            ]
-        }
-    ],
-    'environments': [
-        {
-            'name': 'default',
-            'modules': [],
-            'cc': 'clang',
-            'cxx': 'clang++',
-            'target_systems': ['gaya:production','gaya:public','gaya:gpu']
-        },
-        {
-            'name': 'hpcx',
-            'modules': ['hpcx'],
-            'cc': 'clang',
-            'cxx': 'clang++',
-            'target_systems': ['gaya:production','gaya:public']
-        }
-    ]
-}
diff --git a/src/config/gaya/setup.sh b/src/config/gaya/setup.sh
deleted file mode 100755
index da89d9b..0000000
--- a/src/config/gaya/setup.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash -l
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install --upgrade pip
-python3 -m pip install -r requirements.txt
\ No newline at end of file
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
deleted file mode 100644
index ebec13d..0000000
--- a/src/example/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-feelpp_add_application(parallelSum SRCS parallelSum.cpp )
diff --git a/src/example/README.adoc b/src/example/README.adoc
deleted file mode 100644
index eb1cf6f..0000000
--- a/src/example/README.adoc
+++ /dev/null
@@ -1,6 +0,0 @@
-# feelpp-benchmark example
-
-[source, bash]
-----
-feelpp-benchmarking-exec --machine-config src/config/default/default.json --custom-rfm-config src/config/default/default.py --benchmark-config src/example/parallelSum.json --plots-config src/example/plots.json --website
-----
\ No newline at end of file
diff --git a/src/example/parallelSum.cpp b/src/example/parallelSum.cpp
deleted file mode 100644
index e4895a6..0000000
--- a/src/example/parallelSum.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-#include <mpi.h>
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <numeric>
-#include <string>
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-int main(int argc, char** argv)
-{
-    MPI_Init(&argc, &argv);
-
-    int rank, size;
-    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
-    MPI_Comm_size(MPI_COMM_WORLD, &size);
-
-    if ( argc < 3 )
-    {
-        if (rank == 0)
-            std::cerr << "Usage: " << argv[0] << " <N> <output_directory>\n";
-        MPI_Finalize();
-        return 1;
-    }
-    int N = std::stoi(argv[1]);
-    fs::path output_dir = argv[2];
-    int base_chunk_size = N / size;
-    int remainder = N % size;
-
-    int local_start = rank * base_chunk_size + std::min(rank, remainder);
-    int local_end = local_start + base_chunk_size + (rank < remainder ? 1 : 0);
-
-    std::vector<double> local_array(local_end - local_start, 1.0);
-
-    double start_time = MPI_Wtime();
-    double local_sum = 0;
-    for (size_t i = 0; i < local_array.size(); ++i)
-        local_sum += local_array[i];
-    double end_time = MPI_Wtime();
-
-    double start_comm_time = MPI_Wtime();
-    double global_sum = 0.0;
-    MPI_Reduce(&local_sum, &global_sum, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
-    double end_comm_time = MPI_Wtime();
-    if ( rank == 0 )
-    {
-        double computation_time = end_time - start_time;
-        double communication_time = end_comm_time - start_comm_time;
-        std::cout << "Global sum = " << global_sum << "\n";
-        std::cout << "Computation time: " << computation_time << " seconds\n";
-        std::cout << "Communication time: " << communication_time << " seconds\n";
-
-        if (!fs::exists(output_dir))
-            fs::create_directories(output_dir);
-
-        fs::path filename = "scalability.json";
-
-        std::ofstream scal_outfile(output_dir/filename);
-        if ( scal_outfile.is_open() )
-        {
-            scal_outfile << "{\n";
-            scal_outfile << "  \"computation_time\": " << computation_time << ",\n";
-            scal_outfile << "  \"communication_time\": " << communication_time << "\n";
-            scal_outfile << "}\n";
-            scal_outfile.close();
-        }
-        else
-            std::cerr << "[OOPSIE] Error opening file for writing." << std::endl;
-
-        fs::path out_filename = "outputs.csv";
-        std::ofstream out_outfile(output_dir/out_filename);
-        if (out_outfile.is_open())
-        {
-            out_outfile << "N,sum,num_process\n";
-            out_outfile << N << "," << global_sum << "," << size ;
-            out_outfile.close();
-        }
-        else
-            std::cerr << "[OOPSIE] Error opening file for writing [outputs]." << std::endl;
-
-        std::cout << "[SUCCESS]" << std::endl;
-    }
-
-    MPI_Finalize();
-
-
-    return 0;
-}
\ No newline at end of file
diff --git a/src/example/parallelSum.json b/src/example/parallelSum.json
deleted file mode 100644
index d8cefdb..0000000
--- a/src/example/parallelSum.json
+++ /dev/null
@@ -1,48 +0,0 @@
-{
-    "executable": "{{machine.input_dataset_base_dir}}/build/default/src/example/feelpp_app_parallelSum",
-    "use_case_name": "parallel_sum",
-    "timeout":"0-0:5:0",
-    "output_directory": "{{machine.output_app_dir}}/parallelSum",
-    //Application options
-    "options": [
-        "{{parameters.elements.value}}",
-        "{{output_directory}}/{{instance}}"
-    ],
-    //Files containing execution times
-    "scalability": {
-        "directory": "{{output_directory}}/{{instance}}/",
-        "stages": [
-            {
-                "name":"",
-                "filepath": "scalability.json",
-                "format": "json",
-                "variables_path":"*"
-            }
-        ]
-    },
-    // Resources for the test
-    "resources":{
-        "tasks":"{{parameters.tasks.value}}",
-        "exclusive_access":false
-    },
-    // Test validation (Only stdout supported at the moment)
-    "sanity": {
-        "success": ["[SUCCESS]"],
-        "error": ["[OOPSIE]","Error"]
-    },
-    // Test parameters
-    "parameters": [
-        {
-            "name": "tasks",
-            "sequence": [ 1, 2, 4 ]
-        },
-        {
-            "name":"elements",
-            "linspace":{
-                "min":100000000,
-                "max":1000000000,
-                "n_steps":4
-            }
-        }
-    ]
-}
\ No newline at end of file
diff --git a/src/example/plots.json b/src/example/plots.json
deleted file mode 100644
index bdaa96e..0000000
--- a/src/example/plots.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
-    "plots":[
-        {
-            "title": "Absolute performance",
-            "plot_types": [ "stacked_bar", "grouped_bar" ],
-            "transformation": "performance",
-            "variables": [ "computation_time" ],
-            "names": ["Time"],
-            "xaxis":{
-                "parameter":"tasks",
-                "label":"Number of tasks"
-            },
-            "yaxis":{"label":"Execution time (s)"},
-            "secondary_axis":{
-                "parameter":"elements",
-                "label":"N"
-            }
-        },
-        {
-            "title": "Absolute performance",
-            "plot_types": [ "stacked_bar", "table" ],
-            "transformation": "performance",
-            "variables": [ "computation_time" ],
-            "names": ["Time"],
-            "xaxis":{
-                "parameter":"elements",
-                "label":"N"
-            },
-            "yaxis":{"label":"Execution time (s)"},
-            "secondary_axis":{
-                "parameter":"tasks",
-                "label":"Number of tasks"
-            }
-        },
-        {
-            "title": "Speedup",
-            "plot_types": [ "scatter" ],
-            "transformation": "speedup",
-            "variables": [ "computation_time" ],
-            "names": ["Time"],
-            "xaxis": {
-                "parameter": "tasks",
-                "label": "Number of tasks"
-            },
-            "yaxis": {
-                "label": "Execution time (s)"
-            },
-            "secondary_axis":{
-                "parameter":"elements",
-                "label":"N"
-            }
-        }
-    ]
-}
\ No newline at end of file
diff --git a/src/ktirio-geom/terrain/grenoble/grenoble.json b/src/ktirio-geom/terrain/grenoble/grenoble.json
new file mode 100644
index 0000000..a57f654
--- /dev/null
+++ b/src/ktirio-geom/terrain/grenoble/grenoble.json
@@ -0,0 +1,88 @@
+{
+    "bin_dir":"/data/scratch/cladellash/bin",
+    "executable":"{{bin_dir}}/ktirio_geom_app_terrain",
+    "use_case_name":"Grenoble",
+    "timeout":"0-0:10:0",
+    "output_directory": "{{machine.output_app_dir}}/terrain/{{use_case_name}}/{{instance}}",
+    "input_file_dependencies":{
+        "elevation_dir":"ktirio-geom/terrain/{{use_case_name}}/{{fixed.zoom}}/elevation/",
+        "features_dir":"ktirio-geom/terrain/{{use_case_name}}/{{fixed.zoom}}/features/"
+    },
+    "platforms": {
+        "builtin":{
+            "input_dir":"{{machine.input_dataset_base_dir}}"
+        }
+    },
+    "options":[
+        "--input.terrain.output-directory={{output_directory}}",
+        "--input.terrain.elevation.isolines-step={{parameters.isolines_step.value}}",
+        "--input.terrain.elevation.simplification-threshold={{parameters.simplification_threshold.value}}",
+        "--input.multithreaded={{fixed.multithreaded}}",
+
+        "--input.terrain.autorefine=false",
+        "--input.terrain.elevation.zoom={{fixed.zoom}}",
+        "--input.terrain.features.zoom={{fixed.zoom}}",
+        "--input.terrain.elevation.directory={{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.elevation_dir}}",
+        "--input.terrain.features.directory={{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.features_dir}}",
+
+        "--input.terrain.features.include=water",
+        "--input.terrain.features.include=road"
+    ],
+    "scalability":{
+        "directory":"{{output_directory}}",
+        "stages":[
+            {
+                "name":"Terrain",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.times.*","terrain.subsections.*.times.elapsed"]
+            },
+            {
+                "name":"Terrain_createMesh",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.times.*","terrain.subsections.createMesh.subsections.*.times.elapsed"]
+            },
+            {
+                "name":"Tile_createMesh",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.*.times.*"]
+            },
+            {
+                "name":"Tile_elevation",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.*.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.times.*"]
+            },
+            {
+                "name":"Tile_corefineFeatures",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.corefineFeatures.subsections.*.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.corefineFeatures.times.*"]
+            },
+            {
+                "name":"Tile_constrainedMesher",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.createConstrainedMesh.subsections.*.times","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.createConstrainedMesh.times.*"]
+            }
+        ]
+    },
+    "resources":{
+        "tasks":1,
+        "exclusive_access":false
+    },
+    "sanity":{
+        "success":["TERRAIN done in"],
+        "error":[]
+    },
+    "fixed":{
+        "multithreaded": "true",
+        "zoom":16
+    },
+    "parameters":[
+        { "name": "isolines_step", "sequence":[20,10,5,2,1] },
+        { "name": "simplification_threshold", "sequence":[1,0.9,0.75,0.5,0.25,0.1,0] }
+    ]
+}
\ No newline at end of file
diff --git a/src/ktirio-geom/terrain/grenoble/plots.json b/src/ktirio-geom/terrain/grenoble/plots.json
new file mode 100644
index 0000000..2ee99a9
--- /dev/null
+++ b/src/ktirio-geom/terrain/grenoble/plots.json
@@ -0,0 +1,471 @@
+{
+    "contents":[
+        {
+            "type":"section",
+            "title":"Benchmark Execution Summary",
+            "contents": [
+                {
+                    "type":"section",
+                    "title":"Session",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Hostname: @{session_info.hostname}@",
+                                "User: @{session_info.hostname}@",
+                                "Time Start: @{session_info.time_start}@",
+                                "Time End: @{session_info.time_end}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Cases",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Total: @{session_info.num_cases}@ ",
+                                "Failures: @{session_info.num_failures}@",
+                                "Runs: @{runs | length}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Parametrization",
+                    "contents":[
+                        {
+                            "type":"table",
+                            "ref": "parameter_table",
+                            "layout":{
+                                "column_order":["result","testcases.hashcode","isolines_step","simplification_threshold", "logs_link"],
+                                "rename":{
+                                    "testcases.hashcode":"Hash", "result":"", "logs_link":""}
+                            },
+                            "style":{
+                                "column_align":{ "result":"center" },
+                                "column_width":{ "result":1,"logs_link":1},
+                                "classnames":["scrollable","sortable"]
+                            },
+                            "filter":{ "placeholder":"Filter testcases..." }
+                        }
+                    ]
+                }
+            ]
+        },
+
+        {
+            "type": "section",
+            "title": "Benchmark: Ktirio-Geom - Terrain Generation Pipeline",
+            "contents": [
+                {
+                    "type": "section",
+                    "title": "Description",
+                    "contents": [
+                        {
+                            "type": "text",
+                            "text": "This benchmark evaluates the performance of the Ktirio-Geom terrain generation pipeline. The pipeline transforms elevation datasets into high-quality terrain meshes suitable for numerical simulation, visualization, and downstream geometric processing."
+                        },
+                        {
+                            "type": "text",
+                            "text": "The terrain generation workflow relies on multithreaded execution and advanced geometric algorithms, including contour extraction, constrained triangulation, mesh corefinement, and simplification. Particular attention is paid to scalability with respect to geometric complexity and algorithmic parameters."
+                        },
+                        {
+                            "type": "text",
+                            "text": "Two primary parameters are explored in this benchmark: the isolines step, which controls contour density and therefore geometric resolution, and the simplification threshold, which governs geometric decimation during constrained triangulation."
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Benchmarking Tools Used",
+                    "contents": [
+                            {
+                                "type": "text",
+                                "text": "Performance measurements were collected using internal timing instrumentation integrated into Ktirio-Geom. Each stage of the pipeline reports elapsed wall-clock time, with additional per-thread statistics for multithreaded sections."
+                            },
+                            {
+                                "type": "text",
+                                "text": "For tile-level parallel operations, the benchmark reports the longest executing thread, reflecting the critical path and providing a conservative estimate of scalability limits."
+                            }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Input / Output Dataset Description",
+                    "contents": [
+                        {
+                            "type": "section",
+                            "title": "Input Data",
+                            "contents": [
+                                {
+                                    "type": "itemize",
+                                    "items": [
+                                        "Elevation grids representing terrain height fields.",
+                                        "Overlay features in GIS format, for buildings, roads, water bodies, landuse, ...",
+                                        "Isoline extraction parameters controlling contour spacing.",
+                                        "Simplification thresholds influencing contour line simplification complexity."
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "Output Data",
+                            "contents": [
+                                {
+                                    "type": "text",
+                                    "text": "The output consists of a conforming terrain surface triangulation, with tagged features (water,roads,buildings...), and timing metrics for each major processing stage. These outputs are suitable for visualization, simulation preprocessing, and further geometric analysis."
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "section",
+            "title": "Results Summary",
+            "contents": [
+                {
+                    "type": "text",
+                    "text": "The benchmark results highlight the strong influence of isoline density on total execution time, particularly during constrained triangulation and contour mesh generation. Simplification thresholds provide an effective lever to balance geometric fidelity against computational cost."
+                },
+                {
+                    "type": "text",
+                    "text": "Multithreaded execution significantly reduces wall-clock time for large terrain configurations. However, several stages exhibit diminishing returns due to synchronization points and geometric dependencies."
+                }
+            ]
+        },
+
+
+        {
+            "type": "section",
+            "title": "Results",
+            "contents": [
+                {
+                    "type": "section",
+                    "title": "Terrain Full Pipeline",
+                    "contents": [
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Terrain generation performance agains isolines spacing",
+                                "plot_types":["scatter","grouped_bar"],
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s) - multithreaded"},
+                                "color_axis":{"parameter":"perfvalue","label":"Pipeline step", "filter":[
+                                    {"Terrain_createMesh":"createMesh"}, {"Terrain_exportMesh":"exportMesh"}, {"Terrain_updateForUse":"updateForUse"}
+                                ]},
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"As the isolines step increases (i.e. isolines are more widely separated), the execution time of createMesh decreases significantly, reflecting the reduced geometric complexity and fewer constraints in the meshing process. However, beyond a certain isoline spacing, the performance gain levels off and stagnates, indicating that other fixed costs or algorithmic overheads begin to dominate. Each specific mesh contains a \"sweetspot\" for which users can get the best performance vs mesh quality."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Terrain generation performance against simplification threshold",
+                                "plot_types":["scatter","grouped_bar"],
+                                "secondary_axis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s) - multithreaded"},
+                                "color_axis":{"parameter":"perfvalue","label":"Pipeline step", "filter":[
+                                    {"Terrain_createMesh":"createMesh"}, {"Terrain_exportMesh":"exportMesh"}, {"Terrain_updateForUse":"updateForUse"}
+                                ]},
+                                "xaxis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"This figure shows that the execution time linearly increases with the simplification threshold parameter, meaning that the simplification cost actually is negligeable with respect to the other pipeline stages. If resolution is not important, users should select a simplification threshold of 0 along with sparse isolines to get the fastest performance."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Terrain Generation pipeline - Relative performance",
+                                "transformation":"relative_performance",
+                                "plot_types":["stacked_bar"],
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Percentage"},
+                                "color_axis":{"parameter":"perfvalue","label":"Pipeline step", "filter":[
+                                    {"Terrain_createMesh":"createMesh"}, {"Terrain_exportMesh":"exportMesh"}, {"Terrain_updateForUse":"updateForUse"}
+                                ]},
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"The figures show that the createMesh step of the pipeline takes most of the execution time (~99%)."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Terrain full pipeline - simplification threshold vs isolines step (Multithreaded)",
+                                "plot_types":["scatter","heatmap"],
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s)"},
+                                "color_axis":{"parameter":"simplification_threshold","label":"Simplification threshold"},
+                                "aggregations":[{"column":"perfvalue","agg":"filter:Terrain_elapsed"}]
+                            }
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Terrain createMesh breakdown",
+                    "contents":[
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Terrain create Mesh - Relative performance - (Multithreaded)",
+                                "plot_types":["stacked_bar"],
+                                "transformation":"relative_performance",
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s)"},
+                                "color_axis":{"label":"Step",
+                                    "filter":[
+                                        {"Terrain_createMesh_preProcess":"preProcess"},
+                                        {"Terrain_createMesh_createTileMeshes":"createTileMeshes"},
+                                        {"Terrain_createMesh_mergeTileMeshes":"mergeTileMeshes"}
+                                    ]
+                                },
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"It is seen in this figure that the createTileMeshes step of the pipeline is what dominates. Altough, tile merging is non-negligeable, taking around 5% of the execution time of the createMesh step."
+                        },
+
+                        {
+                            "type":"plot",
+                            "plot":{
+
+                                "title":"Terrain create Mesh (Multithreaded)",
+                                "plot_types":["scatter","grouped_bar"],
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s)"},
+                                "color_axis":{"label":"Step",
+                                    "filter":[
+                                        {"Terrain_createMesh_elapsed":"Total"},
+                                        {"Terrain_createMesh_preProcess":"preProcess"},
+                                        {"Terrain_createMesh_createTileMeshes":"createTileMeshes"},
+                                        {"Terrain_createMesh_mergeTileMeshes":"mergeTileMeshes"}
+                                    ]
+                                },
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"As expected, the total execution time of the `createMesh` step (represented by the 'Total' series) decreases significantly as the `isolines_step` increases, showing a clear performance improvement for coarser meshes. The `createTileMeshes` step remains the most time-consuming part of the process, consuming almost all the 'Total' time."
+                        }
+                    ]
+                },
+                {
+                    "type":"section",
+                    "title":"Performance per tile (longest thread)",
+                    "contents":[
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Tile createMesh (Multithreaded) - longest thread",
+                                "plot_types":["scatter","grouped_bar","stacked_bar"],
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s)"},
+                                "color_axis":{"label":"Method", "filter":[
+                                    {"Tile_createMesh_elapsed":"Total"},
+                                    {"Tile_createMesh_createContourMesh.max":"contourMesh"},
+                                    {"Tile_createMesh_corefineFeatures.max":"corefineFeatures"},
+                                    {"Tile_createMesh_postProcess.max":"PostProcess"}
+                                ]},
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"This figure breaks down the time spent in the `createMesh` step for the longest running tile. The total time for a single tile follows the same trend as the overall execution time with respect to the `isolines_step`. The two main contributing factors are `contourMesh` and `corefineFeatures`, with `contourMesh` generally dominating for smaller `isolines_step` (higher complexity) and `corefineFeatures` becoming more prominent as `isolines_step` increases, due to the fact that features are almost independent of the terrain elevation."
+                        },
+                        {
+                            "type":"plot",
+                            "plot":{
+                                "title":"Tile createMesh (Multithreaded) - Relative Performance - longest thread",
+                                "plot_types":["stacked_bar"],
+                                "transformation":"relative_performance",
+                                "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                "yaxis":{"label":"Execution time (s)"},
+                                "color_axis":{"label":"Method", "filter":[
+                                    {"Tile_createMesh_createContourMesh.max":"contourMesh"},
+                                    {"Tile_createMesh_corefineFeatures.max":"corefineFeatures"},
+                                    {"Tile_createMesh_postProcess.max":"PostProcess"}
+                                ]},
+                                "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                            }
+                        },
+                        {
+                            "type":"text",
+                            "text":"The relative performance breakdown of the tile meshing process clearly shows that the time is mainly split between `contourMesh` and `corefineFeatures`. As the `isolines_step` increases (less contour density), the relative contribution of the initial `contourMesh` step decreases significantly, and the `corefineFeatures` step becomes the major time sink."
+                        },
+
+
+                        {
+                            "type":"section",
+                            "title":"Computational algorithms",
+                            "contents":[
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Tile Corefine Features (Multithreaded) - longest thread",
+                                        "plot_types":["scatter","grouped_bar","stacked_bar"],
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_corefineFeatures_max":"Total"},
+                                            {"Tile_corefineFeatures_createFeatureMeshes.max":"Create Feature Meshes"},
+                                            {"Tile_corefineFeatures_postProcess.max":"PostProcess"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"This plot breaks down the execution time of the corefineFeatures stage for the longest-running tile. The total time for corefineFeatures decreases significantly as the isolines_step increases, consistent with the reduced geometric complexity. The primary cost is consistently in the PostProcess stage, which performs operations such as refinement and quality control after the initial feature mesh creation. The cost of Create Feature Meshes is relatively minor in comparison, suggesting that the initial mesh generation is quick, but the subsequent post-processing of the mesh (likely including complex geometric checks and topological cleanup) dominates the feature refinement time."
+                                },
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Tile Corefine Features (Multithreaded) - Relative Performance - longest thread",
+                                        "plot_types":["stacked_bar"],
+                                        "transformation":"relative_performance",
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_corefineFeatures_createFeatureMeshes.max":"Create Feature Meshes"},
+                                            {"Tile_corefineFeatures_postProcess.max":"PostProcess"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"The relative time distribution within the corefineFeatures step clearly indicates that the PostProcess step is the performance bottleneck, accounting for around 95% of the time in all parameter configurations. The relative contribution of Create Feature Meshes consistently remains very low (around 1-5%). As the isolines_step increases, the relative portion of Create Feature Meshes slightly increases, but PostProcess remains overwhelmingly dominant. This suggests optimization efforts should be heavily focused on improving the performance and scalability of the PostProcess algorithms within the feature corefinement stage, which mostly consist of actually performing the mesh autorefinement."
+                                },
+
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Tile Create Elevation Mesh (Multithreaded) - longest thread",
+                                        "plot_types":["scatter","grouped_bar","stacked_bar"],
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_elevation_max":"Total"},
+                                            {"Tile_elevation_buildGhostMatrix.max":"Build Ghost Matrix"},
+                                            {"Tile_elevation_computeContourLevels.max":"compute Contour Levels"},
+                                            {"Tile_elevation_createConstrainedMesh.max":"Create Constrained Mesh"},
+                                            {"Tile_elevation_matrixToMesh.max":"create Grid"},
+                                            {"Tile_elevation_preProcess.max":"preProcess"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"This figure details the time spent in the contourMesh stage (Total) for the longest-running tile. The overall time decreases significantly with increasing isolines_step. The largest single component across all runs is compute Contour Levels, often consuming the majority of the time, especially for smaller isolines_step values (high contour density). The Create Constrained Mesh time is also substantial, showing a dependence on contour density and the simplification threshold. The create Grid and preProcess steps consume a relatively small and stable portion of the total time."
+                                },
+
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Tile Create Elevation Mesh (Multithreaded) - Relative Performance - longest thread",
+                                        "plot_types":["stacked_bar"],
+                                        "transformation":"relative_performance",
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_elevation_buildGhostMatrix.max":"Build Ghost Matrix"},
+                                            {"Tile_elevation_computeContourLevels.max":"compute Contour Levels"},
+                                            {"Tile_elevation_createConstrainedMesh.max":"Create Constrained Mesh"},
+                                            {"Tile_elevation_matrixToMesh.max":"create Grid"},
+                                            {"Tile_elevation_preProcess.max":"preProcess"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"The relative breakdown of the elevation mesh creation process highlights the trade-off in computational cost driven by the isolines_step. For high-fidelity meshes (isolines_step=1.0), compute Contour Levels is the largest component, consuming over 60% of the time. As the isolines_step increases (sparser contours), its relative share decreases. Simultaneously, the relative cost of the Create Constrained Mesh step increases, becoming the dominant factor for sparser meshes (isolines_step=20.0), accounting for over 40% of the time. This crossover indicates that optimization strategies should target contour computation for dense meshes and the constrained meshing process for sparser meshes."
+                                },
+
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Constrained Mesher (Multithreaded) - longest thread",
+                                        "plot_types":["scatter","grouped_bar","stacked_bar"],
+                                        "transformation":"performance",
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_constrainedMesher_max":"Total"},
+                                            {"Tile_constrainedMesher_cgalToMesh.max":"CGAL to Mesh"},
+                                            {"Tile_constrainedMesher_createCgalTriangulation.max":"create Triangulation"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"This chart focuses on the internal performance of the constrained mesher process within the tile meshing stage. The total time dramatically decreases as the isolines_step increases. The breakdown shows that the time is overwhelmingly dominated by the create Triangulation step, often taking over 90% of the total time within this subprocess. The time spent converting the CGAL output back to a Mesh (CGAL to Mesh) is consistently negligible in comparison across all parameters. This confirms that the geometric constraint satisfaction and triangulation algorithm itself is the computational bottleneck."
+                                },
+
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Tile Create Elevation Mesh (Multithreaded) - Relative Performance - longest thread",
+                                        "plot_types":["stacked_bar"],
+                                        "transformation":"relative_performance",
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"label":"Method", "filter":[
+                                            {"Tile_constrainedMesher_cgalToMesh.max":"CGAL to Mesh"},
+                                            {"Tile_constrainedMesher_createCgalTriangulation.max":"create Triangulation"}
+                                        ]},
+                                        "secondary_axis":{ "parameter": "simplification_threshold", "label":"Simplification threshold" }
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"This relative view of the constrained mesher (excluding pre-computation steps) clearly emphasizes that create Triangulation is the dominant operation, maintaining a relative cost of over 82% and frequently over 95%. This indicates that the choice of isolines_step and simplification_threshold dramatically affects the intrinsic difficulty of the constrained triangulation operation."
+                                },
+
+                                {
+                                    "type":"plot",
+                                    "plot":{
+                                        "title":"Constrained Triangulation + Simplification (Multithreaded) - longest thread",
+                                        "plot_types":["heatmap"],
+                                        "xaxis":{ "parameter":"isolines_step", "label":"Isolines Step" },
+                                        "yaxis":{"label":"Execution time (s)"},
+                                        "color_axis":{"parameter":"simplification_threshold","label":"Simplification threshold"},
+                                        "aggregations":[{"column":"perfvalue","agg":"filter:Tile_constrainedMesher_createCgalTriangulation.max"}]
+                                    }
+                                },
+                                {
+                                    "type":"text",
+                                    "text":"This heatmap shows the absolute time spent solely in the main computational core of the constrained meshing process (create Triangulation). The color gradient confirms the primary observations: the total time is minimized at the highest isolines_step (20.0, lowest row) and lowest simplification_threshold (0.0, leftmost column)."
+                                }
+
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/ktirio-geom/terrain/perlin/perlin.json b/src/ktirio-geom/terrain/perlin/perlin.json
new file mode 100644
index 0000000..9f5ac45
--- /dev/null
+++ b/src/ktirio-geom/terrain/perlin/perlin.json
@@ -0,0 +1,79 @@
+{
+    "bin_dir":"/data/scratch/cladellash/bin",
+    "executable":"{{bin_dir}}/ktirio_geom_app_terrain",
+    "use_case_name":"Perlin",
+    "timeout":"0-0:10:0",
+    "output_directory": "{{machine.output_app_dir}}/terrain/{{use_case_name}}/{{instance}}",
+    "input_file_dependencies":{
+        "cfg" : "ktirio-geom/terrain/{{use_case_name}}/perlin.cfg"
+    },
+    "platforms": {
+        "builtin":{
+            "input_dir":"{{machine.input_dataset_base_dir}}"
+        }
+    },
+    "options":[
+        "--config-file {{platforms.{{machine.platform}}.input_dir}}/{{input_file_dependencies.cfg}}",
+        "--input.terrain.output-directory={{output_directory}}",
+        "--input.terrain.perlin.tile-grid-size={{parameters.tile_grid_size.value}}",
+        "--input.terrain.perlin.terrain-grid-size={{parameters.terrain_grid_size.value}}",
+        "--input.multithreaded={{fixed.multithreaded}}"
+    ],
+    "scalability":{
+        "directory":"{{output_directory}}",
+        "stages":[
+            {
+                "name":"Terrain",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.times.*","terrain.subsections.*.times.elapsed"]
+            },
+            {
+                "name":"Terrain_createMesh",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.times.*","terrain.subsections.createMesh.subsections.*.times.elapsed"]
+            },
+            {
+                "name":"Tile_createMesh",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.*.times.*"]
+            },
+            {
+                "name":"Tile_elevation",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.*.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.times.*"]
+            },
+            {
+                "name":"Tile_corefineFeatures",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.corefineFeatures.subsections.*.times.*","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.corefineFeatures.times.*"]
+            },
+            {
+                "name":"Tile_constrainedMesher",
+                "filepath":"timekeeper.json",
+                "format":"json",
+                "variables_path":["terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.createConstrainedMesh.subsections.*.times","terrain.subsections.createMesh.subsections.createTileMeshes.subsections.createMesh.subsections.createContourMesh.subsections.createConstrainedMesh.times.*"]
+            }
+        ]
+    },
+    "resources":{
+        "tasks":1,
+        "exclusive_access":false
+    },
+    "sanity":{
+        "success":["TERRAIN done in"],
+        "error":[]
+    },
+    "fixed":{
+        "multithreaded": "true"
+    },
+    "parameters":[
+        { "name": "tile_grid_size", "range":{"min":200,"max":1000,"step":200} },
+        { "name": "terrain_grid_size", "range":{"min":1,"max":5,"step":1} },
+        {"name":"triangles","sequence":[0]}
+    ]
+}
\ No newline at end of file
diff --git a/src/ktirio-geom/terrain/perlin/perlin_plots.json b/src/ktirio-geom/terrain/perlin/perlin_plots.json
new file mode 100644
index 0000000..e16f2f8
--- /dev/null
+++ b/src/ktirio-geom/terrain/perlin/perlin_plots.json
@@ -0,0 +1,207 @@
+{
+    "data": [
+        {
+            "type": "DataTable",
+            "name": "reframe_df_parsed",
+            "ref": "reframe_df",
+            "table_options":{
+                "computed_columns":{
+                    "triangles": "2*(row[\"tile_grid_size\"]*row[\"terrain_grid_size\"])**2"
+                }
+            }
+        }
+    ],
+    "contents":[
+
+        {
+            "type":"section",
+            "title":"Benchmark Execution Summary",
+            "contents": [
+                {
+                    "type":"section",
+                    "title":"Session",
+                    "contents":[
+                        {
+                            "type":"itemize",
+                            "ref":"reframe_json",
+                            "items":[
+                                "Hostname: @{session_info.hostname}@",
+                                "User: @{session_info.user}@",
+                                "Time Start: @{session_info.time_start}@",
+                                "Time End: @{session_info.time_end}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Cases",
+                    "contents": [
+                        {
+                            "type": "itemize",
+                            "ref": "reframe_json",
+                            "items": [
+                                "Total: @{session_info.num_cases}@",
+                                "Failures: @{session_info.num_failures}@",
+                                "Runs: @{runs | length}@"
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Parametrization",
+                    "contents": [
+                        {
+                            "type": "table",
+                            "ref": "parameter_table",
+                            "layout": {
+                                "column_order": ["result", "testcases.hashcode", "tile_grid_size", "terrain_grid_size", "triangles", "logs_link"],
+                                "rename": { "testcases.hashcode": "Hash", "result": "", "logs_link": "" }
+                            },
+                            "style": {
+                                "column_align": { "result": "center" },
+                                "column_width": { "result": 1, "logs_link": 1 },
+                                "classnames": ["scrollable", "sortable"]
+                            },
+                            "filter": { "placeholder": "Filter testcases..." }
+                        }
+                    ]
+                }
+            ]
+        },
+
+        {
+            "type": "section",
+            "title": "Benchmark: Ktirio-Geom - Perlin Noise Terrain Generation",
+            "contents": [
+                {
+                    "type": "section",
+                    "title": "Description",
+                    "contents": [
+                        {
+                            "type": "text",
+                            "text": "This benchmark evaluates the performance of Ktirio-Geom when generating synthetic terrains using Perlin noise. The pipeline produces structured terrain meshes with varying levels of detail, controlled by tile and terrain grid parameters."
+                        },
+                        {
+                            "type": "text",
+                            "text": "The workflow uses multithreaded execution and advanced geometric algorithms for mesh creation, including tile-based meshing, elevation grid computation, and feature refinement. The focus is on scalability with respect to the number of tiles, terrain resolution, and resulting mesh complexity."
+                        },
+                        {
+                            "type": "text",
+                            "text": "Two main parameters are explored: tile grid size, which controls the size and number of individual tiles, and terrain grid size, which defines the resolution of each tile. These parameters directly affect the total number of triangles in the mesh and the computational load of the pipeline."
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Benchmarking Tools Used",
+                    "contents": [
+                        {
+                            "type": "text",
+                            "text": "Performance measurements were collected using internal timing instrumentation integrated into Ktirio-Geom. Each stage of the pipeline reports elapsed wall-clock time, with per-tile statistics for multithreaded sections."
+                        },
+                        {
+                            "type": "text",
+                            "text": "For tile-level operations, the benchmark reports the longest-running tile thread to reflect critical-path execution and scalability limits."
+                        }
+                    ]
+                },
+                {
+                    "type": "section",
+                    "title": "Input / Output Dataset Description",
+                    "contents": [
+                        {
+                            "type": "section",
+                            "title": "Input Data",
+                            "contents": [
+                                {
+                                    "type": "itemize",
+                                    "items": [
+                                        "Perlin noise configuration file defining terrain generation parameters.",
+                                        "Tile grid and terrain grid resolution parameters controlling the mesh granularity."
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            "type": "section",
+                            "title": "Output Data",
+                            "contents": [
+                                {
+                                    "type": "text",
+                                    "text": "The output consists of triangulated terrain meshes with per-tile breakdowns and total execution time for each major processing stage. These outputs are suitable for simulation, visualization, and further geometric processing."
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+
+        {
+            "type": "section",
+            "title": "Results Summary",
+            "contents": [
+                {
+                    "type": "text",
+                    "text": "The results show a strong correlation between total execution time and both tile and terrain grid sizes. As tile grid size increases, total time grows due to the larger number of triangles per tile. Increasing terrain grid size also significantly increases computational cost, reflecting higher mesh resolution."
+                },
+                {
+                    "type": "text",
+                    "text": "Multithreaded execution reduces wall-clock time but shows diminishing returns at larger grid sizes, indicating critical-path limitations in tile-level processing."
+                }
+            ]
+        },
+        {
+            "type": "section",
+            "title": "Results",
+            "contents": [
+                {
+                    "type": "section",
+                    "title": "Total Time",
+                    "contents": [
+                        {
+                            "type":"plot",
+                            "ref":"reframe_df_parsed",
+                            "plot":{
+                                "title":"Complexity for tile grid size",
+                                "plot_types":["scatter","grouped_bar"],
+                                "xaxis":{ "parameter":"tile_grid_size", "label":"Tile size" },
+                                "yaxis":{"label":"Execution time (s) - multithreaded"},
+                                "color_axis":{"label":"Pipeline step", "filter":[ {"Terrain_elapsed":"Total"} ]},
+                                "secondary_axis":{ "parameter": "terrain_grid_size", "label":"Terrain Grid Size" }
+                            }
+                        },
+                        {
+                            "type":"plot",
+                            "ref":"reframe_df_parsed",
+                            "plot":{
+                                "title":"Complexity for terrain grid size",
+                                "plot_types":["scatter","grouped_bar"],
+                                "secondary_axis":{ "parameter":"tile_grid_size", "label":"Tile size" },
+                                "yaxis":{"label":"Execution time (s) - multithreaded"},
+                                "color_axis":{"label":"Pipeline step", "filter":[ {"Terrain_elapsed":"Total"} ]},
+                                "xaxis":{ "parameter": "terrain_grid_size", "label":"Terrain Grid Size" }
+                            }
+                        },
+
+                        {
+                            "type":"plot",
+                            "ref":"reframe_df_parsed",
+                            "plot":{
+                                "title":"Complexity for total number of initial triangles",
+                                "plot_types":["scatter","grouped_bar"],
+                                "xaxis":{ "parameter":"triangles", "label":"Initial triangles" },
+                                "yaxis":{"label":"Execution time (s) - multithreaded"},
+                                "color_axis":{"label":"Pipeline step", "filter":[ {"Terrain_elapsed":"Total"} ]},
+                                "aggregations":[{ "column":"terrain_grid_size", "agg":"max" }]
+
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/src/utils/report.hpp b/src/utils/report.hpp
index 7544e20..d8a0669 100644
--- a/src/utils/report.hpp
+++ b/src/utils/report.hpp
@@ -42,12 +42,12 @@ class Report {
         }
     }
 
-    void setMeasure(const std::string name, double value)
+    void setMeasure(std::string const& name, double value)
     {
         M_data[name] = value;
     }
 
-    double getMeasure(const std::string name)
+    double getMeasure(std::string const& name)
     {
         return M_data.at(name);
     }
diff --git a/system_entrypoints/feelpp.sh b/system_entrypoints/feelpp.sh
deleted file mode 100644
index 0647826..0000000
--- a/system_entrypoints/feelpp.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install feelpp-benchmarking
\ No newline at end of file
diff --git a/system_entrypoints/feelpp1.sh b/system_entrypoints/feelpp1.sh
deleted file mode 100644
index 0647826..0000000
--- a/system_entrypoints/feelpp1.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install feelpp-benchmarking
\ No newline at end of file
diff --git a/system_entrypoints/feelpp2.sh b/system_entrypoints/feelpp2.sh
deleted file mode 100644
index 0647826..0000000
--- a/system_entrypoints/feelpp2.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install feelpp-benchmarking
\ No newline at end of file
diff --git a/system_entrypoints/feelpp3.sh b/system_entrypoints/feelpp3.sh
deleted file mode 100644
index 0647826..0000000
--- a/system_entrypoints/feelpp3.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install feelpp-benchmarking
\ No newline at end of file
diff --git a/system_entrypoints/feelpp4.sh b/system_entrypoints/feelpp4.sh
deleted file mode 100644
index 0647826..0000000
--- a/system_entrypoints/feelpp4.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash
-
-python3 -m venv .venv
-source .venv/bin/activate
-python3 -m pip install feelpp-benchmarking
\ No newline at end of file
diff --git a/system_entrypoints/meluxina_launchBenchmark.sh b/system_entrypoints/meluxina_launchBenchmark.sh
index 727d873..df4ee57 100644
--- a/system_entrypoints/meluxina_launchBenchmark.sh
+++ b/system_entrypoints/meluxina_launchBenchmark.sh
@@ -25,6 +25,6 @@ feelpp-benchmarking-exec \
     -mc $MACHINE_CONFIG \
     -bc $BENCHMARK_CONFIG \
     -pc $PLOTS_CONFIG \
-    -rc ./tmp_system_entrypoints/meluxina_rfm.py \
+    -rc ./system_entrypoints/meluxina_rfm.py \
     -v \
     -rfm="-v --exec-order=name --max-retries=0"
\ No newline at end of file
diff --git a/test.slurm b/test.slurm
deleted file mode 100644
index fa1723d..0000000
--- a/test.slurm
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-#SBATCH -p public
-#SBATCH -n 10
-#SBATCH -J test
-#SBATCH -o job%j-o.log
-#SBATCH -e job%j-e.log
-echo "Hello world"
-mpirun -np 10 -bind-to core feelpp_toolbox_heat --config-file /usr/share/feelpp/data/testcases/toolboxes/heat/cases/Building/ThermalBridgesENISO10211/case3.cfg
\ No newline at end of file