one ro-crate per tool, automatic creation of snakefile for a tool workflow

Author: dtyagi

.github/workflows/run-benchmark.yml

@@ -44,31 +44,52 @@ jobs:
           cd $GITHUB_WORKSPACE/benchmarks/linear-elastic-plate-with-hole/
           python generate_config.py
 
+      - name: generate-snakemake-fenics-workflow
+        shell: bash -l {0}
+        run: |
+          cd $GITHUB_WORKSPACE/benchmarks/common/
+          python simulation_tool_snakefile_generator.py --tool fenics --simulation_script run_fenics_simulation.py --environment_file environment_simulation.yml
+
       - name: run_linear-elastic-plate-with-hole-benchmarks_snakemake
         shell: bash -l {0}
         run: |
           cd $GITHUB_WORKSPACE/benchmarks/linear-elastic-plate-with-hole/
-          snakemake --use-conda --force --cores 'all'
-          snakemake --use-conda --force --cores all \
+          snakemake --use-conda --force --cores 'all' --config tool="fenics"
+          snakemake --use-conda --force --cores all --config tool="fenics" \
             --reporter metadata4ing \
             --report-metadata4ing-paramscript ../common/parameter_extractor.py \
-            --report-metadata4ing-filename snakemake_provenance
-          unzip snakemake_provenance -d snakemake_provenance
+            --report-metadata4ing-filename snakemake_provenance_fenics
+          unzip snakemake_provenance_fenics -d snakemake_provenance_fenics
+
+          snakemake --use-conda --force --cores 'all' --config tool="kratos"
+          snakemake --use-conda --force --cores all --config tool="kratos" \
+            --reporter metadata4ing \
+            --report-metadata4ing-paramscript ../common/parameter_extractor.py \
+            --report-metadata4ing-filename snakemake_provenance_kratos
+          unzip snakemake_provenance_kratos -d snakemake_provenance_kratos
       
       - name: run_linear-elastic-plate-with-hole-benchmarks_nextflow
         shell: bash -l {0}
         run: |
           cd $GITHUB_WORKSPACE/benchmarks/linear-elastic-plate-with-hole/
-          nextflow run main.nf -params-file workflow_config.json -c ../common/nextflow.config -plugins [email protected]
+          nextflow run main.nf -params-file workflow_config.json --tool="fenics" -c ../common/nextflow.config -plugins [email protected]
+          nextflow run main.nf -params-file workflow_config.json --tool="kratos"  -c ../common/nextflow.config -plugins [email protected]
+
+      - name: Archive Linear Elastic plate with a hole benchmark data for snakemake fenics
+        uses: actions/upload-artifact@v4
+        with:
+            name: snakemake_fenics_result_linear-elastic-plate-with-hole
+            path: |
+              benchmarks/linear-elastic-plate-with-hole/snakemake_provenance_fenics/
 
-      - name: Archive Linear Elastic plate with a hole benchmark data for snakemake
+      - name: Archive Linear Elastic plate with a hole benchmark data for snakemake kratos
         uses: actions/upload-artifact@v4
         with:
-            name: snakemake_results_linear-elastic-plate-with-hole
+            name: snakemake_kratos_result_linear-elastic-plate-with-hole
             path: |
-              benchmarks/linear-elastic-plate-with-hole/snakemake_provenance/
+              benchmarks/linear-elastic-plate-with-hole/snakemake_provenance_kratos/
 
-      - name: Archive Linear Elastic plate with a hole benchmark data for nextflow
+      - name: Archive Linear Elastic plate with a hole benchmark data for nextflow fenics
         uses: actions/upload-artifact@v4
         with:
             name: nextflow_results_linear-elastic-plate-with-hole
@@ -82,10 +103,16 @@ jobs:
       - name: Checkout repo content
         uses: actions/checkout@v2
 
