diff --git a/.github/workflows/run-benchmark.yml b/.github/workflows/run-benchmark.yml
index b401593..49661f1 100644
--- a/.github/workflows/run-benchmark.yml
+++ b/.github/workflows/run-benchmark.yml
@@ -14,13 +14,12 @@ on:
env:
CACHE_NUMBER: 1 # increase to reset cache manually
+ SNAKEMAKE_RESULT_FILE: metadata4ing_provenance
+ PROVENANACE_FILE_NAME: element_size_vs_max_mises_stress.pdf
jobs:
- tests:
+ run-simulation:
runs-on: ubuntu-latest
-
-
-
steps:
- name: checkout repo content
uses: actions/checkout@v2
@@ -52,8 +51,9 @@ jobs:
snakemake --use-conda --force --cores all \
--reporter metadata4ing \
--report-metadata4ing-paramscript parameter_extractor.py \
- --report-metadata4ing-filename metadata4ing_provenance
-
+ --report-metadata4ing-config metadata4ing.config \
+ --report-metadata4ing-filename $SNAKEMAKE_RESULT_FILE
+
- name: run_linear-elastic-plate-with-hole-benchmarks_nextflow
shell: bash -l {0}
run: |
@@ -65,7 +65,7 @@ jobs:
with:
name: snakemake_results_linear-elastic-plate-with-hole
path: |
- benchmarks/linear-elastic-plate-with-hole/metadata4ing_provenance.zip
+ benchmarks/linear-elastic-plate-with-hole/${{ env.SNAKEMAKE_RESULT_FILE }}.zip
- name: Archive Linear Elastic plate with a hole benchmark data for nextflow
uses: actions/upload-artifact@v4
@@ -76,7 +76,7 @@ jobs:
process-artifacts:
runs-on: ubuntu-latest
- needs: tests
+ needs: run-simulation
steps:
- name: Checkout repo content
uses: actions/checkout@v2
@@ -87,10 +87,10 @@ jobs:
name: snakemake_results_linear-elastic-plate-with-hole
path: ./artifact_files
- - name: Unzip metadata4ing_provenance.zip
+ - name: Unzip Snakemake Result File
run: |
- mkdir -p ./metadata4ing_provenance
- unzip -o ./artifact_files/metadata4ing_provenance.zip -d ./metadata4ing_provenance
+ mkdir -p ./$SNAKEMAKE_RESULT_FILE
+ unzip -o ./artifact_files/$SNAKEMAKE_RESULT_FILE.zip -d ./$SNAKEMAKE_RESULT_FILE
- name: Setup Mambaforge with postprocessing env
uses: conda-incubator/setup-miniconda@v3
@@ -99,14 +99,37 @@ jobs:
activate-environment: postprocessing
use-mamba: true
environment-file: benchmarks/linear-elastic-plate-with-hole/environment_postprocessing.yml
+
+ - name: Validate Snakemake Result File
+ shell: bash -l {0}
+ run: |
+ python benchmarks/common/validate_provenance.py \
+ --provenance_folderpath "./$SNAKEMAKE_RESULT_FILE"
- name: Run plotting script
shell: bash -l {0}
run: |
- python benchmarks/linear-elastic-plate-with-hole/plot_provenance.py ./metadata4ing_provenance
+ python benchmarks/linear-elastic-plate-with-hole/plot_provenance.py \
+ --provenance_folderpath "./$SNAKEMAKE_RESULT_FILE" \
+ --output_file $PROVENANACE_FILE_NAME
- - name: Upload PDF plot as artifact
+ - name: Upload snakemake results file as artifact
uses: actions/upload-artifact@v4
with:
name: element-size-vs-stress-plot
- path: element_size_vs_stress.pdf
\ No newline at end of file
+ path: ${{ env.PROVENANACE_FILE_NAME }}
+
+ - name: Re-zip snakemake result folder
+ run: |
+ cd "./${SNAKEMAKE_RESULT_FILE}"
+ zip -r "../${SNAKEMAKE_RESULT_FILE}.zip" .
+
+
+ - name: Upload RoCrate Zip file onto RoHub
+ shell: bash -l {0}
+ run: |
+ python benchmarks/common/upload_provenance.py \
+ --provenance_folderpath "./${SNAKEMAKE_RESULT_FILE}.zip" \
+ --benchmark_name "linear-elastic-plate-with-hole" \
+ --username "${{ secrets.ROHUB_USERNAME }}" \
+ --password "${{ secrets.ROHUB_PASSWORD }}"
\ No newline at end of file
diff --git a/benchmarks/common/provenance.py b/benchmarks/common/provenance.py
new file mode 100644
index 0000000..05a8a76
--- /dev/null
+++ b/benchmarks/common/provenance.py
@@ -0,0 +1,276 @@
+import os
+from rdflib import Graph
+import matplotlib.pyplot as plt
+from collections import defaultdict
+from typing import List, Tuple
+import re
+from rocrate_validator import services, models
+
+
+class ProvenanceAnalyzer:
+ """
+ A class to analyze, validate, and visualize provenance data from RO-Crate metadata files.
+
+ This class loads RO-Crate JSON-LD files, builds dynamic SPARQL queries to extract
+ workflow metadata about methods, parameters, and metrics, and provides visualization
+ capabilities. It also validates RO-Crate files against the RO-Crate 1.1 profile.
+
+ Attributes:
+ provenance_folderpath (str): The directory path containing the RO-Crate folder.
+ provenance_filename (str): The name of the provenance file (default: 'ro-crate-metadata.json').
+ """
+
+ def __init__(
+ self,
+ provenance_folderpath: str = None,
+ provenance_filename: str = "ro-crate-metadata.json",
+ ):
+ """
+ Initialize the ProvenanceAnalyzer.
+
+ Args:
+ provenance_folderpath (str, optional): Path to the folder containing the RO-Crate.
+ Defaults to None.
+ provenance_filename (str, optional): Name of the RO-Crate metadata file.
+ Defaults to "ro-crate-metadata.json".
+ """
+ self.provenance_folderpath = provenance_folderpath
+ self.provenance_filename = provenance_filename
+
+ def load_graph_from_file(self) -> Graph:
+ """
+ Loads the RO-Crate metadata file into an rdflib Graph object.
+
+ Returns:
+ rdflib.Graph: The loaded RDF graph containing the provenance data.
+
+ Raises:
+ Exception: If the file cannot be parsed as JSON-LD.
+ """
+ try:
+ g = Graph()
+ # The parse method handles file loading and format parsing
+ g.parse(
+ os.path.join(self.provenance_folderpath, self.provenance_filename),
+ format="json-ld",
+ )
+ return g
+ except Exception as e:
+ print(f"Failed to parse {self.provenance_filename}: {e}")
+ raise # Re-raise to ensure error is handled
+
+ def sanitize_variable_name(self, name: str) -> str:
+ """
+ Convert a string into a valid SPARQL variable name.
+
+ Replaces invalid characters with underscores and ensures the variable
+ name doesn't start with a digit.
+
+ Args:
+ name (str): The original string to convert.
+
+ Returns:
+ str: A sanitized variable name safe for use in SPARQL queries.
+ """
+ # Replace invalid chars with underscore
+ var = re.sub(r"[^a-zA-Z0-9_]", "_", name)
+ # Ensure it doesn't start with a digit
+ if re.match(r"^\d", var):
+ var = "_" + var
+ return var
+
+ def build_dynamic_query(self, parameters, metrics, tools=None, named_graph=None):
+ """
+ Generate a dynamic SPARQL query to extract m4i:Method instances with specified
+ parameters and metrics.
+
+ The query extracts methods along with their associated parameters (via m4i:hasParameter),
+ metrics (via m4i:investigates), and the tools that implement them (via ssn:implementedBy).
+
+ Args:
+ parameters (list): List of parameter names to query (matched via rdfs:label).
+ metrics (list): List of metric names to query (matched via rdfs:label).
+ tools (list, optional): List of tool name substrings to filter results.
+ Case-insensitive matching. Defaults to None.
+ named_graph (str, optional): URI of a named graph to query within.
+ If None, queries the default graph. Defaults to None.
+
+ Returns:
+ str: A complete SPARQL query string ready to execute.
+ """
+
+ all_names = parameters + metrics
+ # Map original names to safe SPARQL variable names
+ var_map = {name: self.sanitize_variable_name(name) for name in all_names}
+
+ # Build SELECT variables
+ select_vars = " ".join(f"?{var_map[name]}" for name in all_names)
+
+ # Build method→parameter and method→metric links
+ method_links = (
+ "\n ".join(
+ f"?method m4i:hasParameter ?param_{var_map[p]} ." for p in parameters
+ )
+ + "\n"
+ + "\n ".join(
+ f"?method m4i:investigates ?param_{var_map[m]} ." for m in metrics
+ )
+ )
+
+ # Build parameter and metric blocks
+ value_blocks = "\n".join(
+ f'?param_{var_map[name]} a schema:PropertyValue ;\n rdfs:label "{name}" ;\n schema:value ?{var_map[name]} .\n'
+ for name in all_names
+ )
+
+ # Tool block with optional filter
+ tool_block = "?method m4i:implementedByTool ?tool .\n?tool a schema:SoftwareApplication ;\n rdfs:label ?tool_name .\n"
+ if tools:
+ filter_cond = " || ".join(
+ f'CONTAINS(LCASE(?tool_name), "{t.lower()}")' for t in tools
+ )
+ tool_block += f"\nFILTER({filter_cond}) .\n"
+
+ # Build the inner query
+ inner_query = f"""
+ ?method a m4i:Method .
+ {method_links}
+ {value_blocks}
+ {tool_block}
+ """.strip()
+
+ # Wrap in GRAPH if named_graph is provided
+ where_block = (
+ f"GRAPH <{named_graph}> {{\n{inner_query}\n}}"
+ if named_graph
+ else inner_query
+ )
+
+ # Final query
+ query = f"""
+ PREFIX schema:
+ PREFIX rdfs:
+ PREFIX m4i:
+ PREFIX ssn:
+
+ SELECT {select_vars} ?tool_name
+ WHERE {{
+ {where_block}
+ }}
+ """.strip()
+
+ return query
+
+ def run_query_on_graph(
+ self, graph: Graph, query: str
+ ) -> Tuple[List[str], List[List]]:
+ """
+ Executes a SPARQL query on the provided RDF graph.
+
+ Args:
+ graph (rdflib.Graph): The RDF graph to query.
+ query (str): The SPARQL query string to execute.
+
+ Returns:
+ rdflib.plugins.sparql.processor.SPARQLResult: The query results object
+ from rdflib.
+ """
+ return graph.query(query)
+
+ def plot_provenance_graph(
+ self,
+ data: List[List],
+ x_axis_label: str,
+ y_axis_label: str,
+ x_axis_index: str,
+ y_axis_index: str,
+ group_by_index: str,
+ title: str,
+ output_file: str = None,
+ figsize: Tuple[int, int] = (12, 5),
+ ):
+ """
+ Generates a scatter/line plot from the extracted provenance data.
+
+ The plot displays data points grouped by a specified column, with each group
+ shown as a separate line series. The x-axis uses a logarithmic scale.
+
+ Args:
+ data (List[List]): The table data to plot, where each row is a list of values.
+ x_axis_label (str): Label for the x-axis.
+ y_axis_label (str): Label for the y-axis.
+ x_axis_index (int or str): Index or key for the x-axis values in each row.
+ y_axis_index (int or str): Index or key for the y-axis values in each row.
+ group_by_index (int or str): Index or key for the grouping variable (used for legend).
+ title (str): Title of the plot.
+ output_file (str, optional): Path where the plot will be saved as an image.
+ If None, displays the plot. Defaults to None.
+ figsize (Tuple[int, int], optional): Figure dimensions (width, height).
+ Defaults to (12, 5).
+ """
+
+ grouped_data = defaultdict(list)
+ x_tick_set = set()
+
+ for row in data:
+ x = float(row[x_axis_index])
+ y = float(row[y_axis_index])
+ grouped_data[row[group_by_index]].append((x, y))
+ x_tick_set.add(x)
+
+ # Sort x-tick labels
+ x_ticks = sorted(x_tick_set)
+
+ plt.figure(figsize=figsize)
+ for grouped_title, values in grouped_data.items():
+ # Sort values by x-axis (element size) to ensure correct line plotting
+ values.sort()
+ x_vals, y_vals = zip(*values)
+ plt.plot(x_vals, y_vals, marker="o", linestyle="-", label=grouped_title)
+
+ plt.xlabel(x_axis_label)
+ plt.ylabel(y_axis_label)
+ plt.title(title)
+ plt.grid(True)
+ plt.legend()
+ plt.xscale("log")
+
+ # Set x-ticks to show original values
+ plt.xticks(ticks=x_ticks, labels=[str(x) for x in x_ticks], rotation=45)
+ plt.tight_layout()
+
+ if output_file:
+ plt.savefig(output_file)
+ print(f"Plot saved to: {output_file}")
+ else:
+ plt.show()
+
+ def validate_provenance(self):
+ """
+ Validates the RO-Crate against the RO-Crate 1.1 profile.
+
+ Uses the rocrate-validator library to check if the RO-Crate metadata
+ conforms to the RO-Crate 1.1 specification with required severity level.
+
+ Raises:
+ AssertionError: If the RO-Crate has validation issues, with details
+ about each issue's severity and message.
+
+ Prints:
+ Success message if the RO-Crate is valid.
+ """
+ settings = services.ValidationSettings(
+ rocrate_uri=self.provenance_folderpath,
+ profile_identifier="ro-crate-1.1",
+ requirement_severity=models.Severity.REQUIRED,
+ )
+
+ result = services.validate(settings)
+
+ assert not result.has_issues(), "RO-Crate is invalid!\n" + "\n".join(
+ f"Detected issue of severity {issue.severity.name} with check "
+ f'"{issue.check.identifier}": {issue.message}'
+ for issue in result.get_issues()
+ )
+
+ print("RO-Crate is valid!")
diff --git a/benchmarks/common/upload_provenance.py b/benchmarks/common/upload_provenance.py
new file mode 100644
index 0000000..4ef6d82
--- /dev/null
+++ b/benchmarks/common/upload_provenance.py
@@ -0,0 +1,203 @@
+"""
+RoHub Provenance Upload Module
+
+This module handles the upload of research object provenance data to RoHub,
+a platform for research object management and sharing. It processes RO-Crate
+metadata artifacts and manages the complete upload workflow including:
+- Authentication with RoHub
+- Deletion of existing research objects
+- Upload of new research objects from zip files
+- Polling for upload completion
+- Adding semantic annotations to uploaded objects
+
+The module supports both production and development environments of RoHub.
+"""
+
+import argparse
+import rohub
+import time
+
+
+def parse_args():
+ """
+ Parse command-line arguments for RoHub provenance upload.
+
+ Returns:
+ argparse.Namespace: Parsed command-line arguments containing:
+ - provenance_folderpath (str): Path to the zip file containing
+ provenance data (RO-Crate)
+ - username (str): RoHub authentication username
+ - password (str): RoHub authentication password
+ """
+ parser = argparse.ArgumentParser(
+ description="Process ro-crate-metadata.json artifacts and display simulation results."
+ )
+ parser.add_argument(
+ "--provenance_folderpath",
+ type=str,
+ required=True,
+ help="Path to the folder containing provenance data",
+ )
+ parser.add_argument(
+ "--benchmark_name",
+ type=str,
+ required=True,
+ help="Name of the benchmark to be uploaded",
+ )
+ parser.add_argument(
+ "--username",
+ type=str,
+ required=True,
+ help="Username for RoHub",
+ )
+ parser.add_argument(
+ "--password",
+ type=str,
+ required=True,
+ help="Password for RoHub",
+ )
+ return parser.parse_args()
+
+
+def run(args):
+ """
+ Execute the complete RoHub upload workflow.
+
+ This function performs the following operations:
+ 1. Configures RoHub settings (API endpoints, authentication)
+ 2. Authenticates with RoHub using provided credentials
+ 3. Deletes all existing research objects owned by the user
+ 4. Uploads the new research object from the specified zip file
+ 5. Polls the upload job status until completion or timeout
+ 6. Adds semantic annotations to the successfully uploaded object
+
+ Args:
+ args (argparse.Namespace): Parsed command-line arguments containing:
+ - provenance_folderpath: Path to the provenance zip file
+ - username: RoHub username
+ - password: RoHub password
+
+ Raises:
+ Exception: If authentication fails
+ Exception: If upload fails
+ Exception: If deletion of existing ROs fails
+
+ Configuration:
+ USE_DEVELOPMENT_VERSION (bool): When True, uses RoHub development server.
+ Set to False for production environment.
+
+ Timeout Settings:
+ - Upload timeout: 5 minutes (300 seconds)
+ - Poll interval: 10 seconds between status checks
+ - Sleep time: 10 seconds between API calls
+
+ Annotations:
+ The function adds a predefined annotation linking the research object
+ to the NFDI4Ing Model Validation Platform benchmark.
+ """
+ # Configure API sleep time to avoid rate limiting
+ rohub.settings.SLEEP_TIME = 10
+
+ # Toggle between development and production environments
+ USE_DEVELOPMENT_VERSION = True
+
+ if USE_DEVELOPMENT_VERSION:
+ # Development server configuration
+ rohub.settings.API_URL = "https://rohub2020-rohub.apps.paas-dev.psnc.pl/api/"
+ rohub.settings.KEYCLOAK_CLIENT_ID = "rohub2020-cli"
+ rohub.settings.KEYCLOAK_CLIENT_SECRET = "714617a7-87bc-4a88-8682-5f9c2f60337d"
+ rohub.settings.KEYCLOAK_URL = "https://keycloak-dev.apps.paas-dev.psnc.pl/auth/realms/rohub/protocol/openid-connect/token"
+ rohub.settings.SPARQL_ENDPOINT = (
+ "https://rohub2020-api-virtuoso-route-rohub.apps.paas-dev.psnc.pl/sparql/"
+ )
+
+ # Authenticate with RoHub
+ rohub.login(args.username, args.password)
+
+ # Retrieve list of user's existing research objects
+ my_ros = rohub.list_my_ros()
+
+ # Delete all existing research objects to ensure clean upload
+ try:
+ for _, row in my_ros.iterrows():
+ rohub.ros_delete(row["identifier"])
+ except Exception as error:
+ print(f"Error on Deleting RoHub: {error}")
+
+ # Initialize tracking variables for upload
+ identifier = "" # Job identifier for status polling
+ uuid = "" # UUID of the uploaded research object
+
+ # Upload the research object zip file
+ try:
+ upload_result = rohub.ros_upload(path_to_zip=args.provenance_folderpath)
+ identifier = upload_result["identifier"]
+ uuid = upload_result["results"].rstrip("/").split("/")[-1]
+ except Exception as error:
+ print(f"Error on Upload RoHub: {error}")
+
+ # Configure polling parameters
+ timeout_seconds = 5 * 60 # 5 minutes maximum wait time
+ poll_interval = 10 # Check status every 10 seconds
+ start_time = time.time()
+
+ # Poll upload job status until completion or timeout
+ while True:
+ success_result = rohub.is_job_success(job_id=identifier)
+ status = success_result.get("status", "UNKNOWN")
+
+ if status == "SUCCESS":
+ print(f"Upload successful: {success_result}")
+ break
+ elif time.time() - start_time > timeout_seconds:
+ print(f"Upload did not succeed within 5 minutes. Last status: {status}")
+ break
+ else:
+ print(f"Current status: {status}, waiting {poll_interval}s...")
+ time.sleep(poll_interval)
+
+ # Define semantic annotation linking to the validation platform benchmark
+ ANNOTATION_PREDICATE = "http://w3id.org/nfdi4ing/metadata4ing#investigates"
+ ANNOTATION_OBJECT = f"https://github.com/BAMresearch/NFDI4IngModelValidationPlatform/tree/main/benchmarks/{args.benchmark_name}"
+
+ # Add semantic annotations if upload was successful
+ if uuid != "":
+ _RO = rohub.ros_load(uuid)
+ annotation_json = [
+ {"property": ANNOTATION_PREDICATE, "value": ANNOTATION_OBJECT}
+ ]
+ add_annotations_result = _RO.add_annotations(
+ body_specification_json=annotation_json
+ )
+ print(add_annotations_result)
+
+
+def main():
+ """
+ Main entry point for the RoHub provenance upload script.
+
+ Parses command-line arguments and initiates the upload workflow to RoHub.
+ This function is called when the script is executed directly.
+
+ Usage:
+ python upload_provenance.py \
+ --provenance_folderpath /path/to/ro-crate.zip \
+ --username user@example.com \
+ --password your_password
+
+ Note:
+ - Ensure the provenance file is a valid zip containing RO-Crate metadata
+ - Valid RoHub credentials are required for authentication
+ - The script will delete all existing research objects before uploading
+ - Upload process may take up to 5 minutes
+
+ Exits:
+ The script will exit with a non-zero status code if authentication
+ or upload fails, or if required arguments are not provided.
+ """
+ args = parse_args()
+ run(args)
+
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/benchmarks/common/validate_provenance.py b/benchmarks/common/validate_provenance.py
new file mode 100644
index 0000000..57c2b27
--- /dev/null
+++ b/benchmarks/common/validate_provenance.py
@@ -0,0 +1,86 @@
+"""
+Provenance Validation Module
+
+This module provides functionality to validate research object provenance data
+against defined profiles. It processes RO-Crate metadata to ensure compliance
+with provenance standards.
+
+"""
+
+import argparse
+from provenance import ProvenanceAnalyzer
+
+
+def parse_args():
+ """
+ Parse command-line arguments for provenance validation.
+
+ Returns:
+ argparse.Namespace: Parsed command-line arguments containing:
+ - provenance_folderpath (str): Path to the folder containing provenance data
+ - provenance_filename (str): Name of the provenance metadata file
+ (default: 'ro-crate-metadata.json')
+ """
+ parser = argparse.ArgumentParser(
+ description="Process research object zip to validate against profile."
+ )
+ parser.add_argument(
+ "--provenance_folderpath",
+ type=str,
+ required=True,
+ help="Path to the folder containing provenance data",
+ )
+ parser.add_argument(
+ "--provenance_filename",
+ type=str,
+ default="ro-crate-metadata.json",
+ help="File name for the provenance graph",
+ )
+ return parser.parse_args()
+
+
+def run(args):
+ """
+ Execute the provenance validation process.
+
+ Creates a ProvenanceAnalyzer instance with the provided arguments and
+ runs the validation against the configured profile.
+
+ Args:
+ args (argparse.Namespace): Parsed command-line arguments containing
+ provenance folder path and filename
+
+ Raises:
+ FileNotFoundError: If the specified provenance file doesn't exist
+ ValidationError: If the provenance data fails validation checks
+ """
+ analyzer = ProvenanceAnalyzer(
+ provenance_folderpath=args.provenance_folderpath,
+ provenance_filename=args.provenance_filename,
+ )
+
+ analyzer.validate_provenance()
+
+
+def main():
+ """
+ Main entry point for the provenance validation script.
+
+ Parses command-line arguments and initiates the validation process.
+ This function is called when the script is executed directly.
+
+ Usage:
+ python validate_provenance.py --provenance_folderpath /path/to/folder
+ python validate_provenance.py --provenance_folderpath /path/to/folder \
+ --provenance_filename custom-metadata.json
+
+ Exits:
+ The script will exit with a non-zero status code if validation fails
+ or if required arguments are not provided.
+ """
+ args = parse_args()
+ run(args)
+
+
+if __name__ == "__main__":
+ main()
\ No newline at end of file
diff --git a/benchmarks/linear-elastic-plate-with-hole/environment_postprocessing.yml b/benchmarks/linear-elastic-plate-with-hole/environment_postprocessing.yml
index 43a2a8f..0ee4a2d 100644
--- a/benchmarks/linear-elastic-plate-with-hole/environment_postprocessing.yml
+++ b/benchmarks/linear-elastic-plate-with-hole/environment_postprocessing.yml
@@ -11,3 +11,9 @@ dependencies:
- pyvista
- rdflib
- matplotlib
+ - pandas
+ - numpy
+ - pip
+ - pip:
+ - roc-validator
+ - rohub
\ No newline at end of file
diff --git a/benchmarks/linear-elastic-plate-with-hole/fenics/environment_simulation.yml b/benchmarks/linear-elastic-plate-with-hole/fenics/environment_simulation.yml
index b5280ab..940b20e 100644
--- a/benchmarks/linear-elastic-plate-with-hole/fenics/environment_simulation.yml
+++ b/benchmarks/linear-elastic-plate-with-hole/fenics/environment_simulation.yml
@@ -7,7 +7,7 @@ channel_priority: strict
dependencies:
- python=3.12
- fenics-dolfinx=0.9.*
- - libadios2=2.10.1
+ - mpich
- petsc4py
- pint
- python-gmsh
diff --git a/benchmarks/linear-elastic-plate-with-hole/metadata4ing.config b/benchmarks/linear-elastic-plate-with-hole/metadata4ing.config
new file mode 100644
index 0000000..1881df1
--- /dev/null
+++ b/benchmarks/linear-elastic-plate-with-hole/metadata4ing.config
@@ -0,0 +1,10 @@
+{
+ "researchProblem": {
+ "description": "This benchmark describes a linear-elastic plate with a hole test case used in the NFDI-4Ing Model Validation Platform for comparing and validating computational modelling methods."
+ },
+ "rocrate": {
+ "name": "NFDI4Ing Provenance",
+ "description": "Benchmark for linear-elastic plate with a hole",
+ "license": "https://opensource.org/licenses/MIT"
+ }
+}
\ No newline at end of file
diff --git a/benchmarks/linear-elastic-plate-with-hole/plot_provenance.py b/benchmarks/linear-elastic-plate-with-hole/plot_provenance.py
index 8089eb1..40e3afa 100644
--- a/benchmarks/linear-elastic-plate-with-hole/plot_provenance.py
+++ b/benchmarks/linear-elastic-plate-with-hole/plot_provenance.py
@@ -1,153 +1,423 @@
-import os
import argparse
-from rdflib import Graph
-import matplotlib.pyplot as plt
-from collections import defaultdict
+import sys
+from pathlib import Path
from generate_config import workflow_config
+import json
+import os
+import pandas as pd
+import numpy as np
-def load_graphs(base_dir):
+
+def parse_args():
"""
- Walk through the base_dir and load all JSON-LD files into rdflib Graphs.
+ Parse command-line arguments for the provenance processing script.
+
+ Returns:
+ argparse.Namespace: Parsed arguments containing:
+ - provenance_folderpath: Path to the folder with RO-Crate data
+ - provenance_filename: Name of the RO-Crate metadata file
+ - output_file: Path for the final visualization output
"""
- graph_list = []
- for root, _, files in os.walk(base_dir):
- for file in files:
- if file.endswith(".jsonld"):
- file_path = os.path.join(root, file)
- try:
- g = Graph()
- g.parse(file_path, format='json-ld')
- graph_list.append(g)
- print(f"✅ Parsed: {file_path}")
- except Exception as e:
- print(f"❌ Failed to parse {file_path}: {e}")
- print(f"\nTotal graphs loaded: {len(graph_list)}")
- return graph_list
+ parser = argparse.ArgumentParser(
+ description="Process ro-crate-metadata.json artifacts and display simulation results."
+ )
+ parser.add_argument(
+ "--provenance_folderpath",
+ type=str,
+ required=True,
+ help="Path to the folder containing provenance data",
+ )
+ parser.add_argument(
+ "--provenance_filename",
+ type=str,
+ default="ro-crate-metadata.json",
+ help="File name for the provenance graph",
+ )
+ parser.add_argument(
+ "--output_file",
+ type=str,
+ required=True,
+ help="Final visualization file",
+ )
+ return parser.parse_args()
-def query_and_build_table(graph_list):
+def sparql_result_to_dataframe(results):
"""
- Run SPARQL query on graphs and build a table.
- Returns headers and table_data.
+ Convert SPARQL query results into a pandas DataFrame.
+
+ Extracts variable bindings from each result row using asdict() and converts
+ RDF values to Python native types using toPython().
+
+ Args:
+ results (rdflib.plugins.sparql.processor.SPARQLResult): SPARQL query results
+ from rdflib.
+
+ Returns:
+ pd.DataFrame: DataFrame where each row represents a query result and columns
+ correspond to SPARQL variables.
"""
- tools = workflow_config["tools"]
- filter_conditions = " || ".join(
- f'CONTAINS(LCASE(?tool_name), "{tool.lower()}")' for tool in tools
+ rows = []
+
+ for row in results:
+ row_dict = {k: v.toPython() for k, v in row.asdict().items()}
+ rows.append(row_dict)
+
+ return pd.DataFrame(rows)
+
+
+def apply_custom_filters(data: pd.DataFrame) -> pd.DataFrame:
+ """
+ Filter provenance data to include only first-order linear elements.
+
+ Filters rows where element_degree = 1 and element_order = 1, then removes
+ these filtering columns from the result.
+
+ Args:
+ data (pd.DataFrame): Input DataFrame containing element_degree and
+ element_order columns.
+
+ Returns:
+ pd.DataFrame: Filtered DataFrame with element_degree and element_order
+ columns removed and index reset.
+ """
+ filtered_df = data[(data["element_degree"] == 1) & (data["element_order"] == 1)]
+
+ return filtered_df.drop(columns=["element_degree", "element_order"]).reset_index(
+ drop=True
)
- query = f"""
- PREFIX cr:
- PREFIX sio:
-
- SELECT DISTINCT ?value_element_size ?value_max_von_mises_stress_gauss_points ?tool_name
- WHERE {{
- ?processing_step a schema:Action ;
- m4i:hasParameter ?element_size ;
- m4i:hasParameter ?element_order ;
- m4i:hasParameter ?element_degree ;
- m4i:investigates ?max_von_mises_stress_gauss_points ;
- schema:instrument ?tool .
-
- ?max_von_mises_stress_gauss_points a schema:PropertyValue ;
- rdfs:label "max_von_mises_stress_nodes" ;
- schema:value ?value_max_von_mises_stress_gauss_points .
-
- ?element_order a schema:PropertyValue ;
- rdfs:label "element_order" ;
- schema:value 1 .
-
- ?element_degree a schema:PropertyValue ;
- rdfs:label "element_degree" ;
- schema:value 1 .
-
- ?element_size a schema:PropertyValue ;
- rdfs:label "element_size" ;
- schema:value ?value_element_size .
-
- ?tool a schema:SoftwareApplication ;
- rdfs:label ?tool_name .
-
- FILTER ({filter_conditions})
- }}
- """
-
- headers = [
- "element-size",
- "max-mises-stress",
- "Tool Name"
- ]
-
- table_data = []
-
- for g in graph_list:
- results = g.query(query)
- for row in results:
- value_element_size = row.value_element_size
- value_max_von_mises_stress_gauss_points = row.value_max_von_mises_stress_gauss_points
- tool_name = row.tool_name
- table_data.append(
- [
- value_element_size,
- value_max_von_mises_stress_gauss_points,
- tool_name,
- ]
- )
-
- # Sort by element-size
- sort_key = headers.index("element-size")
- table_data.sort(key=lambda x: x[sort_key])
-
- return headers, table_data
-
-
-def plot_element_size_vs_stress(headers, table_data, output_file="element_size_vs_stress.pdf"):
- """Plots element-size vs max-mises-stress grouped by tool and saves as PDF."""
-
- idx_element_size = headers.index("element-size")
- idx_stress = headers.index("max-mises-stress")
- idx_tool = headers.index("Tool Name")
-
- grouped_data = defaultdict(list)
- x_tick_set = set()
-
- for row in table_data:
- tool = row[idx_tool]
- x = float(row[idx_element_size])
- y = float(row[idx_stress])
- grouped_data[tool].append((x, y))
- x_tick_set.add(x)
-
- # Sort x-tick labels
- x_ticks = sorted(x_tick_set)
-
- plt.figure(figsize=(12, 5))
- for tool, values in grouped_data.items():
- values.sort()
- x_vals, y_vals = zip(*values)
- plt.plot(x_vals, y_vals, marker='o', linestyle='-', label=tool)
-
- plt.xlabel("element-size")
- plt.ylabel("max-mises-stress")
- plt.title("element-size vs max-mises-stress by Tool\n(element-order = 1 , element-degree = 1)")
- plt.legend(title="Tool Name")
- plt.grid(True)
-
- # Use logarithmic scale for x-axis
- plt.xscale('log')
-
- # Set x-ticks to show original values
- plt.xticks(ticks=x_ticks, labels=[str(x) for x in x_ticks], rotation=45)
- plt.tight_layout()
-
- # Save to PDF instead of showing
- plt.savefig(output_file)
- print(f"Plot saved as {output_file}")
-if __name__ == "__main__":
- parser = argparse.ArgumentParser(description="Process JSON-LD artifacts and display simulation results.")
- parser.add_argument("artifact_folder", type=str, help="Path to the folder containing unzipped artifacts")
- args = parser.parse_args()
+def summary_file_to_dataframe(analyzer, summary_path, parameters, metrics):
+ """
+ Load benchmark data from a summary.json file into a DataFrame.
+
+ Handles both dictionary-style parameter/metric values (with 'value' key) and
+ direct scalar values. Converts parameter names from underscore to hyphen format
+ for JSON lookup.
+
+ Args:
+ summary_path (str): Path to the summary.json file.
+ parameters (list): List of parameter names to extract.
+ metrics (list): List of metric names to extract.
+
+ Returns:
+ pd.DataFrame: DataFrame with columns for each parameter and metric.
+ """
+ with open(summary_path, "r") as f:
+ data = json.load(f)
+
+ records = []
+ for entry in data:
+ record = {}
+
+ for p in parameters:
+ param_value = entry["parameters"][p]
+ sanitized_param_name = analyzer.sanitize_variable_name(p)
+ if isinstance(param_value, dict):
+ record[sanitized_param_name] = param_value.get("value")
+ else:
+ record[sanitized_param_name] = param_value
+
+ for m in metrics:
+ metric_value = entry["metrics"][m]
+ sanitized_metric_name = analyzer.sanitize_variable_name(m)
+ if isinstance(metric_value, dict):
+ record[sanitized_metric_name] = metric_value.get("value")
+ else:
+ record[sanitized_metric_name] = metric_value
+
+ records.append(record)
+
+ return pd.DataFrame(records)
+
+
+def compare_dataframes(df1: pd.DataFrame, df2: pd.DataFrame):
+ """
+ Compare two DataFrames for identical content regardless of row order.
+
+ Sorts both DataFrames by all columns, then checks for equality. If differences
+ are found, prints rows that appear in one DataFrame but not the other.
+
+ Args:
+ df1 (pd.DataFrame): First DataFrame to compare.
+ df2 (pd.DataFrame): Second DataFrame to compare.
+
+ Returns:
+ bool: True if DataFrames contain identical data, False otherwise.
+
+ Raises:
+ ValueError: If the DataFrames have different columns.
+
+ Prints:
+ Rows that are present in one DataFrame but missing in the other,
+ when differences are detected.
+ """
+ cols1 = sorted(df1.columns)
+ cols2 = sorted(df2.columns)
+
+ if cols1 != cols2:
+ raise ValueError("DataFrames have different columns.")
+
+ df1_sorted = df1[cols1].sort_values(by=cols1).reset_index(drop=True)
+ df2_sorted = df2[cols2].sort_values(by=cols2).reset_index(drop=True)
+
+ are_equal = df1_sorted.equals(df2_sorted)
+
+ if are_equal:
+ return True
+
+ missing_in_df2 = pd.concat([df1_sorted, df2_sorted, df2_sorted]).drop_duplicates(
+ keep=False
+ )
+
+ missing_in_df1 = pd.concat([df2_sorted, df1_sorted, df1_sorted]).drop_duplicates(
+ keep=False
+ )
+
+ print("Rows in df1 but not in df2:")
+ print(missing_in_df2 if not missing_in_df2.empty else "None")
+
+ print("\nRows in df2 but not in df1:")
+ print(missing_in_df1 if not missing_in_df1.empty else "None")
+
+ return False
+
+
+def load_and_query_graph(analyzer, parameters, metrics, tools):
+ """
+ Load the RO-Crate graph and execute a SPARQL query to extract provenance data.
+
+ Args:
+ analyzer (ProvenanceAnalyzer): Initialized analyzer instance.
+ parameters (list): List of parameter names to query.
+ metrics (list): List of metric names to query.
+ tools (list): List of tool names to filter by.
+
+ Returns:
+ pd.DataFrame: DataFrame containing the query results.
+
+ Raises:
+ AssertionError: If the query returns no data.
+ """
+ graph = analyzer.load_graph_from_file()
+ query = analyzer.build_dynamic_query(parameters, metrics, tools)
+ results = analyzer.run_query_on_graph(graph, query)
+
+ provenance_df = sparql_result_to_dataframe(results)
+ assert len(provenance_df), "No data found for the provenance query."
+
+ return provenance_df
+
- graphs = load_graphs(args.artifact_folder)
- headers, table_data = query_and_build_table(graphs)
- plot_element_size_vs_stress(headers, table_data, output_file="element_size_vs_stress.pdf")
\ No newline at end of file
+def validate_provenance_data_summary_file(
+ analyzer, provenance_df, parameters, metrics, tools, provenance_folderpath
+):
+ """
+ Validate provenance query results against ground truth data from summary.json files.
+
+ For each tool, loads the corresponding summary.json file and compares its data
+ against the filtered provenance query results for that tool.
+
+ Args:
+ provenance_df (pd.DataFrame): DataFrame containing all provenance query results.
+ parameters (list): List of parameter names used in the comparison.
+ metrics (list): List of metric names used in the comparison.
+ tools (list): List of tool names to validate.
+ provenance_folderpath (str): Base path to the provenance folder containing
+ summary.json files.
+
+ Raises:
+ AssertionError: If data mismatch is found between summary.json and provenance
+ data for any tool.
+ """
+ for tool in tools:
+ summary_path = os.path.join(
+ provenance_folderpath,
+ "snakemake_results",
+ "linear-elastic-plate-with-hole",
+ tool,
+ "summary.json",
+ )
+ summary_df = summary_file_to_dataframe(
+ analyzer, summary_path, parameters, metrics
+ )
+
+ filtered_df = provenance_df[
+ provenance_df["tool_name"].str.contains(tool, case=False, na=False)
+ ].drop(columns=["tool_name"])
+
+ assert compare_dataframes(
+ summary_df, filtered_df
+ ), f"Data mismatch for tool '{tool}'. See above for details."
+
+
+def validate_provenance_data_csv_file(analyzer, provenance_df, tools, float_precision=6, tol=1e+6):
+ """
+ Validate that the provided provenance DataFrame contains all rows from reference CSV files for the given tools.
+
+ The CSV file is treated as the ground truth. It may contain extra columns, but only
+ the columns that also exist in the input DataFrame are checked.
+
+ Float values are rounded to avoid minor numerical differences.
+
+ Args:
+ analyzer: ProvenanceAnalyzer: Initialized analyzer instance.
+ provenance_df (pd.DataFrame): The DataFrame containing provenance data to validate.
+ tools (list of str): List of tool names. For each tool, a CSV file `.csv`
+ must exist in the `tests` folder next to this script.
+ float_precision (int, optional): Decimal places for rounding float values.
+ Defaults to 6.
+
+ Raises:
+ AssertionError: If any CSV row (considering only overlapping columns) is missing in `provenance_df`.
+ """
+
+ stress_cols = {"max_von_mises_stress_nodes", "max_von_mises_stress_gauss_points"}
+
+ for tool in tools:
+ df_subset = provenance_df[
+ provenance_df["tool_name"].str.lower().str.startswith(tool.lower())
+ ].copy()
+
+ csv_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tests", f"{tool}.csv")
+ df_csv = pd.read_csv(csv_path)
+
+ df_csv.columns = [analyzer.sanitize_variable_name(c) for c in df_csv.columns]
+
+ common_cols = df_csv.columns.intersection(df_subset.columns)
+ df_subset = df_subset[common_cols].reset_index(drop=True)
+ df_csv = df_csv[common_cols].reset_index(drop=True)
+
+ # Round all floats to avoid minor precision issues
+ for col in df_csv.select_dtypes(include=["float", "float64", "float32"]).columns:
+ df_csv[col] = df_csv[col].round(float_precision)
+
+ for i, row_csv in df_csv.iterrows():
+ best_mismatch = None
+ best_mismatch_count = float("inf")
+ matched = False
+
+ for j, row_df in df_subset.iterrows():
+ mismatches = []
+
+ for col in common_cols:
+ v_csv = row_csv[col]
+ v_df = row_df[col]
+
+ if pd.api.types.is_numeric_dtype(df_subset[col]):
+ if col in stress_cols:
+ if not np.isclose(v_csv, v_df, atol=tol, rtol=0):
+ mismatches.append((col, v_csv, v_df))
+ else:
+ if v_csv != v_df:
+ mismatches.append((col, v_csv, v_df))
+ else:
+ # Non-numeric columns: exact match
+ if v_csv != v_df:
+ mismatches.append((col, v_csv, v_df))
+
+ if not mismatches:
+ matched = True
+ break
+
+ if len(mismatches) < best_mismatch_count:
+ best_mismatch = j, mismatches
+ best_mismatch_count = len(mismatches)
+
+ if not matched:
+ _, mismatches_best = best_mismatch
+ for col, v_csv, v_df in mismatches_best:
+ print(f"Column `{col}` → CSV: {v_csv} | DataFrame: {v_df}")
+
+ raise AssertionError(
+ f"\n[{tool}] CSV row {i} not matched in DataFrame within tolerance {tol} "
+ f"on columns {list(common_cols)}:\n{row_csv.to_dict()}"
+ )
+
+
+def plot_results(analyzer, final_df, output_file):
+ """
+ Generate a visualization plot of the provenance results.
+
+ Creates a scatter/line plot showing the relationship between element size
+ and maximum von Mises stress, grouped by tool name.
+
+ Args:
+ analyzer (ProvenanceAnalyzer): Initialized analyzer instance.
+ final_df (pd.DataFrame): DataFrame containing filtered data to plot.
+ Expected columns: element_size, max_von_mises_stress_nodes,
+ tool_name (in that order).
+ output_file (str): Path where the plot image will be saved.
+ """
+ analyzer.plot_provenance_graph(
+ data=final_df.values.tolist(),
+ x_axis_label="Element Size",
+ y_axis_label="Max Von Mises Stress",
+ x_axis_index=0,
+ y_axis_index=1,
+ group_by_index=2,
+ title="Element Size vs Max Von Mises Stress",
+ output_file=output_file,
+ )
+
+
+def run(args, parameters, metrics, tools):
+ """
+ Execute the complete provenance analysis workflow.
+
+ Performs the following steps:
+ 1. Initialize the ProvenanceAnalyzer
+ 2. Load and query the provenance graph
+ 3. Validate query results against summary.json ground truth data
+ 4. Apply custom filters to the data
+ 5. Generate visualization plot
+
+ Args:
+ args (argparse.Namespace): Parsed command-line arguments.
+ parameters (list): List of parameter names to extract.
+ metrics (list): List of metric names to extract.
+ tools (list): List of tool names to process.
+ """
+ root_dir = Path(__file__).parent.parent.parent
+
+ sys.path.insert(0, str(root_dir))
+ from benchmarks.common.provenance import ProvenanceAnalyzer
+
+ analyzer = ProvenanceAnalyzer(
+ provenance_folderpath=args.provenance_folderpath,
+ provenance_filename=args.provenance_filename,
+ )
+
+ provenance_df = load_and_query_graph(analyzer, parameters, metrics, tools)
+
+ validate_provenance_data_summary_file(
+ analyzer, provenance_df, parameters, metrics, tools, args.provenance_folderpath
+ )
+
+ validate_provenance_data_csv_file(analyzer, provenance_df, tools)
+
+ final_df = apply_custom_filters(provenance_df)
+
+ plot_results(analyzer, final_df, args.output_file)
+
+
+def main():
+ """
+ Main entry point for the provenance analysis script.
+
+ Parses command-line arguments, defines the parameters and metrics to extract,
+ retrieves tool names from the workflow configuration, and executes the analysis
+ workflow.
+ """
+ args = parse_args()
+
+ parameters = ["element-size", "element-order", "element-degree"]
+ metrics = ["max_von_mises_stress_nodes"]
+ tools = workflow_config["tools"]
+
+ run(args, parameters, metrics, tools)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/linear-elastic-plate-with-hole/tests/fenics.csv b/benchmarks/linear-elastic-plate-with-hole/tests/fenics.csv
new file mode 100644
index 0000000..f0db114
--- /dev/null
+++ b/benchmarks/linear-elastic-plate-with-hole/tests/fenics.csv
@@ -0,0 +1,10 @@
+radius,length,load,element-size,element-order,element-degree,quadrature-rule,quadrature-degree,young-modulus,poisson-ratio,max_von_mises_stress_nodes,max_von_mises_stress_gauss_points
+0.33,1.0,100.0,0.025,1,1,gauss,1,210000000000.0,0.3,299791507.5586336,299791507.55863357
+0.33,1.0,100.0,0.1,1,2,gauss,2,210000000000.0,0.3,303258587.51563627,273716447.12326705
+0.33,1.0,100.0,0.0125,1,1,gauss,1,210000000000.0,0.3,300129618.71379626,300129618.7137961
+0.33,1.0,100.0,0.1,2,2,gauss,2,210000000000.0,0.3,303461918.9716136,274324640.6728336
+0.33,1.0,100.0,0.05,1,1,gauss,1,210000000000.0,0.3,296011478.74885035,296011478.7488503
+0.33,1.0,100.0,0.1,1,1,gauss,1,210000000000.0,0.3,273190934.3950996,273190934.39509964
+0.33,1.0,100.0,0.00625,1,1,gauss,1,210000000000.0,0.3,299475432.9322356,299475432.9322354
+0.33,1.0,100.0,0.5,2,2,gauss,2,210000000000.0,0.3,301751305.94987875,243231832.53382885
+0.33,1.0,100.0,0.003125,1,1,gauss,1,210000000000.0,0.3,299783353.33785635,299783353.3378568
diff --git a/benchmarks/linear-elastic-plate-with-hole/tests/kratos.csv b/benchmarks/linear-elastic-plate-with-hole/tests/kratos.csv
new file mode 100644
index 0000000..a8329f0
--- /dev/null
+++ b/benchmarks/linear-elastic-plate-with-hole/tests/kratos.csv
@@ -0,0 +1,10 @@
+radius,length,load,element-size,element-order,element-degree,quadrature-rule,quadrature-degree,young-modulus,poisson-ratio,max_von_mises_stress_nodes
+0.33,1.0,100.0,0.025,1,1,gauss,1,210000000000.0,0.3,283087904.0
+0.33,1.0,100.0,0.1,1,2,gauss,2,210000000000.0,0.3,226270384.0
+0.33,1.0,100.0,0.0125,1,1,gauss,1,210000000000.0,0.3,291662048.0
+0.33,1.0,100.0,0.1,2,2,gauss,2,210000000000.0,0.3,259553392.0
+0.33,1.0,100.0,0.05,1,1,gauss,1,210000000000.0,0.3,263995664.0
+0.33,1.0,100.0,0.1,1,1,gauss,1,210000000000.0,0.3,226270384.0
+0.33,1.0,100.0,0.00625,1,1,gauss,1,210000000000.0,0.3,296148032.0
+0.33,1.0,100.0,0.5,2,2,gauss,2,210000000000.0,0.3,197391808.0
+0.33,1.0,100.0,0.003125,1,1,gauss,1,210000000000.0,0.3,298100064.0
diff --git a/benchmarks/notebooks/RoCrate.ipynb b/benchmarks/notebooks/RoCrate.ipynb
new file mode 100644
index 0000000..10714b8
--- /dev/null
+++ b/benchmarks/notebooks/RoCrate.ipynb
@@ -0,0 +1,503 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Requirement already satisfied: rohub in /opt/anaconda3/lib/python3.12/site-packages (1.2.1)\n",
+ "Requirement already satisfied: requests in /opt/anaconda3/lib/python3.12/site-packages (from rohub) (2.32.5)\n",
+ "Requirement already satisfied: pandas in /opt/anaconda3/lib/python3.12/site-packages (from rohub) (2.2.2)\n",
+ "Requirement already satisfied: numpy>=1.26.0 in /opt/anaconda3/lib/python3.12/site-packages (from pandas->rohub) (1.26.4)\n",
+ "Requirement already satisfied: python-dateutil>=2.8.2 in /opt/anaconda3/lib/python3.12/site-packages (from pandas->rohub) (2.9.0.post0)\n",
+ "Requirement already satisfied: pytz>=2020.1 in /opt/anaconda3/lib/python3.12/site-packages (from pandas->rohub) (2024.1)\n",
+ "Requirement already satisfied: tzdata>=2022.7 in /opt/anaconda3/lib/python3.12/site-packages (from pandas->rohub) (2023.3)\n",
+ "Requirement already satisfied: charset_normalizer<4,>=2 in /opt/anaconda3/lib/python3.12/site-packages (from requests->rohub) (3.4.4)\n",
+ "Requirement already satisfied: idna<4,>=2.5 in /opt/anaconda3/lib/python3.12/site-packages (from requests->rohub) (3.11)\n",
+ "Requirement already satisfied: urllib3<3,>=1.21.1 in /opt/anaconda3/lib/python3.12/site-packages (from requests->rohub) (2.6.2)\n",
+ "Requirement already satisfied: certifi>=2017.4.17 in /opt/anaconda3/lib/python3.12/site-packages (from requests->rohub) (2026.1.4)\n",
+ "Requirement already satisfied: six>=1.5 in /opt/anaconda3/lib/python3.12/site-packages (from python-dateutil>=2.8.2->pandas->rohub) (1.17.0)\n"
+ ]
+ }
+ ],
+ "source": [
+ "!pip install rohub"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "\n",
+ "import rohub\n",
+ "import sys\n",
+ "import os\n",
+ "import pandas as pd\n",
+ "\n",
+ "module_path = os.path.abspath(os.path.join('..', 'common'))\n",
+ "\n",
+ "if module_path not in sys.path:\n",
+ " sys.path.append(module_path)\n",
+ "\n",
+ "import provenance\n",
+ "from generate_config import workflow_config\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "USE_DEVELOPMENT_VERSION = False"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "if USE_DEVELOPMENT_VERSION:\n",
+ " rohub.settings.API_URL = \"https://rohub2020-rohub.apps.paas-dev.psnc.pl/api/\"\n",
+ " rohub.settings.KEYCLOAK_CLIENT_ID = \"rohub2020-cli\"\n",
+ " rohub.settings.KEYCLOAK_CLIENT_SECRET = \"714617a7-87bc-4a88-8682-5f9c2f60337d\"\n",
+ " rohub.settings.KEYCLOAK_URL = \"https://keycloak-dev.apps.paas-dev.psnc.pl/auth/realms/rohub/protocol/openid-connect/token\"\n",
+ " rohub.settings.SPARQL_ENDPOINT = \"https://rohub2020-api-virtuoso-route-rohub.apps.paas-dev.psnc.pl/sparql/\"\n",
+ "else:\n",
+ " rohub.settings.API_URL = \"https://api.rohub.org/api/\"\n",
+ " rohub.settings.KEYCLOAK_CLIENT_ID = \"rohub2020-public-cli\"\n",
+ " rohub.settings.KEYCLOAK_URL = \"https://login.rohub.org/auth/realms/rohub/protocol/openid-connect/token\"\n",
+ " rohub.settings.SPARQL_ENDPOINT = \"https://rohub2020-api-virtuoso-route-rohub2020.apps.paas.psnc.pl/sparql\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Logged successfully as mahdi.jafarkhani@tik.uni-stuttgart.de.\n"
+ ]
+ }
+ ],
+ "source": [
+ "username = \"\"\n",
+ "password = \"\"\n",
+ "\n",
+ "rohub.login(username=username, password=password)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Trying to confirm status of the job. It can take a while...\n"
+ ]
+ }
+ ],
+ "source": [
+ "zip_path = \"/Users/mahdi/Downloads/metadata4ing_provenance.zip\"\n",
+ "resources_from_zip = rohub.ros_upload(path_to_zip=zip_path)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "ANNOTATION_PREDICATE = \"http://w3id.org/nfdi4ing/metadata4ing#investigates\"\n",
+ "ANNOTATION_OBJECT = \"https://github.com/BAMresearch/NFDI4IngModelValidationPlatform/tree/main/benchmarks/linear-elastic-plate-with-hole\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Research Object was successfully loaded with id = 5b8eae99-5f8b-4124-9eb6-05a64860819e\n"
+ ]
+ }
+ ],
+ "source": [
+ "RO = rohub.ros_load(\"5b8eae99-5f8b-4124-9eb6-05a64860819e\")\n",
+ "annotation_json = [\n",
+ "\t{\n",
+ "\t\t\"property\": ANNOTATION_PREDICATE,\n",
+ "\t\t\"value\": ANNOTATION_OBJECT\n",
+ "\t}\n",
+ "]\n",
+ "add_annotations_result = RO.add_annotations(body_specification_json=annotation_json)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "UUIDs: ['5b8eae99-5f8b-4124-9eb6-05a64860819e']\n"
+ ]
+ }
+ ],
+ "source": [
+ "UUID_QUERY = f\"\"\"\n",
+ "SELECT ?subject \n",
+ "WHERE {{\n",
+ " ?subject <{ANNOTATION_PREDICATE}> <{ANNOTATION_OBJECT}> .\n",
+ "}}\n",
+ "\"\"\"\n",
+ "\n",
+ "uuid_result = rohub.query_sparql_endpoint(UUID_QUERY)\n",
+ "uuids = []\n",
+ "\n",
+ "if not uuid_result.empty:\n",
+ " uuids = [iri.split('/')[-1] for iri in uuid_result[\"subject\"]]\n",
+ " print(\"UUIDs:\", uuids)\n",
+ "else:\n",
+ " uuids = []\n",
+ " print(\"No results found\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[5b8eae99-5f8b-4124-9eb6-05a64860819e] Found Named Graph: https://w3id.org/ro-id/5b8eae99-5f8b-4124-9eb6-05a64860819e/.ro/annotations/eb1512d5-cb3b-47ba-93e6-fcc2863f6e39.ttl\n"
+ ]
+ }
+ ],
+ "source": [
+ "named_graphs = {}\n",
+ "\n",
+ "for UUID in uuids:\n",
+ " NAMED_GRAPH_QUERY = f\"\"\"\n",
+ " PREFIX schema: \n",
+ " SELECT ?graph WHERE {{\n",
+ " GRAPH ?graph {{ a schema:Dataset . }}\n",
+ " }}\n",
+ " \"\"\"\n",
+ "\n",
+ " named_graph_result = rohub.query_sparql_endpoint(NAMED_GRAPH_QUERY)\n",
+ "\n",
+ " if not named_graph_result.empty:\n",
+ " graph_iri = named_graph_result.iloc[0][\"graph\"]\n",
+ " named_graphs[UUID] = graph_iri\n",
+ " print(f\"[{UUID}] Found Named Graph: {graph_iri}\")\n",
+ " else:\n",
+ " named_graphs[UUID] = None\n",
+ " print(f\"[{UUID}] No named graph found\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "analyzer = provenance.ProvenanceAnalyzer()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "parameters = [\"element-size\", \"element-order\", \"element-degree\"]\n",
+ "metrics = [\"max_von_mises_stress_nodes\"]\n",
+ "tools = workflow_config[\"tools\"]\n",
+ "\n",
+ "data = []\n",
+ "\n",
+ "for uuid, named_graph in named_graphs.items():\n",
+ " query_string = analyzer.build_dynamic_query(parameters, metrics, tools, named_graph)\n",
+ " result = rohub.query_sparql_endpoint(query_string)\n",
+ " if not result.empty:\n",
+ " result[\"element_order\"] = pd.to_numeric(\n",
+ " result[\"element_order\"], errors=\"coerce\"\n",
+ " )\n",
+ " result[\"element_degree\"] = pd.to_numeric(\n",
+ " result[\"element_degree\"], errors=\"coerce\"\n",
+ " )\n",
+ " filtered_result = result[\n",
+ " (result[\"element_order\"] == 1) & (result[\"element_degree\"] == 1)\n",
+ " ]\n",
+ " rows = [\n",
+ " [\n",
+ " float(row[\"element_size\"]),\n",
+ " float(row[\"max_von_mises_stress_nodes\"]),\n",
+ " row[\"tool_name\"],\n",
+ " ]\n",
+ " for _, row in filtered_result.iterrows()\n",
+ " ]\n",
+ " data.extend(rows)\n",
+ "\n",
+ "data.sort(key=lambda row: row[0], reverse=False)\n",
+ "\n",
+ "analyzer.plot_provenance_graph(\n",
+ " data=data,\n",
+ " x_axis_label=\"Element Size\",\n",
+ " y_axis_label=\"Max Von Mises Stress Nodes\",\n",
+ " x_axis_index=0,\n",
+ " y_axis_index=1,\n",
+ " group_by_index=2,\n",
+ " title=\"Element Size vs Max Von Mises Stress Nodes \\n element-order = 1 , element-degree = 1 \",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "parameters = [\"element-size\", \"element-order\", \"element-degree\"]\n",
+ "metrics = [\"max_von_mises_stress_gauss_points\"]\n",
+ "tools = workflow_config[\"tools\"]\n",
+ "\n",
+ "data = []\n",
+ "\n",
+ "for uuid, named_graph in named_graphs.items():\n",
+ " query_string = analyzer.build_dynamic_query(parameters, metrics, tools, named_graph)\n",
+ " result = rohub.query_sparql_endpoint(query_string)\n",
+ " if not result.empty:\n",
+ " result[\"element_order\"] = pd.to_numeric(\n",
+ " result[\"element_order\"], errors=\"coerce\"\n",
+ " )\n",
+ " result[\"element_degree\"] = pd.to_numeric(\n",
+ " result[\"element_degree\"], errors=\"coerce\"\n",
+ " )\n",
+ " filtered_result = result[\n",
+ " (result[\"element_order\"] == 1) & (result[\"element_degree\"] == 1)\n",
+ " ]\n",
+ " rows = [\n",
+ " [\n",
+ " float(row[\"element_size\"]),\n",
+ " float(row[\"max_von_mises_stress_gauss_points\"]),\n",
+ " row[\"tool_name\"],\n",
+ " ]\n",
+ " for _, row in filtered_result.iterrows()\n",
+ " ]\n",
+ " data.extend(rows)\n",
+ "\n",
+ "data.sort(key=lambda row: row[0], reverse=False)\n",
+ "\n",
+ "analyzer.plot_provenance_graph(\n",
+ " data=data,\n",
+ " x_axis_label=\"Element Size\",\n",
+ " y_axis_label=\"Max Von Mises Stress Gauss Points\",\n",
+ " x_axis_index=0,\n",
+ " y_axis_index=1,\n",
+ " group_by_index=2,\n",
+ " title=\"Element Size vs Max Von Mises Stress Gauss Points \\n element-order = 1 , element-degree = 1 \",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "parameters = [\"element-size\", \"element-order\", \"element-degree\"]\n",
+ "metrics = [\"max_von_mises_stress_nodes\"]\n",
+ "tools = workflow_config[\"tools\"]\n",
+ "\n",
+ "data = []\n",
+ "\n",
+ "for uuid, named_graph in named_graphs.items():\n",
+ " query_string = analyzer.build_dynamic_query(parameters, metrics, tools, named_graph)\n",
+ " result = rohub.query_sparql_endpoint(query_string)\n",
+ " if not result.empty:\n",
+ " result[\"element_order\"] = pd.to_numeric(\n",
+ " result[\"element_order\"], errors=\"coerce\"\n",
+ " )\n",
+ " result[\"element_degree\"] = pd.to_numeric(\n",
+ " result[\"element_degree\"], errors=\"coerce\"\n",
+ " )\n",
+ " filtered_result = result[\n",
+ " (result[\"element_order\"] == 2) & (result[\"element_degree\"] == 2)\n",
+ " ]\n",
+ " rows = [\n",
+ " [\n",
+ " float(row[\"element_size\"]),\n",
+ " float(row[\"max_von_mises_stress_nodes\"]),\n",
+ " row[\"tool_name\"],\n",
+ " ]\n",
+ " for _, row in filtered_result.iterrows()\n",
+ " ]\n",
+ " data.extend(rows)\n",
+ "\n",
+ "data.sort(key=lambda row: row[0], reverse=False)\n",
+ "\n",
+ "analyzer.plot_provenance_graph(\n",
+ " data=data,\n",
+ " x_axis_label=\"Element Size\",\n",
+ " y_axis_label=\"Max Von Mises Stress Nodes\",\n",
+ " x_axis_index=0,\n",
+ " y_axis_index=1,\n",
+ " group_by_index=2,\n",
+ " title=\"Element Size vs Max Von Mises Stress Nodes \\n element-order = 2 , element-degree = 2 \",\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "parameters = [\"element-size\", \"element-order\", \"element-degree\"]\n",
+ "metrics = [\"max_von_mises_stress_gauss_points\"]\n",
+ "tools = workflow_config[\"tools\"]\n",
+ "\n",
+ "data = []\n",
+ "\n",
+ "for uuid, named_graph in named_graphs.items():\n",
+ " query_string = analyzer.build_dynamic_query(parameters, metrics, tools, named_graph)\n",
+ " result = rohub.query_sparql_endpoint(query_string)\n",
+ " if not result.empty:\n",
+ " result[\"element_order\"] = pd.to_numeric(\n",
+ " result[\"element_order\"], errors=\"coerce\"\n",
+ " )\n",
+ " result[\"element_degree\"] = pd.to_numeric(\n",
+ " result[\"element_degree\"], errors=\"coerce\"\n",
+ " )\n",
+ " filtered_result = result[\n",
+ " (result[\"element_order\"] == 2) & (result[\"element_degree\"] == 2)\n",
+ " ]\n",
+ " rows = [\n",
+ " [\n",
+ " float(row[\"element_size\"]),\n",
+ " float(row[\"max_von_mises_stress_gauss_points\"]),\n",
+ " row[\"tool_name\"],\n",
+ " ]\n",
+ " for _, row in filtered_result.iterrows()\n",
+ " ]\n",
+ " data.extend(rows)\n",
+ "\n",
+ "data.sort(key=lambda row: row[0], reverse=False)\n",
+ "\n",
+ "analyzer.plot_provenance_graph(\n",
+ " data=data,\n",
+ " x_axis_label=\"Element Size\",\n",
+ " y_axis_label=\"Max Von Mises Stress Nodes Gauss Points \",\n",
+ " x_axis_index=0,\n",
+ " y_axis_index=1,\n",
+ " group_by_index=2,\n",
+ " title=\"Element Size vs Max Von Mises Stress Nodes Gauss Points \\n element-order = 2 , element-degree = 2 \",\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "base",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
diff --git a/environment_benchmarks.yml b/environment_benchmarks.yml
index 2ee70d3..0e36b3a 100644
--- a/environment_benchmarks.yml
+++ b/environment_benchmarks.yml
@@ -11,4 +11,4 @@ dependencies:
- conda
- pip
- pip:
- - "git+https://github.com/izus-fokus/snakemake-report-plugin-metadata4ing@v1.0.0#egg=snakemake-report-plugin-metadata4ing"
\ No newline at end of file
+ - "git+https://github.com/izus-fokus/snakemake-report-plugin-metadata4ing@v1.2.3#egg=snakemake-report-plugin-metadata4ing"
\ No newline at end of file