dumux simulation can run via snakemake rule

Author: Sarbani-Roy

benchmarks/rotating-cylinders/Snakefile

@@ -0,0 +1,70 @@
+# benchmarks/rotating-cylinders/Snakefile
+
+import json
+import os
+
+# --------------------------
+# Load workflow configuration
+# --------------------------
+with open("rotating-cylinders_config.json") as f:
+    config = json.load(f)
+
+tools = config["tools"]
+benchmark = config["benchmark"]
+benchmark_uri = config["benchmark_uri"]
+configurations = config["configurations"]
+config_to_param = config["configuration_to_parameter_file"]
+config_to_vtu_files = config.get("configuration_to_solution_vtu_files", {})
+
+# --------------------------
+# Helper functions
+# --------------------------
+def parameter_file(cfg):
+    return config_to_param[cfg]
+
+def vtu_files(cfg):
+    return config_to_vtu_files.get(cfg, [])
+
+def summary_file(tool_name):
+    return f"{tool_name}_summary.json"
+
+# --------------------------
+# Include tool Snakefiles
+# --------------------------
+for tool in tools:
+    include: f"{tool}/Snakefile"
+
+# --------------------------
+# Global result directory
+# --------------------------
+result_dir = f"snakemake_results/rotating-cylinders"
+
+# --------------------------
+# Rule: Aggregate all outputs
+# --------------------------
+rule all:
+    input:
+        expand(f"{result_dir}/dumux/solution_metrics_{{configuration}}.json", configuration=configurations),
+        expand(f"{result_dir}/dumux/solution_field_data_{{configuration}}.zip", configuration=configurations)
+
+# --------------------------
+# Rule: Create summary
+# --------------------------
+rule create_summary:
+    input:
+        parameter_files=[parameter_file(cfg) for cfg in configurations],
+        solution_vtu_files=sum([vtu_files(cfg) for cfg in configurations], [])  # flatten list of lists
+    output:
+        summary=summary_file("dumux")
+    params:
+        configs=configurations
+    shell:
+        """
+        python create_dumux_summary.py \
+            --input_configuration {params.configs} \
+            --input_parameter_file {input.parameter_files} \
+            --input_solution_vtu {input.solution_vtu_files} \
+            --input_benchmark "{benchmark}" \
+            --input_benchmark_uri "{benchmark_uri}" \
+            --output_summary_json {output.summary}
+        """

benchmarks/rotating-cylinders/config_template.json

@@ -0,0 +1,8 @@
+{
+    "benchmark": "rotating-cylinders",
+    "benchmark_uri": "https://www.openfoam.com/documentation/guides/latest/doc/verification-validation-rotating-cylinders-2d.html",
+    "tools": ["dumux"],
+    "configurations": [],
+    "configuration_to_parameter_file": {},
+    "configuration_to_solution_vtu_files": {}
+}

benchmarks/rotating-cylinders/create_dumux_summary.py

@@ -0,0 +1,53 @@
+import json
+import argparse
+import meshio
+
+def create_dumux_summary(configurations, parameter_files, solution_vtu_files, benchmark, benchmark_uri, summary_json):
+    summaries = []
+    for cfg, param_file, vtu_file in zip(configurations, parameter_files, solution_vtu_files):
+        summary = {
+            "benchmark": benchmark,
+            "benchmark_uri": benchmark_uri,
+            "configuration": cfg
+        }
+        # Load parameters
+        with open(param_file) as f:
+            summary["parameters"] = json.load(f)
+
+        summary["solution_vtu"] = vtu_file
+
+        # Extract field summaries
+        vtu = meshio.read(vtu_file)
+        field_summaries = {}
+        for key, data in vtu.point_data.items():
+            field_summaries[key] = {
+                "min": float(data.min()),
+                "max": float(data.max()),
+                "mean": float(data.mean())
+            }
+        summary["solution_fields_summary"] = field_summaries
+
+        summaries.append(summary)
+
+    with open(summary_json, "w") as f:
+        json.dump(summaries, f, indent=4)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_configuration", nargs="+", required=True)
+    parser.add_argument("--input_parameter_file", nargs="+", required=True)
+    parser.add_argument("--input_solution_vtu", nargs="+", required=True)
+    parser.add_argument("--input_benchmark", required=True)
+    parser.add_argument("--input_benchmark_uri", required=True)
+    parser.add_argument("--output_summary_json", required=True)
+    args = parser.parse_args()
+
+    create_dumux_summary(
+        args.input_configuration,
+        args.input_parameter_file,
+        args.input_solution_vtu,
+        args.input_benchmark,
+        args.input_benchmark_uri,
+        args.output_summary_json
+    )

benchmarks/rotating-cylinders/dumux/Snakefile

@@ -1,26 +1,54 @@
-# Snakefile — rotating cylinders benchmark
-
 import os
-import glob
 
+# 1. Setup and Config
 tool = "dumux"
+result_dir = f"snakemake_results/rotating-cylinders/{tool}"
+configurations = config["configurations"]
+configuration_to_parameter_file = config["configuration_to_parameter_file"]
+vtu_mapping = config["configuration_to_solution_vtu_files"]
 
-# Directory where simulation writes VTU files
-output_dir = "."
+container_image = "git.iws.uni-stuttgart.de:4567/benchmarks/rotating-cylinders:3.0"
+shared_dir = os.getcwd()
+# dumux_input = f"{shared_dir}/{tool}/input_files" 
+dumux_dir = f"{shared_dir}/{tool}" 
 