-      - name: Download artifact
+      - name: Download snakemake fenics artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: snakemake_fenics_result_linear-elastic-plate-with-hole
+          path: ./snakemake_provenance
+
+      - name: Download snakemake kratos artifact
         uses: actions/download-artifact@v4
         with:
-          name: snakemake_results_linear-elastic-plate-with-hole
+          name: snakemake_kratos_result_linear-elastic-plate-with-hole
           path: ./snakemake_provenance
 
       - name: Setup Mambaforge with postprocessing env

.gitignore

@@ -3,23 +3,24 @@ conda {
 }
 
 params.result_dir = "nextflow_results/${params.benchmark}"
+params.tool = "kratos"  // default tool
 
 prov {
    formats {
       dag {
-         file = "${params.result_dir}/nf_prov_dag.html"
+         file = "${params.result_dir}/${params.tool}/nf_prov_dag.html"
          overwrite = true
       }
       legacy {
-         file = "${params.result_dir}/nf_prov_legacy.json"
+         file = "${params.result_dir}/${params.tool}/nf_prov_legacy.json"
          overwrite = true
       }
       wrroc {
          agent {
             name = 'Firstname Lastname'
             orcid = 'https://orcid.org/0000-0000-0000-0000'
          }
-         file = "${params.result_dir}/ro-crate-metadata.json"
+         file = "${params.result_dir}/${params.tool}/ro-crate-metadata.json"
          license = 'https://spdx.org/licenses/MIT'
          overwrite = true
       }

benchmarks/common/nextflow.config

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+Script to generate a Snakefile for simulation tools in the benchmark workflow.
+
+This script creates a standardized Snakefile that follows the expected output format
+for integration with the main benchmark workflow.
+"""
+
+import argparse
+import os
+from pathlib import Path
+
+
+def generate_snakefile(tool_name: str, environment_file: str, simulation_script: str, output_path: str = None):
+    """
+    Generate a Snakefile for a simulation tool.
+    
+    Args:
+        tool_name: Name of the simulation tool (e.g., 'fenics', 'kratos')
+        environment_file: Path to the conda environment YAML file (relative to tool directory)
+        simulation_script: Path to the simulation Python script (relative to tool directory)
+        output_path: Optional path where to save the Snakefile. If None, saves to {tool_name}/Snakefile
+    """
+    
+    # Template for the Snakefile
+    
+    snakefile_template = f'''import json
+import os
+
+tool = "{tool_name}"
+result_dir = "snakemake_results/" + config["benchmark"] 
+configuration_to_parameter_file = config["configuration_to_parameter_file"]
+configurations = config["configurations"]
+
+
+rule run_{tool_name}_simulation:
+    input: 
+        script = "{{tool}}/{simulation_script}",
+        parameters = lambda wildcards: configuration_to_parameter_file[wildcards.configuration],
+        mesh = f"{{result_dir}}/mesh/mesh_{{{{configuration}}}}.msh",
+    output:
+        zip = f"{{result_dir}}/{{{{tool}}}}/solution_field_data_{{{{configuration}}}}.zip",
+        metrics = f"{{result_dir}}/{{{{tool}}}}/solution_metrics_{{{{configuration}}}}.json",
+    conda:
+        "{environment_file}",
+    shell:
+        """
+        python3 {{input.script}} --input_parameter_file {{input.parameters}} --input_mesh_file {{input.mesh}} --output_solution_file_zip {{output.zip}} --output_metrics_file {{output.metrics}}
+        """
+    '''
+    
+    # Determine output path
+    if output_path is None:
+        output_path = f"../linear-elastic-plate-with-hole/{tool_name}/Snakefile"
+    
+    # Write the Snakefile
+    with open(output_path, 'w') as f:
+        f.write(snakefile_template)
+    
+    print(f"Snakefile generated successfully: {output_path}")
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate a simulation-tool-specific Snakefile for running the simulation.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=
+    """
+    !IMPORTANT!:The scripts to be stored inside the tool's sub-directory in the benchmark folder. E.g., benchmarks/linear-elastic-plate-with-hole/tool_name/
+    
+    Execution example for fenics:
+    python generate_tool_snakefile.py --tool fenics --env environment_simulation.yml --script run_fenics_simulation.py
+
+    The simulation script must accept these command-line arguments:
+      --input_parameter_file: JSON file with simulation parameters
+      --input_mesh_file: Input mesh file (.msh format)
+      --output_solution_file_zip: Output ZIP file containing solution visualization files (VTK)
+      --output_metrics_file: Output JSON file with computed metrics
+
+    """
+    )
+    
+    parser.add_argument(
+        '--tool',
+        type=str,
+        required=True,
+        help='Name of the simulation tool (e.g., fenics, kratos, abaqus)'
+    )
+    
+    parser.add_argument(
+        '--environment_file',
+        type=str,
+        required=True,
+        help='Conda environment YAML file name'
+    )
+    
+    parser.add_argument(
+        '--simulation_script',
+        type=str,
+        required=True,
+        help='Simulation script name'
+    )
+    
+    args = parser.parse_args()
+    
+    generate_snakefile(
+        tool_name=args.tool,
+        environment_file=args.environment_file,
+        simulation_script=args.simulation_script
+    )
+
+if __name__ == "__main__":
+    main()
+
+

benchmarks/common/simulation_tool_snakefile_generator.py

@@ -4,14 +4,14 @@ configfile: "workflow_config.json"
 result_dir = "snakemake_results/" + config["benchmark"] 
 configuration_to_parameter_file = config["configuration_to_parameter_file"]
 configurations = config["configurations"]
-tools = config["tools"]
+tool = config["tool"]
 benchmark = config["benchmark"]
 benchmark_uri = config["benchmark_uri"]
 
 
 rule all:
     input:
-        expand(f"{result_dir}/{{tool}}/summary.json", tool=tools),
+        expand(f"{result_dir}/{{tool}}/summary.json", tool=tool),
 
 rule create_mesh:    
     input:
@@ -34,8 +34,8 @@ rule create_mesh:
 # solution_metrics_{configuration}.json and 
 # and solution_field_data_{configuration}.zip whee all the visualization files are stored
 # (e.g. vtk)
-for tool in tools:
-    include: f"{tool}/Snakefile"
+#for tool in tools:
+include: f"{tool}/Snakefile"
 
 
 rule summary:
@@ -70,12 +70,6 @@ rule summary:
         """
 
 """ 
-Steps to add a new simulation tool to the workflow:
-
-1. Write the tool-specific workflow, scripts, environment file and store them in the benchmarks/linear-elastic-plate-with-hole/tool_name/.
-2. Add the tool name to "tools" workflow_config.json (generated here using generate_config.py)
-
-------------------------------------------------------------------------------------------------------------------------
 "rule all" defines the final target of the workflow. Knowing the final target, the snakemake determines
 the dependency chain automatically.
 

benchmarks/linear-elastic-plate-with-hole/README.md

@@ -10,6 +10,7 @@ dependencies:
   - python=3.12
   - fenics-dolfinx=0.9.*
   - libadios2=2.10.1
+  - mpich
   - petsc4py
   - pint
   - python-gmsh

benchmarks/linear-elastic-plate-with-hole/Snakefile

@@ -39,15 +39,13 @@ def get_configuration(file):
 # Reverse mapping for easy lookup by configuration name
 configuration_to_parameter_file = {v: str(k) for k, v in configurations.items()}
 
-tools = ["fenics", "kratos"]
 benchmark = "linear-elastic-plate-with-hole"
 benchmark_uri = "https://portal.mardi4nfdi.de/wiki/Model:6775296"
 
 # Template for workflow config
 workflow_config = {
     "configuration_to_parameter_file": configuration_to_parameter_file,
     "configurations": list(configurations.values()),
-    "tools": tools,
     "benchmark": benchmark,
     "benchmark_uri": benchmark_uri
 }