-# Dynamically find all VTU files starting with "test_rotatingcylinders"
-vtu_files = glob.glob(os.path.join(output_dir, "test_rotatingcylinders*.vtu"))
+# Rule 1: Only runs the simulation, outputs the VTU files
+rule run_dumux_simulation:
+    input:
+        params=lambda wildcards: f"{dumux_dir}/input_files/{configuration_to_parameter_file[wildcards.configuration]}"
+    output:
+        # Use a list of the actual files you expect
+        vtu_files = [
+            f"{tool}/test_rotatingcylinders_{{configuration}}-00000.vtu",
+            f"{tool}/test_rotatingcylinders_{{configuration}}-00001.vtu"
+        ]
+    resources:
+        serial_run=1
+    singularity:
+        f"docker://{container_image}"
+    shell:
+        """
+        set -euo pipefail
+        cd /dumux/rotating-cylinders/build-cmake/test/freeflow/navierstokes/rotatingcylinders
+        ./test_ff_navierstokes_rotatingcylinders {input.params} -IO.OutputPath {dumux_dir}
+        """
 
-rule run_rotating_cylinders_simulation:
+# Rule 2: Only runs post-processing, depends on the VTU files
+rule postprocess_dumux:
     input:
-        script = "docker_rotatingCylinders.sh"
+        sim_data = [
+            f"{tool}/test_rotatingcylinders_{{configuration}}-00000.vtu",
+            f"{tool}/test_rotatingcylinders_{{configuration}}-00001.vtu"
+        ],
+        postprocess_script=f"{tool}/run_dumux_postprocessing.py"
     output:
-        # We can use a sentinel file since the container produces multiple outputs
-        os.path.join(output_dir, ".simulation_done")
-    conda:
-        "environment.yaml",
+        metrics=f"{result_dir}/solution_metrics_{{configuration}}.json",
+        fields=f"{result_dir}/solution_field_data_{{configuration}}.zip"
     shell:
         """
-        bash {input.script} open
-        touch {output}
+        python3 {input.postprocess_script} \
+            --input_dumux_output_dir {dumux_dir} \
+            --input_configuration {wildcards.configuration} \
+            --output_solution_file_zip {output.fields} \
+            --output_metrics_file {output.metrics}
         """

benchmarks/rotating-cylinders/dumux/docker_rotatingCylinders.sh

@@ -0,0 +1,93 @@
+import json
+import zipfile
+from argparse import ArgumentParser
+from pathlib import Path
+
+import meshio
+import numpy as np
+
+
+def run_dumux_postprocessing(
+    dumux_output_dir: str,
+    configuration: str,
+    metrics_file: str,
+    solution_file_zip: str,
+) -> None:
+    dumux_output_dir = Path(dumux_output_dir)
+
+    # ---- read all VTU / PVTU files ----
+    vtk_files = list(dumux_output_dir.glob("*.vtu")) + list(
+        dumux_output_dir.glob("*.pvtu")
+    )
+    if not vtk_files:
+        raise RuntimeError("No VTU/PVTU files found in DuMuX output directory")
+
+    # Read first file for metrics (extend if needed)
+    mesh = meshio.read(vtk_files[0])
+
+    metrics = {}
+
+    # ---- example metrics (adapt to benchmark definition) ----
+    if "p" in mesh.cell_data_dict:
+        p = mesh.cell_data_dict["p"]
+        # flatten possible block structure
+        p_vals = np.concatenate([np.asarray(v).ravel() for v in p.values()])
+        metrics["min_pressure"] = float(np.min(p_vals))
+        metrics["max_pressure"] = float(np.max(p_vals))
+        metrics["mean_pressure"] = float(np.mean(p_vals))
+
+    if "velocity_liq (m/s)" in mesh.cell_data_dict:
+        v = mesh.cell_data_dict["velocity_liq (m/s)"]
+        v_vals = np.concatenate([np.asarray(vv) for vv in v.values()])
+        speed = np.linalg.norm(v_vals, axis=1)
+        metrics["max_velocity_magnitude"] = float(np.max(speed))
+        metrics["mean_velocity_magnitude"] = float(np.mean(speed))
+
+    # ---- write metrics JSON ----
+    with open(metrics_file, "w") as f:
+        json.dump(metrics, f, indent=4)
+
+    # ---- zip solution field data ----
+    with zipfile.ZipFile(solution_file_zip, "w", zipfile.ZIP_DEFLATED) as zipf:
+        for file in vtk_files:
+            zipf.write(file, arcname=file.name)
+
+    # ---- cleanup: delete original VTU/PVTU files ----
+    for ext in ["*.vtu", "*.pvtu", "*.pvd"]:
+        for file in dumux_output_dir.glob(ext):
+            file.unlink()
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(
+        description="Post-process DuMuX results into benchmark artifacts"
+    )
+    parser.add_argument(
+        "--input_dumux_output_dir",
+        required=True,
+        help="Directory containing DuMuX VTU/PVTU files",
+    )
+    parser.add_argument(
+        "--input_configuration",
+        required=True,
+        help="Configuration name",
+    )
+    parser.add_argument(
+        "--output_metrics_file",
+        required=True,
+        help="Path to solution_metrics_{configuration}.json",
+    )
+    parser.add_argument(
+        "--output_solution_file_zip",
+        required=True,
+        help="Path to solution_field_data_{configuration}.zip",
+    )
+
+    args = parser.parse_args()
+
+    run_dumux_postprocessing(
+        args.input_dumux_output_dir,
+        args.input_configuration,
+        args.output_metrics_file,
+        args.output_solution_file_zip,
+    )

benchmarks/rotating-cylinders/dumux/run_dumux_postprocessing.py

@@ -8,3 +8,4 @@ dependencies:
   - pip
   - pip:
       - snakemake
+      - meshio