PMDCO_3_0_RDF_TTO_Data_Mapping.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i9xFCD7lzN4o"
   },
   "source": [
    "**RDF creation of tensile test data using TTO**\n",
    "\n",
    "In this notebook, data originating from tensile tests performed to an S355 steel sheet is read in to create an exemplary RDF data file that uses the [Tensile Test Ontology (TTO) version 3.0](https://github.com/materialdigital/tensile-test-ontology) as semantic backbone. Hence, the tensile test data available in 'classic' test formats is transformed to RDF data by creating triples using the RDFlib library and some helper functions. Therefore, values tokenized from the CSV are allocated to concepts of the TTO developed in the frame of the PMD project. Since the TTO is strongly based on the PMD Core Ontology - PMDco (namespace: [https://w3id.org/pmd/co](https://w3id.org/pmd/co)) - the PMDco will also be parsed and semantic concepts this ontology is related to will also be used, accordingly. The tensile test data is taken from a dataset published openly available on [Zenodo](https://zenodo.org/record/6778336).\n",
    "The RDF data is directly saved in a graph. Subsequently, the graph is serialized and saved to a TTL and an RDF file. Furthermore, SPARQL queries may be performed for consistency checks.\n",
    "Hence, all in all, this script is used to create a knowledge graph using vocabulary of several ontologies and tensile test data originating from real tests performed on an S355 steel in accordance with the corresponding test standard [ISO 6892-1:2019-11](https://www.beuth.de/de/norm/iso-6892-1/316885984)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SiKstygmJ7BC"
   },
   "source": [
    "# Installing and Importing relevant Python packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ALWAfVAn0G2p",
    "outputId": "6767a7e1-e2cb-48eb-b19d-87111243d656"
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "%pip install --upgrade pip\n",
    "# Installing relevant python package rdflib\n",
    "%pip install rdflib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "W9PMLkvw0Gs_"
   },
   "outputs": [],
   "source": [
    "# Import of relevant package parts\n",
    "from rdflib import Graph, Literal, URIRef, BNode, Namespace, DC\n",
    "from rdflib.term import Identifier\n",
    "from rdflib.collection import Collection\n",
    "from rdflib.namespace import RDF, RDFS, SKOS, XSD, OWL\n",
    "import rdflib.plugins.sparql.update\n",
    "import pandas as pd\n",
    "import io\n",
    "import urllib.parse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r1QFp5RGKPAo"
   },
   "source": [
    "# Definition of helper methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "id": "MsiwF49W0Ggf"
   },
   "outputs": [],
   "source": [
    "# Definition of helper methods / functions - do not necessarily have to be used.\n",
    "\n",
    "# Helper method 'add' used to write triples to an RDF graph\n",
    "def add(s,p,o):\n",
    "\n",
    "    # in this case p is \"ObjectProperty\"\n",
    "    if o.find('http://')==0 or o.find('https://')==0:\n",
    "        g.add( (URIRef(s), URIRef(p), URIRef(o)) )\n",
    "\n",
    "    # in this case p is \"DatatypeProperty\"\n",
    "    else:\n",
    "        # if we can parse o as Float, just set the datatype\n",
    "        try:\n",
    "            g.add( (URIRef(s), URIRef(p), Literal(float(o), datatype=XSD.float) ))\n",
    "        except:\n",
    "            g.add( (URIRef(s), URIRef(p), Literal(o) ))\n",
    "\n",
    "\n",
    "# Global counter possibly usable for the creation of arbitrary instance names (numbers)\n",
    "instanceCounter = 0\n",
    "def nextInstanceNum():\n",
    "    global instanceCounter\n",
    "    instanceCounter = instanceCounter + 1\n",
    "    return str(instanceCounter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JRFzEfTHKGt1"
   },
   "source": [
    "# Read in tensile test data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "lqEA1YqQqo3w"
   },
   "outputs": [],
   "source": [
    "# Read in data that is supposed to be mapped to the concepts of the ontology (TTO).\n",
    "# The data is also findable as a dataset on tensile tests that is published freely available on Zenodo: https://zenodo.org/record/6778336\n",
    "# Reading in data from URL\n",
    "\n",
    "link_data = \"https://raw.githubusercontent.com/materialdigital/tensile-test-ontology/main/data/S355_data.csv\"\n",
    "data_S333_read_in = pd.read_csv(link_data, sep=';')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mGtNWn9bKXms"
   },
   "source": [
    "# Graph creation using RDFlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "id": "Q0DKLdjU0MId"
   },
   "outputs": [],
   "source": [
    "# Creating the RDF graph 'g'\n",
    "g = Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "9ZVPKF8ArjDv"
   },
   "outputs": [],
   "source": [
    "# Definition of IRI prefixes (namespaces)\n",
    "base = Namespace(\"https://w3id.org/pmd/tto/\")\n",
    "g.bind(\"base\", base)\n",
    "pmdco = Namespace(\"https://w3id.org/pmd/co/\")\n",
    "g.bind(\"pmdco\", pmdco)\n",
    "unit = Namespace(\"http://qudt.org/vocab/unit/\")\n",
    "g.bind(\"unit\", unit)\n",
    "prov = Namespace(\"http://www.w3.org/ns/prov#\")\n",
    "g.bind(\"prov\", prov)\n",
    "raw_data = Namespace(\"https://github.com/materialdigital/tensile-test-ontology/tree/3dc72e40d492402e5ccd46167b8c03c62599c5dc/data/primary_data/\")\n",
    "g.bind(\"raw_data\", raw_data)\n",
    "csvw = Namespace(\"http://www.w3.org/ns/csvw#\")\n",
    "g.bind(\"csvw\", csvw)\n",
    "datacite = Namespace(\"http://purl.org/spar/datacite/\")\n",
    "g.bind(\"datacite\", datacite)\n",
    "obo = Namespace(\"http://purl.obolibrary.org/obo/\")\n",
    "g.bind(\"obo\", obo)\n",
    "dct = Namespace(\"http://purl.org/dc/elements/1.1/\")\n",
    "g.bind(\"dct\", dct)\n",
    "time = Namespace(\"http://www.w3.org/2006/time#\")\n",
    "g.bind(\"time\", time)\n",
    "\n",
    "# A-Box namespace (namespace of instances)\n",
    "prefix = Namespace(\"https://w3id.org/pmd/demodata/tensiletest_S355/\")\n",
    "g.bind(\"prefix\", prefix)\n",
    "\n",
    "# Turtle style abbreviation for RDF.type\n",
    "a = RDF.type\n",
    "\n",
    "# Create ontology and import TTO as basis\n",
    "onto = URIRef(prefix)\n",
    "g.add((onto, a, OWL.Ontology))\n",
    "g.add((onto, OWL.imports, URIRef(base)))\n",
    "\n",
    "# Add creators:\n",
    "markus = URIRef(\"https://orcid.org/0000-0002-7094-5371\")\n",
    "bernd = URIRef(\"https://orcid.org/0000-0002-3717-7104\")\n",
    "joerg = URIRef(\"https://orcid.org/0000-0001-7192-7143\")\n",
    "philipp = URIRef(\"https://orcid.org/0000-0003-4971-3645\")\n",
    "\n",
    "g.add((onto, DC.creator, markus))\n",
    "g.add((markus, RDFS.label, Literal(\"Markus Schilling\", datatype=XSD.string)))\n",
    "g.add((onto, DC.creator, bernd))\n",
    "g.add((bernd, RDFS.label, Literal(\"Bernd Bayerlein\", datatype=XSD.string)))\n",
    "g.add((onto, DC.creator, joerg))\n",
    "g.add((joerg, RDFS.label, Literal(\"Jörg Waitelonis\", datatype=XSD.string)))\n",
    "g.add((onto, DC.creator, philipp))\n",
    "g.add((philipp, RDFS.label, Literal(\"Philipp von Hartrott\", datatype=XSD.string)))\n",
    "\n",
    "g.add((onto, DC.title, Literal(\"Tensile Test Ontology (TTO) data mapping example\", datatype=XSD.string)))\n",
    "g.add((onto, OWL.versionInfo, Literal(\"3.0.0\", datatype=XSD.string)))\n",
    "\n",
    "# Load data from read in above.\n",
    "data = data_S333_read_in\n",
    "\n",
    "# Creation of QUDT unit instances as instances of iao:measurement unit label\n",
    "# mesurement unit label has IRI: obo.IAO_0000003 (see below for more details)\n",
    "g.add((unit.MilliM, a, obo.IAO_0000003))\n",
    "g.add((unit.SEC, a, obo.IAO_0000003))\n",
    "g.add((unit.KiloN, a, obo.IAO_0000003))\n",
    "g.add((unit.PERCENT, a, obo.IAO_0000003))\n",
    "g.add((unit.MilliM2, a, obo.IAO_0000003))\n",
    "g.add((unit.MegaPa, a, obo.IAO_0000003))\n",
    "g.add((unit.GigaPa, a, obo.IAO_0000003))\n",
    "g.add((unit.DEG_C, a, obo.IAO_0000003))\n",
    "\n",
    "# Creation of triples\n",
    "# Iterate over the full data table\n",
    "for idx, row in data.iterrows():\n",
    "  # Definition of tokens in accordance with columns of original csv file\n",
    "  process_id                          = row[\"process\"]\n",
    "  testpiece_id                        = row[\"testpiece\"]\n",
    "  a1                                  = row[\"d1 / a1\"]\n",
    "  a2                                  = row[\"d2 / a2\"]\n",
    "  a3                                  = row[\"d3 / a3\"]\n",
    "  b1                                  = row[\"b1\"]\n",
    "  b2                                  = row[\"b2\"]\n",
    "  b3                                  = row[\"b3\"]\n",
    "  s1                                  = row[\"s1\"]\n",
    "  s2                                  = row[\"s2\"]\n",
    "  s3                                  = row[\"s3\"]\n",
    "  S0                                  = row[\"S0\"]\n",
    "  Rp02                                = row[\"Rp0,2\"]\n",
    "  ReH                                 = row[\"ReH\"]\n",
    "  Fm                                  = row[\"Fm\"]\n",
    "  Rm                                  = row[\"Rm\"]\n",
    "  E                                   = row[\"E\"]\n",
    "  L0                                  = row[\"L0\"]\n",
    "  Lu                                  = row[\"Lu\"]\n",
    "  A                                   = row[\"A\"]\n",
    "  au                                  = row[\"au\"]\n",
    "  bu                                  = row[\"bu\"]\n",
    "  Su                                  = row[\"Su\"]\n",
    "  Z                                   = row[\"Z\"]\n",
    "  operator                            = row[\"Operator\"]\n",
    "  date                                = row[\"date\"]\n",
    "  materialDescription                 = row[\"Werkstoff\"]\n",
    "  specimenShape                       = row[\"Probenform\"]\n",
    "  note                                = row[\"Note\"]\n",
    "  environmentalTemperature            = row[\"Umgebungstemperatur\"]\n",
    "  machineName                         = row[\"Prüfmaschinen-Name\"]\n",
    "  machineManufacturer                 = row[\"Prüfmaschinenhersteller\"]\n",
    "  machineType                         = row[\"Prüfmaschinen-Typ\"]\n",
    "  machineSerialNumber                 = row[\"Prüfmaschinen-Seriennummer\"]\n",
    "  machineStandard                     = row[\"Prüfmaschinen-Standard\"]\n",
    "  extensometerName                    = row[\"Extensometer\"]\n",
    "  extensometerSerialNumber            = row[\"Extensometer-Seriennummer\"]\n",
    "  extensometerStandard                = row[\"Extensometer-Standard\"]\n",
    "  micrometerGaugeManufacturer         = row[\"Mikrometerschraube-Hersteller\"]\n",
    "  caliperManufacturer                 = row[\"Messschieber-Hersteller\"]\n",
    "  caliperSerialNumber                 = row[\"Messschieber-Seriennummer\"]\n",
    "  strainRate                          = row[\"Dehngeschwindigkeit\"]\n",
    "  transitionPoint                     = row[\"Umschaltpunkt\"]\n",
    "  extensometerGaugeLength             = row[\"Extensometer-Nenngerätemesslänger\"]\n",
    "  loadCellMaxForce                    = row[\"Kraftmessdose-Kraftbereich\"]\n",
    "  project                             = row[\"Project\"]\n",
    "  standard                            = row[\"Norm\"]\n",
    "  rollingDirection                    = row[\"Walzrichtung\"]\n",
    "  location                            = row[\"Ort\"]\n",
    "  institute                           = row[\"Institut\"]\n",
    "  address                             = row[\"Adresse\"]\n",
    " \n",
    "  # Creation of triples for all instances (considering all connections between them) based on a bibliographic approach (RDFlib). There is about one \"block\" per instance.\n",
    "  experimentIRI = URIRef(prefix + process_id)\n",
    "  g.add((experimentIRI, a, obo.IAO_0020000))\n",
    "  g.add((experimentIRI, RDFS.label, Literal(process_id, datatype=XSD.string)))  \n",
    "\n",
    "  processIRI = URIRef(experimentIRI + \"_process\")\n",
    "  g.add((processIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((processIRI, a, base.TensileTest)) # Tensile Test\n",
    "  g.add((experimentIRI, obo.IAO_0000219, processIRI)) # Experiment ID denotes Process (Tensile Test)\n",
    "\n",
    "  # Creation Process Plan and Process Plan Specification\n",
    "  processPlanIRI = URIRef(experimentIRI + \"_process_plan\")\n",
    "  g.add((processPlanIRI, a, obo.OBI_0000260)) # obi:Plan\n",
    "  g.add((processIRI, obo.BFO_0000055, processPlanIRI)) # (Tensile Test) Process bfo:realizes the process plan\n",
    "\n",
    "  processPlanSpecificationIRI = URIRef(experimentIRI + \"_process_plan_specification\")\n",
    "  g.add((processPlanSpecificationIRI, a, obo.OBI_0000104)) # obi:Plan Specification\n",
    "  g.add((processPlanIRI, obo.RO_0000059, processPlanSpecificationIRI)) # The process plan ro:concretizes a process plan specification\n",
    "\n",
    "\n",
    "  # Advanced process description\n",
    "  # In this section, the process of tensile testing is disassembled into individual parts, allowing a more precise process and subprocess description.\n",
    "\n",
    "  # No. 1\n",
    "  preMeasuringIRI = URIRef(experimentIRI + \"_process_preMeasuring\")\n",
    "  g.add((preMeasuringIRI, a, obo.OBI_0000070)) # Assay (subclass of Planned process)\n",
    "  g.add((preMeasuringIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((processIRI, obo.RO_0002224, preMeasuringIRI)) # (entire) process starts with\n",
    "  \n",
    "  # No. 2\n",
    "  mountingIRI = URIRef(experimentIRI + \"_process_mounting\")\n",
    "  g.add((mountingIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((mountingIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((mountingIRI, obo.RO_0002090, preMeasuringIRI)) # Mounting process immediately precedes preMeasuring process\n",
    "\n",
    "  # No. 3\n",
    "  gripsAlignmentIRI = URIRef(experimentIRI + \"_process_gripsAlignment\")\n",
    "  g.add((gripsAlignmentIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((gripsAlignmentIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((gripsAlignmentIRI, obo.RO_0002090, mountingIRI)) # Grips Alignment process immediately precedes Mounting process\n",
    "\n",
    "  # No. 4\n",
    "  tensileTestISOIRI = URIRef(experimentIRI + \"_process_tensileTestISO\")\n",
    "  g.add((tensileTestISOIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((tensileTestISOIRI, a, base.TensileTest)) # ISO Tensile testing refers to tensile testing\n",
    "  g.add((tensileTestISOIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((tensileTestISOIRI, obo.RO_0002090, gripsAlignmentIRI)) # ISO Tensile Test process immediately precedes Grips Alignment process\n",
    "\n",
    "  # No. 5\n",
    "  demountingIRI = URIRef(experimentIRI + \"_process_demounting\")\n",
    "  g.add((demountingIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((demountingIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((demountingIRI, obo.RO_0002090, tensileTestISOIRI)) # Demounting process immediately precedes ISO Tensile Test process\n",
    "\n",
    "  # No. 6\n",
    "  postMeasuringIRI = URIRef(experimentIRI + \"_process_postMeasuring\")\n",
    "  g.add((postMeasuringIRI, a, obo.OBI_0000070)) # Assay (subclass of Planned process)\n",
    "  g.add((postMeasuringIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((postMeasuringIRI, obo.RO_0002090, demountingIRI)) # Post Measuring process immediately precedes Demounting process\n",
    "\n",
    "  # No. 7\n",
    "  analysisIRI = URIRef(experimentIRI + \"_process_analysis\")\n",
    "  g.add((analysisIRI, a, pmdco.PMD_0000583)) # Process is also a Computing process (PMD_0000583) which is a subclass of planned process in acc. with new version of PMDco 3.0 datatransformation module\n",
    "  # g.add((analysisIRI, a, obo.OBI_0000011)) # Planned process\n",
    "  g.add((analysisIRI, obo.RO_0002012, processIRI)) # Occurrent part of (entire) process\n",
    "  g.add((analysisIRI, obo.RO_0002090, postMeasuringIRI)) # Analysis process immediately precedes Post Measuring process\n",
    "\n",
    "  \n",
    "  # Object / test piece description\n",
    "  # Test piece as input prior to tensile test\n",
    "  testpieceIRI = URIRef(prefix  + f\"testpiece/{testpiece_id}\")\n",
    "  g.add((testpieceIRI, a, base.TestPiece)) # tto:TestPiece as subclass of bfo:object\n",
    "  testpieceID_IRI = URIRef(prefix + f\"testpiece_name/{testpiece_id}\")\n",
    "  g.add((testpieceID_IRI, a, obo.IAO_0020000)) # IAO:identifier\n",
    "  g.add((testpieceID_IRI, dct.identifier, Literal(testpiece_id, datatype=XSD.string)))\n",
    "  g.add((testpieceID_IRI, obo.IAO_0000219, testpieceIRI)) # testpiece ID iao:denotes testpiece\n",
    "\n",
    "  # Test piece(s) as output after tensile test (typically, 2 fractured parts will be formed)\n",
    "  # Test piece after test 1\n",
    "  testpieceAfterTest1IRI = URIRef(testpieceIRI  + \"_testpiece_afterTest_1\")\n",
    "  g.add((testpieceAfterTest1IRI, a, base.TestPiece)) # tto:TestPiece as subclass of bfo:object\n",
    "  testpieceAfterTest1ID_IRI = URIRef(testpieceID_IRI + \"_afterTest_1\")\n",
    "  g.add((testpieceAfterTest1ID_IRI, a, obo.IAO_0020000)) # IAO:identifier\n",
    "  g.add((testpieceAfterTest1ID_IRI, dct.identifier, Literal(testpiece_id + \"_afterTest_1\", datatype=XSD.string)))\n",
    "  g.add((testpieceAfterTest1ID_IRI, obo.IAO_0000219, testpieceAfterTest1IRI)) # testpiece after test 1 ID iao:denotes testpiece after test 1\n",
    "\n",
    "  # Test piece after test 2\n",
    "  testpieceAfterTest2IRI = URIRef(testpieceIRI  + \"_testpiece_afterTest_2\")\n",
    "  g.add((testpieceAfterTest2IRI, a, base.TestPiece)) # tto:TestPiece as subclass of bfo:object\n",
    "  testpieceAfterTest2ID_IRI = URIRef(testpieceID_IRI + \"_afterTest_2\")\n",
    "  g.add((testpieceAfterTest2ID_IRI, a, obo.IAO_0020000)) # IAO:identifier\n",
    "  g.add((testpieceAfterTest2ID_IRI, dct.identifier, Literal(testpiece_id + \"_afterTest_2\", datatype=XSD.string)))\n",
    "  g.add((testpieceAfterTest2ID_IRI, obo.IAO_0000219, testpieceAfterTest2IRI)) # testpiece after test 2 ID iao:denotes testpiece after test 2\n",
    "\n",
    "  # Process - Test Piece Relations\n",
    "  g.add((processIRI, obo.OBI_0000293, testpieceIRI)) # Process has specified input testpiece\n",
    "  g.add((processIRI, obo.OBI_0000299, testpieceAfterTest1IRI)) # Process has specified output testpiece after test 1\n",
    "  g.add((processIRI, obo.OBI_0000299, testpieceAfterTest2IRI)) # Process has specified output testpiece after test 2\n",
    "  g.add((testpieceAfterTest1IRI, obo.RO_0001000, testpieceIRI)) # Testpiece after test 1 derives from Testpiece\n",
    "  g.add((testpieceAfterTest2IRI, obo.RO_0001000, testpieceIRI)) # Testpiece after test 2 derives from Testpiece\n",
    "\n",
    "\n",
    "  # The next section contains some material / test piece information.\n",
    "\n",
    "  materialDescriptionIRI = URIRef(experimentIRI + \"_material_description\")\n",
    "  g.add((materialDescriptionIRI, a, pmdco.PMD_0000002)) # PMD_0000002 is a pmdco:MaterialDesignation as subclass of iao:identifier --> information content entity\n",
    "  g.add((materialDescriptionIRI, dct.identifier, Literal(materialDescription, datatype=XSD.string)))\n",
    "  g.add((materialDescriptionIRI, obo.IAO_0000219, testpieceIRI)) # Material Description (identifier) iao:denotes Test Piece (Test pieces after test are derived from test piece, anyways)\n",
    "\n",
    "  specimenShapeIRI = URIRef(experimentIRI + \"_specimen_shape\")\n",
    "  g.add((specimenShapeIRI, a, base.Shape3D)) # Shape3D as subclass of tto:geometry shape, subclass of tto:shape, subclass of pmdco:morphological quality\n",
    "  g.add((testpieceIRI, obo.RO_0000086, specimenShapeIRI)) # Test piece ro:has quality specimen Shape\n",
    "\n",
    "  specimenShapeTextualEntityIRI = URIRef(experimentIRI + \"_specimen_shape_description\")\n",
    "  g.add((specimenShapeTextualEntityIRI, a, obo.IAO_0000300)) # is an iao:textual entity\n",
    "  g.add((specimenShapeTextualEntityIRI, obo.OBI_0002815, Literal(specimenShape, datatype=XSD.string))) # Specimen Shape Textual Entity obi:has representation (Datatype Property used for textual information)\n",
    "  g.add((specimenShapeTextualEntityIRI, obo.IAO_0000136, specimenShapeIRI)) # Specimen Shape Textual Entity iao:is about Specimen Shape  \n",
    "\n",
    "  rollingDirectionInformationIRI = URIRef(experimentIRI + \"_rolling_direction_information\")\n",
    "  g.add((rollingDirectionInformationIRI, a, obo.IAO_0000300)) # is an iao:textual entity\n",
    "  g.add((rollingDirectionInformationIRI, obo.OBI_0002815, Literal(rollingDirection, datatype=XSD.string))) # Rolling Direction Information obi:has representation (Datatype Property used for textual information)\n",
    "  g.add((rollingDirectionInformationIRI, obo.IAO_0000136, testpieceIRI)) # Rolling Direction Information Textual Entity iao:is about Test Piece\n",
    "\n",
    "  # The next section contains some primary data.\n",
    "\n",
    "  # Raw data / dataset\n",
    "  # Using CSVW ontology vocabulary for raw / primary data set description\n",
    "  datasetIRI = URIRef(experimentIRI + \"resource/\" + testpiece_id + \"_dataset\")\n",
    "  g.add((datasetIRI, a, csvw.Table)) # is a csvw:Table\n",
    "  g.add((datasetIRI, a, obo.IAO_0000100)) # is an iao:data set\n",
    "  g.add((datasetIRI, DC.title, Literal(f\"process/{process_id}\" + f\"testpiece_id/{testpiece_id}\", datatype=XSD.string)))\n",
    "  g.add((datasetIRI, csvw.url, Literal(raw_data + f\"{testpiece_id}\" + \".csv\", datatype=XSD.string)))\n",
    "  g.add((datasetIRI, DC.format, Literal(\"text/csv\", datatype=XSD.string)))\n",
    "  g.add((processIRI, obo.OBI_0000299, datasetIRI)) # Entire Tensile Test Process obi:has specified output dataset\n",
    "  g.add((tensileTestISOIRI, obo.OBI_0000299, datasetIRI)) # ISO Tensile Test Process (subprocess) obi:has specified output dataset\n",
    "\n",
    "  schemaIRI = URIRef(experimentIRI + testpiece_id + \"_schema\")\n",
    "  g.add((schemaIRI, a, csvw.Schema))\n",
    "  g.add((datasetIRI, csvw.tableSchema, schemaIRI))\n",
    "\n",
    "  BNode1 = BNode()\n",
    "  BNode2 = BNode()\n",
    "  BNode3 = BNode()\n",
    "  BNode4 = BNode()\n",
    "\n",
    "  column1 = BNode()\n",
    "  g.add((column1, a, csvw.Column))\n",
    "  g.add((column1, a, time.Duration)) # is a time:Duration as subclass of time:TemporalDuration (owl:Class)\n",
    "  g.add((column1, obo.IAO_0000039, unit.SEC)) # Column iao:has measurement label \n",
    "  g.add((column1, csvw.name, Literal(\"Time\", datatype=XSD.string)))\n",
    "  g.add((column1, DC.title, Literal(\"Time\", datatype=XSD.string)))\n",
    "  g.add((column1, csvw.datatype, Literal(1, datatype=XSD.float))) # here, also xsd:duration may be used; although, a decimal is given in the data!\n",
    "  g.add((column1, csvw.headerCount, Literal(2, datatype=XSD.float)))\n",
    "\n",
    "  column2 = BNode()\n",
    "  g.add((column2, a, csvw.Column))\n",
    "  g.add((column2, a, base.CrossheadSeparation))\n",
    "  g.add((column2, obo.IAO_0000039, unit.MilliM)) # Column iao:has measurement label \n",
    "  g.add((column2, csvw.name, Literal(\"Crosshead travel\", datatype=XSD.string)))\n",
    "  g.add((column2, DC.title, Literal(\"Crosshead Separation\", datatype=XSD.string)))\n",
    "  g.add((column2, csvw.datatype, Literal(2, datatype=XSD.float)))\n",
    "  g.add((column2, csvw.headerCount, Literal(2, datatype=XSD.float)))\n",
    "\n",
    "  column3 = BNode()\n",
    "  g.add((column3, a, csvw.Column))\n",
    "  g.add((column3, a, base.Force))\n",
    "  g.add((column3, obo.IAO_0000039, unit.KiloN)) # Column iao:has measurement label \n",
    "  g.add((column3, csvw.name, Literal(\"Force\", datatype=XSD.string)))\n",
    "  g.add((column3, DC.title, Literal(\"Force\", datatype=XSD.string)))\n",
    "  g.add((column3, csvw.datatype, Literal(3, datatype=XSD.float)))\n",
    "  g.add((column3, csvw.headerCount, Literal(2, datatype=XSD.float)))\n",
    "\n",
    "  column4 = BNode()\n",
    "  g.add((column4, a, csvw.Column))\n",
    "  g.add((column4, a, base.PercentageExtension))\n",
    "  g.add((column4, obo.IAO_0000039, unit.PERCENT)) # Column iao:has measurement label \n",
    "  g.add((column4, csvw.name, Literal(\"Strain\", datatype=XSD.string)))\n",
    "  g.add((column4, DC.title, Literal(\"Percentage Extension\", datatype=XSD.string)))\n",
    "  g.add((column4, csvw.datatype, Literal(4, datatype=XSD.float)))\n",
    "  g.add((column4, csvw.headerCount, Literal(2, datatype=XSD.float)))\n",
    "\n",
    "  g.add((schemaIRI, csvw.column, BNode1))\n",
    "  g.add((BNode1, RDF.first, column1))\n",
    "  g.add((BNode1, RDF.rest, BNode2))\n",
    "  g.add((BNode2, RDF.first, column2))\n",
    "  g.add((BNode2, RDF.rest, BNode3))\n",
    "  g.add((BNode3, RDF.first, column3))\n",
    "  g.add((BNode3, RDF.rest, BNode4))\n",
    "  g.add((BNode4, RDF.first, column4))\n",
    "  g.add((BNode4, RDF.rest, RDF.nil))\n",
    "\n",
    "  # Rest of primary data.\n",
    "  # a1\n",
    "  a1IRI_value_specification = URIRef(experimentIRI + \"_thickness_a1_value_specification\")\n",
    "  g.add((a1IRI_value_specification, a, obo.OBI_0001931)) # a1 measurement value specification is a obi:scalar value specification\n",
    "  g.add((a1IRI_value_specification, obo.OBI_0001937, Literal(a1, datatype=XSD.float))) # a1IRI_value_specification has specified numeric value a1\n",
    "  g.add((a1IRI_value_specification, obo.IAO_0000039, unit.MilliM)) # a1 measurement value specification iao:has measurement unit label unit:MilliM (QUDT)\n",
    "  g.add((a1IRI_value_specification, obo.IAO_0000136, testpieceIRI)) # a1 measurement value specification iao:is about Testpiece\n",
    "\n",
    "  a1IRI = URIRef(experimentIRI + \"_thickness_a1_scalar_measurement_datum\")\n",
    "  g.add((a1IRI, a, obo.IAO_0000032)) # a1 is a iao:scalar measurement datum\n",
    "  g.add((a1IRI, obo.OBI_0001938, a1IRI_value_specification)) # a1 scalar measurement datum obi:has specified numeric value a1 measurement value specification\n",
    "  g.add((processIRI, obo.OBI_0000299, a1IRI)) # Process has specified output a1\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, a1IRI)) # preMeasuring process has specified output a1\n",
    "  g.add((a1IRI, obo.IAO_0000136, testpieceIRI)) # a1 scalar measurement datum iao:is about testpiece\n",
    "\n",
    "  a1IRI_quality = URIRef(experimentIRI + \"_thickness_a1\")\n",
    "  g.add((a1IRI_quality, a, base.OriginalThickness)) # Original Thickness used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((a1IRI_quality, obo.IAO_0000417, a1IRI)) # a1 quality iao:is quality measured as a1\n",
    "  g.add((testpieceIRI, obo.RO_0000086, a1IRI_quality)) # Testpiece ro:has quality a1 quality\n",
    "\n",
    "  # a2\n",
    "  a2IRI_value_specification = URIRef(experimentIRI + \"_thickness_a2_value_specification\")\n",
    "  g.add((a2IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((a2IRI_value_specification, obo.OBI_0001937, Literal(a2, datatype=XSD.float)))\n",
    "  g.add((a2IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((a2IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  a2IRI = URIRef(experimentIRI + \"_thickness_a2_scalar_measurement_datum\")\n",
    "  g.add((a2IRI, a, obo.IAO_0000032))\n",
    "  g.add((a2IRI, obo.OBI_0001938, a2IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, a2IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, a2IRI)) # preMeasuring process has specified output a2\n",
    "  g.add((a2IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  a2IRI_quality = URIRef(experimentIRI + \"_thickness_a2\")\n",
    "  g.add((a2IRI_quality, a, base.OriginalThickness)) # Original Thickness used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((a2IRI_quality, obo.IAO_0000417, a2IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, a2IRI_quality))\n",
    "\n",
    "  # a3\n",
    "  a3IRI_value_specification = URIRef(experimentIRI + \"_thickness_a3_value_specification\")\n",
    "  g.add((a3IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((a3IRI_value_specification, obo.OBI_0001937, Literal(a3, datatype=XSD.float)))\n",
    "  g.add((a3IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((a3IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  a3IRI = URIRef(experimentIRI + \"_thickness_a3_scalar_measurement_datum\")\n",
    "  g.add((a3IRI, a, obo.IAO_0000032))\n",
    "  g.add((a3IRI, obo.OBI_0001938, a3IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, a3IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, a3IRI)) # preMeasuring process has specified output a3\n",
    "  g.add((a3IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  a3IRI_quality = URIRef(experimentIRI + \"_thickness_a3\")\n",
    "  g.add((a3IRI_quality, a, base.OriginalThickness)) # Original Thickness used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((a3IRI_quality, obo.IAO_0000417, a3IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, a3IRI_quality))\n",
    "\n",
    "  # b1\n",
    "  b1IRI_value_specification = URIRef(experimentIRI + \"_width_b1_value_specification\")\n",
    "  g.add((b1IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((b1IRI_value_specification, obo.OBI_0001937, Literal(b1, datatype=XSD.float)))\n",
    "  g.add((b1IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((b1IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b1IRI = URIRef(experimentIRI + \"_width_b1_scalar_measurement_datum\")\n",
    "  g.add((b1IRI, a, obo.IAO_0000032))\n",
    "  g.add((b1IRI, obo.OBI_0001938, b1IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, b1IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, b1IRI)) # preMeasuring process has specified output b1\n",
    "  g.add((b1IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b1IRI_quality = URIRef(experimentIRI + \"_width_b1\")\n",
    "  g.add((b1IRI_quality, a, base.OriginalWidth)) # Original Width used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((b1IRI_quality, obo.IAO_0000417, b1IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, b1IRI_quality))\n",
    "\n",
    "  # b2\n",
    "  b2IRI_value_specification = URIRef(experimentIRI + \"_width_b2_value_specification\")\n",
    "  g.add((b2IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((b2IRI_value_specification, obo.OBI_0001937, Literal(b2, datatype=XSD.float)))\n",
    "  g.add((b2IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((b2IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b2IRI = URIRef(experimentIRI + \"_width_b2_scalar_measurement_datum\")\n",
    "  g.add((b2IRI, a, obo.IAO_0000032))\n",
    "  g.add((b2IRI, obo.OBI_0001938, b2IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, b2IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, b2IRI)) # preMeasuring process has specified output b2\n",
    "  g.add((b2IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b2IRI_quality = URIRef(experimentIRI + \"_width_b2\")\n",
    "  g.add((b2IRI_quality, a, base.OriginalWidth)) # Original Width used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((b2IRI_quality, obo.IAO_0000417, b2IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, b2IRI_quality))\n",
    "\n",
    "  # b3\n",
    "  b3IRI_value_specification = URIRef(experimentIRI + \"_width_b3_value_specification\")\n",
    "  g.add((b3IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((b3IRI_value_specification, obo.OBI_0001937, Literal(b3, datatype=XSD.float)))\n",
    "  g.add((b3IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((b3IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b3IRI = URIRef(experimentIRI + \"_width_b3_scalar_measurement_datum\")\n",
    "  g.add((b3IRI, a, obo.IAO_0000032))\n",
    "  g.add((b3IRI, obo.OBI_0001938, b3IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, b3IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, b3IRI)) # preMeasuring process has specified output b3\n",
    "  g.add((b3IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  b3IRI_quality = URIRef(experimentIRI + \"_width_b3\")\n",
    "  g.add((b3IRI_quality, a, base.OriginalWidth)) # Original Width used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((b3IRI_quality, obo.IAO_0000417, b3IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, b3IRI_quality))\n",
    "\n",
    "  # s1\n",
    "  s1IRI_value_specification = URIRef(experimentIRI + \"_crossSectionArea_s1_value_specification\")\n",
    "  g.add((s1IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((s1IRI_value_specification, obo.OBI_0001937, Literal(s1, datatype=XSD.float)))\n",
    "  g.add((s1IRI_value_specification, obo.IAO_0000039, unit.MilliM2))\n",
    "  g.add((s1IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s1IRI = URIRef(experimentIRI + \"_crossSectionArea_s1_scalar_measurement_datum\")\n",
    "  g.add((s1IRI, a, obo.IAO_0000032))\n",
    "  g.add((s1IRI, obo.OBI_0001938, s1IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, s1IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, s1IRI)) # preMeasuring process has specified output s1\n",
    "  g.add((s1IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s1IRI_quality = URIRef(experimentIRI + \"_crossSectionArea_s1\")\n",
    "  g.add((s1IRI_quality, a, base.CrossSectionArea)) # Cross Section Area (tto) used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((s1IRI_quality, obo.IAO_0000417, s1IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, s1IRI_quality))\n",
    "\n",
    "  # s2\n",
    "  s2IRI_value_specification = URIRef(experimentIRI + \"_crossSectionArea_s2_value_specification\")\n",
    "  g.add((s2IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((s2IRI_value_specification, obo.OBI_0001937, Literal(s2, datatype=XSD.float)))\n",
    "  g.add((s2IRI_value_specification, obo.IAO_0000039, unit.MilliM2))\n",
    "  g.add((s2IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s2IRI = URIRef(experimentIRI + \"_crossSectionArea_s2_scalar_measurement_datum\")\n",
    "  g.add((s2IRI, a, obo.IAO_0000032))\n",
    "  g.add((s2IRI, obo.OBI_0001938, s2IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, s2IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, s2IRI)) # preMeasuring process has specified output s2\n",
    "  g.add((s2IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s2IRI_quality = URIRef(experimentIRI + \"_crossSectionArea_s2\")\n",
    "  g.add((s2IRI_quality, a, base.CrossSectionArea)) # Cross Section Area (tto) used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((s2IRI_quality, obo.IAO_0000417, s2IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, s2IRI_quality))\n",
    "\n",
    "  # s3\n",
    "  s3IRI_value_specification = URIRef(experimentIRI + \"_crossSectionArea_s3_value_specification\")\n",
    "  g.add((s3IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((s3IRI_value_specification, obo.OBI_0001937, Literal(s3, datatype=XSD.float)))\n",
    "  g.add((s3IRI_value_specification, obo.IAO_0000039, unit.MilliM2))\n",
    "  g.add((s3IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s3IRI = URIRef(experimentIRI + \"_crossSectionArea_s3_scalar_measurement_datum\")\n",
    "  g.add((s3IRI, a, obo.IAO_0000032))\n",
    "  g.add((s3IRI, obo.OBI_0001938, s3IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, s3IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, s3IRI)) # preMeasuring process has specified output s3\n",
    "  g.add((s3IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s3IRI_quality = URIRef(experimentIRI + \"_crossSectionArea_s3\")\n",
    "  g.add((s3IRI_quality, a, base.CrossSectionArea)) # Cross Section Area (tto) used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((s3IRI_quality, obo.IAO_0000417, s3IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, s3IRI_quality))\n",
    "\n",
    "  # S0\n",
    "  s0IRI_value_specification = URIRef(experimentIRI + \"_crossSectionArea_s0_value_specification\")\n",
    "  g.add((s0IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((s0IRI_value_specification, obo.OBI_0001937, Literal(S0, datatype=XSD.float)))\n",
    "  g.add((s0IRI_value_specification, obo.IAO_0000039, unit.MilliM2))\n",
    "  g.add((s0IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s0IRI = URIRef(experimentIRI + \"_crossSectionArea_s0_scalar_measurement_datum\")\n",
    "  g.add((s0IRI, a, obo.IAO_0000032))\n",
    "  g.add((s0IRI, obo.OBI_0001938, s0IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, s0IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, s0IRI)) # preMeasuring process has specified output S0\n",
    "  g.add((s0IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  s0IRI_quality = URIRef(experimentIRI + \"_crossSectionArea_s0\")\n",
    "  g.add((s0IRI_quality, a, base.CrossSectionArea)) # Cross Section Area (tto) used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((s0IRI_quality, obo.IAO_0000417, s0IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, s0IRI_quality))\n",
    "\n",
    "  # L0\n",
    "  L0IRI_value_specification = URIRef(experimentIRI + \"_originalGaugeLength_L0_value_specification\")\n",
    "  g.add((L0IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((L0IRI_value_specification, obo.OBI_0001937, Literal(L0, datatype=XSD.float)))\n",
    "  g.add((L0IRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((L0IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  L0IRI = URIRef(experimentIRI + \"_originalGaugeLength_L0_scalar_measurement_datum\")\n",
    "  g.add((L0IRI, a, obo.IAO_0000032))\n",
    "  g.add((L0IRI, obo.OBI_0001938, L0IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, L0IRI))\n",
    "  g.add((preMeasuringIRI, obo.OBI_0000299, L0IRI)) # preMeasuring process has specified output L0\n",
    "  g.add((L0IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  L0IRI_quality = URIRef(experimentIRI + \"_originalGaugeLength_L0\")\n",
    "  g.add((L0IRI_quality, a, base.OriginalGaugeLength)) # Original Gauge Length used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((L0IRI_quality, obo.IAO_0000417, L0IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, L0IRI_quality))\n",
    "\n",
    "  # Lu\n",
    "  LuIRI_value_specification = URIRef(experimentIRI + \"_finalGaugeLengthAfterFracture_Lu_value_specification\")\n",
    "  g.add((LuIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((LuIRI_value_specification, obo.OBI_0001937, Literal(Lu, datatype=XSD.float)))\n",
    "  g.add((LuIRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((LuIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  LuIRI = URIRef(experimentIRI + \"_finalGaugeLengthAfterFracture_Lu_scalar_measurement_datum\")\n",
    "  g.add((LuIRI, a, obo.IAO_0000032))\n",
    "  g.add((LuIRI, obo.OBI_0001938, LuIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, LuIRI))\n",
    "  g.add((postMeasuringIRI, obo.OBI_0000299, LuIRI)) # postMeasuring process has specified output Lu\n",
    "  g.add((LuIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  LuIRI_quality = URIRef(experimentIRI + \"_finalGaugeLengthAfterFracture_Lu\")\n",
    "  g.add((LuIRI_quality, a, base.FinalGaugeLengthAfterFracture)) # Final Gauge Length After Fracture used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((LuIRI_quality, obo.IAO_0000417, LuIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, LuIRI_quality))\n",
    "\n",
    "  # au\n",
    "  auIRI_value_specification = URIRef(experimentIRI + \"_thicknessAfterFracture_au_value_specification\")\n",
    "  g.add((auIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((auIRI_value_specification, obo.OBI_0001937, Literal(au, datatype=XSD.float)))\n",
    "  g.add((auIRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((auIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  auIRI = URIRef(experimentIRI + \"_thicknessAfterFracture_au_scalar_measurement_datum\")\n",
    "  g.add((auIRI, a, obo.IAO_0000032))\n",
    "  g.add((auIRI, obo.OBI_0001938, auIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, auIRI))\n",
    "  g.add((postMeasuringIRI, obo.OBI_0000299, auIRI)) # postMeasuring process has specified output au\n",
    "  g.add((auIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  auIRI_quality = URIRef(experimentIRI + \"_thicknessAfterFracture_au\")\n",
    "  g.add((auIRI_quality, a, base.ThicknessAfterFracture)) # Thickness After Fracture used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((auIRI_quality, obo.IAO_0000417, auIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, auIRI_quality))\n",
    "\n",
    "  # bu\n",
    "  buIRI_value_specification = URIRef(experimentIRI + \"_widthAfterFracture_bu_value_specification\")\n",
    "  g.add((buIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((buIRI_value_specification, obo.OBI_0001937, Literal(bu, datatype=XSD.float)))\n",
    "  g.add((buIRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((buIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  buIRI = URIRef(experimentIRI + \"_widthAfterFracture_bu_scalar_measurement_datum\")\n",
    "  g.add((buIRI, a, obo.IAO_0000032))\n",
    "  g.add((buIRI, obo.OBI_0001938, buIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, buIRI))\n",
    "  g.add((postMeasuringIRI, obo.OBI_0000299, buIRI)) # postMeasuring process has specified output bu\n",
    "  g.add((buIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  buIRI_quality = URIRef(experimentIRI + \"_widthAfterFracture_bu\")\n",
    "  g.add((buIRI_quality, a, base.WidthAfterFracture)) # Width After Fracture used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((buIRI_quality, obo.IAO_0000417, buIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, buIRI_quality))\n",
    "\n",
    "  # Su\n",
    "  SuIRI_value_specification = URIRef(experimentIRI + \"_crossSectionArea_Su_value_specification\")\n",
    "  g.add((SuIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((SuIRI_value_specification, obo.OBI_0001937, Literal(Su, datatype=XSD.float)))\n",
    "  g.add((SuIRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "  g.add((SuIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  SuIRI = URIRef(experimentIRI + \"_crossSectionArea_Su_scalar_measurement_datum\")\n",
    "  g.add((SuIRI, a, obo.IAO_0000032))\n",
    "  g.add((SuIRI, obo.OBI_0001938, SuIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, SuIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, SuIRI)) # Analysis process has specified output Su, since Su is calculated within this process\n",
    "  g.add((SuIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  SuIRI_quality = URIRef(experimentIRI + \"_crossSectionArea_Su\")\n",
    "  g.add((SuIRI_quality, a, base.CrossSectionArea)) # Cross Section Area (tto) used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((SuIRI_quality, obo.IAO_0000417, SuIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, SuIRI_quality))\n",
    "\n",
    "  # The next section contains some secondary data.\n",
    "\n",
    "  # Rp02\n",
    "  Rp02IRI_value_specification = URIRef(experimentIRI + \"_proofStrength_Rp02_value_specification\")\n",
    "  g.add((Rp02IRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((Rp02IRI_value_specification, obo.OBI_0001937, Literal(Rp02, datatype=XSD.float)))\n",
    "  g.add((Rp02IRI_value_specification, obo.IAO_0000039, unit.MegaPa))\n",
    "  g.add((Rp02IRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  Rp02IRI = URIRef(experimentIRI + \"_proofStrength_Rp02_scalar_measurement_datum\")\n",
    "  g.add((Rp02IRI, a, obo.IAO_0000032))\n",
    "  g.add((Rp02IRI, obo.OBI_0001938, Rp02IRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, Rp02IRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, Rp02IRI)) # Analysis process has specified output Rp02, since it is calculated / computed within this process\n",
    "  g.add((Rp02IRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  Rp02IRI_quality = URIRef(experimentIRI + \"_proofStrength_Rp02\")\n",
    "  g.add((Rp02IRI_quality, a, base.Rp02)) # Rp02 used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((Rp02IRI_quality, obo.IAO_0000417, Rp02IRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, Rp02IRI_quality))\n",
    "\n",
    "  # ReH\n",
    "  ReHIRI_value_specification = URIRef(experimentIRI + \"_upperYieldStrength_ReH_value_specification\")\n",
    "  g.add((ReHIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((ReHIRI_value_specification, obo.OBI_0001937, Literal(ReH, datatype=XSD.float)))\n",
    "  g.add((ReHIRI_value_specification, obo.IAO_0000039, unit.MegaPa))\n",
    "  g.add((ReHIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  ReHIRI = URIRef(experimentIRI + \"_upperYieldStrength_ReH_scalar_measurement_datum\")\n",
    "  g.add((ReHIRI, a, obo.IAO_0000032))\n",
    "  g.add((ReHIRI, obo.OBI_0001938, ReHIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, ReHIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, ReHIRI)) # Analysis process has specified output ReH, since it is calculated / computed within this process\n",
    "  g.add((ReHIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  ReHIRI_quality = URIRef(experimentIRI + \"_upperYieldStrength_ReH\")\n",
    "  g.add((ReHIRI_quality, a, base.UpperYieldStrength)) # Upper Yield Strength used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((ReHIRI_quality, obo.IAO_0000417, ReHIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, ReHIRI_quality))\n",
    "\n",
    "  # Fm\n",
    "  FmIRI_value_specification = URIRef(experimentIRI + \"_maximumForce_Fm_value_specification\")\n",
    "  g.add((FmIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((FmIRI_value_specification, obo.OBI_0001937, Literal(Fm, datatype=XSD.float)))\n",
    "  g.add((FmIRI_value_specification, obo.IAO_0000039, unit.kiloN))\n",
    "  g.add((FmIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  FmIRI = URIRef(experimentIRI + \"_maximumForce_Fm_scalar_measurement_datum\")\n",
    "  g.add((FmIRI, a, obo.IAO_0000032))\n",
    "  g.add((FmIRI, obo.OBI_0001938, FmIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, FmIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, FmIRI)) # Analysis process has specified output Fm, since it is calculated / computed within this process\n",
    "  g.add((FmIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  FmIRI_quality = URIRef(experimentIRI + \"_maximumForce_Fm\")\n",
    "  g.add((FmIRI_quality, a, base.MaximumForce)) # Maximum Force used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((FmIRI_quality, obo.IAO_0000417, FmIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, FmIRI_quality))\n",
    "\n",
    "  # Rm\n",
    "  RmIRI_value_specification = URIRef(experimentIRI + \"_tensileStrength_Rm_value_specification\")\n",
    "  g.add((RmIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((RmIRI_value_specification, obo.OBI_0001937, Literal(Rm, datatype=XSD.float)))\n",
    "  g.add((RmIRI_value_specification, obo.IAO_0000039, unit.MegaPa))\n",
    "  g.add((RmIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  RmIRI = URIRef(experimentIRI + \"_tensileStrength_Rm_scalar_measurement_datum\")\n",
    "  g.add((RmIRI, a, obo.IAO_0000032))\n",
    "  g.add((RmIRI, obo.OBI_0001938, RmIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, RmIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, RmIRI)) # Analysis process has specified output Rm, since it is calculated / computed within this process\n",
    "  g.add((RmIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  RmIRI_quality = URIRef(experimentIRI + \"_tensileStrength_Rm\")\n",
    "  g.add((RmIRI_quality, a, base.TensileStrength)) # Tensile Strength used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((RmIRI_quality, obo.IAO_0000417, RmIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, RmIRI_quality))\n",
    "\n",
    "  # E\n",
    "  EIRI_value_specification = URIRef(experimentIRI + \"_modulusOfElasticity_E_value_specification\")\n",
    "  g.add((EIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((EIRI_value_specification, obo.OBI_0001937, Literal(E, datatype=XSD.float)))\n",
    "  g.add((EIRI_value_specification, obo.IAO_0000039, unit.GigaPa))\n",
    "  g.add((EIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  EIRI = URIRef(experimentIRI + \"_modulusOfElasticity_E_scalar_measurement_datum\")\n",
    "  g.add((EIRI, a, obo.IAO_0000032))\n",
    "  g.add((EIRI, obo.OBI_0001938, EIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, EIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, EIRI)) # Analysis process has specified output E, since it is calculated / computed within this process\n",
    "  g.add((EIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  EIRI_quality = URIRef(experimentIRI + \"_modulusOfElasticity_E\")\n",
    "  g.add((EIRI_quality, a, base.ModulusOfElasticity)) # Modulus Of Elasticity (tto) used as subclass of pmdco:Elastic Modulus (instead, pmdco.quality could be used)\n",
    "  g.add((EIRI_quality, obo.IAO_0000417, EIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, EIRI_quality))\n",
    "\n",
    "  # Slope of the elastic part\n",
    "  slopeElasticPartIRI_value_specification = URIRef(experimentIRI + \"_slopeOfTheElasticPart_me_value_specification\")\n",
    "  g.add((slopeElasticPartIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((slopeElasticPartIRI_value_specification, obo.OBI_0001937, Literal(E, datatype=XSD.float)))\n",
    "  g.add((slopeElasticPartIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  slopeElasticPartIRI = URIRef(experimentIRI + \"_slopeOfTheElasticPart_me_scalar_measurement_datum\")\n",
    "  g.add((slopeElasticPartIRI, a, obo.IAO_0000032))\n",
    "  g.add((slopeElasticPartIRI, obo.OBI_0001938, slopeElasticPartIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, slopeElasticPartIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, slopeElasticPartIRI)) # Analysis process has specified output slope of the elastic part, since it is calculated / computed within this process\n",
    "  g.add((slopeElasticPartIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  slopeElasticPartIRI_quality = URIRef(experimentIRI + \"_slopeOfTheElasticPart_me\")\n",
    "  g.add((slopeElasticPartIRI_quality, a, base.SlopeOfTheElasticPart)) # Slope Of The Elastic Part used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((slopeElasticPartIRI_quality, obo.IAO_0000417, slopeElasticPartIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, slopeElasticPartIRI_quality))\n",
    "\n",
    "  # A\n",
    "  AIRI_value_specification = URIRef(experimentIRI + \"_percentageElongationAfterFracture_A_value_specification\")\n",
    "  g.add((AIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((AIRI_value_specification, obo.OBI_0001937, Literal(A, datatype=XSD.float)))\n",
    "  g.add((AIRI_value_specification, obo.IAO_0000039, unit.PERCENT))\n",
    "  g.add((AIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  AIRI = URIRef(experimentIRI + \"_percentageElongationAfterFracture_A_scalar_measurement_datum\")\n",
    "  g.add((AIRI, a, obo.IAO_0000032))\n",
    "  g.add((AIRI, obo.OBI_0001938, AIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, AIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, AIRI)) # Analysis process has specified output A, since it is calculated / computed within this process\n",
    "  g.add((AIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  AIRI_quality = URIRef(experimentIRI + \"_percentageElongationAfterFracture_A\")\n",
    "  g.add((AIRI_quality, a, base.PercentageElongationAfterFracture)) # Percentage Elongation After Fracture used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((AIRI_quality, obo.IAO_0000417, AIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, AIRI_quality))\n",
    "\n",
    "  # Z\n",
    "  ZIRI_value_specification = URIRef(experimentIRI + \"_percentageReductionOfArea_Z_value_specification\")\n",
    "  g.add((ZIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((ZIRI_value_specification, obo.OBI_0001937, Literal(Z, datatype=XSD.float)))\n",
    "  g.add((ZIRI_value_specification, obo.IAO_0000039, unit.PERCENT))\n",
    "  g.add((ZIRI_value_specification, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  ZIRI = URIRef(experimentIRI + \"_percentageReductionOfArea_Z_scalar_measurement_datum\")\n",
    "  g.add((ZIRI, a, obo.IAO_0000032))\n",
    "  g.add((ZIRI, obo.OBI_0001938, ZIRI_value_specification))\n",
    "  g.add((processIRI, obo.OBI_0000299, ZIRI))\n",
    "  g.add((analysisIRI, obo.OBI_0000299, ZIRI)) # Analysis process has specified output Z, since it is calculated / computed within this process\n",
    "  g.add((ZIRI, obo.IAO_0000136, testpieceIRI))\n",
    "\n",
    "  ZIRI_quality = URIRef(experimentIRI + \"_percentageReductionOfArea_Z\")\n",
    "  g.add((ZIRI_quality, a, base.PercentageReductionOfArea)) # Percentage Reduction Of Area used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((ZIRI_quality, obo.IAO_0000417, ZIRI))\n",
    "  g.add((testpieceIRI, obo.RO_0000086, ZIRI_quality))\n",
    "\n",
    "  # The next section contains metadata concerning the process itself.\n",
    "\n",
    "  # Environmental Temperature\n",
    "  temperatureIRI_value_specification = URIRef(experimentIRI + \"_environmentalTemperature_value_specification\")\n",
    "  g.add((temperatureIRI_value_specification, a, obo.OBI_0001931))\n",
    "  g.add((temperatureIRI_value_specification, obo.OBI_0001937, Literal(environmentalTemperature, datatype=XSD.float)))\n",
    "  g.add((temperatureIRI_value_specification, obo.IAO_0000039, unit.DEG_C))\n",
    "\n",
    "  temperatureIRI = URIRef(experimentIRI + \"_environmentalTemperature_scalar_measurement_datum\")\n",
    "  g.add((temperatureIRI, a, obo.IAO_0000032)) # is scalar measurement datum\n",
    "  g.add((temperatureIRI, obo.OBI_0001938, temperatureIRI_value_specification)) # temperatureIRI obi:has value specification temperatureIRI_value_specification\n",
    "  g.add((processIRI, obo.RO_0000057, temperatureIRI)) # Tensile Test Process ro:has participant Environmental Temperature scalar measurement datum\n",
    "\n",
    "  temperatureIRI_quality = URIRef(experimentIRI + \"_environmentalTemperature\")\n",
    "  g.add((temperatureIRI_quality, a, base.EnvironmentalTemperature)) # Environmental Temperature (tto) used as subclass of pmdco:Temperature (instead, pmdco.quality could be used)\n",
    "  g.add((temperatureIRI_quality, obo.IAO_0000417, temperatureIRI)) # temperatureIRI_quality iao:is quality measured as temperatureIRI\n",
    "  g.add((temperatureIRI_value_specification, obo.OBI_0001927, temperatureIRI_quality)) # temperatureIRI_value_specification obi:specifies value of temperatureIRI_quality\n",
    "  \n",
    "  dateIRI = URIRef(experimentIRI + \"_date\")\n",
    "  g.add((dateIRI, a, time.Instant)) # is a time:instant (Definition: A temporal entity with zero extent or duration)\n",
    "  g.add((dateIRI, time.inXSDDate, Literal(date, datatype=XSD.date))) # Date is given as xsd:date\n",
    "  g.add((processIRI, time.hasTime, dateIRI)) # Process has Time date\n",
    "\n",
    "  # Project and Funding information\n",
    "  projectIRI = URIRef(experimentIRI + \"_project\")\n",
    "  g.add((projectIRI, a, pmdco.PMD_0000909)) # PMD_0000909 is a pmdco:Project as subclass of iao:planned process\n",
    "  g.add((projectIRI, obo.BFO_0000051, processIRI)) # Project bfo:has part Tensile Test Process\n",
    "\n",
    "  projectIdentifierIRI = URIRef(experimentIRI + \"_project_ID\")\n",
    "  g.add((projectIdentifierIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((projectIdentifierIRI, dct.identifier, Literal(project, datatype=XSD.string)))\n",
    "  g.add((projectIdentifierIRI, obo.IAO_0000219, projectIRI)) # Project identifier iao:denotes Project\n",
    "\n",
    "  FunderRoleIRI = URIRef(experimentIRI + \"funder_role\")\n",
    "  g.add((FunderRoleIRI, a, base.FunderRole)) # is a tto:FunderRole as subclass of bfo:role\n",
    "  g.add((FunderRoleIRI, obo.BFO_0000054, projectIRI)) # Funder Role is bfo:realized in Project\n",
    "\n",
    "  BMBF_IRI = URIRef(experimentIRI + \"_funder\")\n",
    "  g.add((BMBF_IRI, a, pmdco.PMD_0000879)) # PMD_0000879 is a pmdco:Organization\n",
    "  g.add((BMBF_IRI, obo.RO_0000087, FunderRoleIRI)) # Funder (BMBF) ro:has role Funder Role\n",
    "  g.add((projectIRI, obo.RO_0002608, BMBF_IRI)) # Project ro:process has causal agent Funder (BMBF)\n",
    "\n",
    "  BMBFNameIRI = URIRef(experimentIRI + \"_funder_name\")\n",
    "  g.add((BMBFNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((BMBFNameIRI, dct.identifier, Literal(\"Bundesministerium für Bildung und Forschung (BMBF)@de\", datatype=XSD.string)))\n",
    "  g.add((BMBFNameIRI, dct.identifier, Literal(\"Federal Ministry of Education and Research@en\", datatype=XSD.string)))\n",
    "  g.add((BMBFNameIRI, obo.IAO_0000219, BMBF_IRI)) # BMBF Name (identifier) iao:denotes Funder (BMBF)\n",
    "\n",
    "  BMBFIdentifierNumberIRI = URIRef(experimentIRI + \"_funder_identifier_number\")\n",
    "  g.add((BMBFIdentifierNumberIRI, a, obo.IAO_0000578)) # is an iao:centrally registered identifier\n",
    "  g.add((BMBFIdentifierNumberIRI, dct.identifier, Literal(\"Q492234\", datatype=XSD.string)))\n",
    "  g.add((BMBFIdentifierNumberIRI, obo.IAO_0000219, BMBF_IRI)) # BMBF Identifier Number iao:denotes Funder (BMBF)\n",
    "\n",
    "  fundingProjectIRI = URIRef(experimentIRI + \"_funding_project\")\n",
    "  g.add((fundingProjectIRI, a, pmdco.PMD_0000909)) # PMD_0000909 is a pmdco:Project as subclass of iao:planned process\n",
    "  g.add((fundingProjectIRI, obo.BFO_0000051, projectIRI)) # Funding Project bfo:has part Project\n",
    "\n",
    "  FundingProjectIdentifierIRI = URIRef(experimentIRI + \"_funding_project_ID\")\n",
    "  g.add((FundingProjectIdentifierIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((FundingProjectIdentifierIRI, dct.identifier, Literal(\"13XP5094\", datatype=XSD.string)))\n",
    "  g.add((FundingProjectIdentifierIRI, obo.IAO_0000219, fundingProjectIRI)) # Funding Project identifier iao:denotes Funding Project\n",
    "\n",
    "  # Operator\n",
    "  operatorRoleIRI = URIRef(experimentIRI + \"_operator_role\")\n",
    "  g.add((operatorRoleIRI, a, pmdco.PMD_0000873)) # PMD_0000873 is a pmdco:OperatorRole\n",
    "  g.add((operatorRoleIRI, obo.BFO_0000054, processIRI)) # Operator Role is bfo:realized in (tensile testing) process\n",
    "    \n",
    "  operatorIRI = URIRef(experimentIRI + \"_operator\")\n",
    "  g.add((operatorIRI, a, pmdco.PMD_0000872)) # PMD_0000872 is a pmdco:Operator\n",
    "  g.add((operatorIRI, obo.RO_0000087, operatorRoleIRI)) # Operator ro:has role Operator Role\n",
    "  g.add((processIRI, obo.RO_0002608, operatorIRI)) # Tensile Test Process ro:prcoess has causal agent Operator\n",
    "  g.add((operatorIRI, obo.RO_0002215, processIRI)) # Operator is ro:capable of Tensile Test Process\n",
    "\n",
    "  operatorNameIRI = URIRef(experimentIRI + \"_operator_name\")\n",
    "  g.add((operatorNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((operatorNameIRI, dct.identifier, Literal(operator, datatype=XSD.string)))\n",
    "  g.add((operatorNameIRI, obo.IAO_0000219, operatorIRI)) # Operator Name (identifier) iao:denotes Operator\n",
    "\n",
    "  # Test Standard\n",
    "  standardInformationIRI = URIRef(experimentIRI + \"_test_standard\")\n",
    "  g.add((standardInformationIRI, a, obo.IAO_0000300)) # is an iao:textual entity\n",
    "  g.add((standardInformationIRI, obo.OBI_0002815, Literal(standard, datatype=XSD.string))) # Test Standard Information obi:has representation (Datatype Property used for textual information)\n",
    "  g.add((standardInformationIRI, obo.IAO_0000136, processIRI)) # Test Standard Information Textual Entity iao:is about Tensile Test Process\n",
    "\n",
    "  # Note\n",
    "  noteIRI = URIRef(experimentIRI + \"_note\")\n",
    "  g.add((noteIRI, a, obo.IAO_0000300)) # is an iao:textual entity\n",
    "  g.add((noteIRI, obo.OBI_0002815, Literal(note, datatype=XSD.string))) # Note obi:has representation (Datatype Property used for textual information)\n",
    "  g.add((noteIRI, obo.IAO_0000136, processIRI)) # Note Textual Entity iao:is about Tensile Test Process\n",
    "\n",
    "  # The next section contains metadata on location, address, institute, etc.\n",
    "  # 'Static' data such as institution and location get a static URI (the same URI / instance for every process regarded)\n",
    "  # (there is only one of the explicitely specified institution and location that is referred to, respectively)\n",
    "  institutionRoleIRI = URIRef(experimentIRI + \"_institute_role\")\n",
    "  g.add((institutionRoleIRI, a, pmdco.PMD_0000599)) # PMD_0000599 is a pmdco:DepartmentRole\n",
    "  g.add((institutionRoleIRI, obo.BFO_0000054, processIRI)) # Institution Role is bfo:realized in (tensile testing) process\n",
    "    \n",
    "  institutionIRI = URIRef(experimentIRI + \"_institute\")\n",
    "  g.add((institutionIRI, a, pmdco.PMD_0000879)) # PMD_0000879 is a pmdco:Organization\n",
    "  g.add((institutionIRI, obo.RO_0000087, institutionRoleIRI)) # Institution ro:has role Institution Role\n",
    "  g.add((processIRI, obo.RO_0002608, institutionIRI)) # Tensile Test Process ro:prcoess has causal agent Institution\n",
    "\n",
    "  institutionNameIRI = URIRef(experimentIRI + \"_institute_BAM\")\n",
    "  g.add((institutionNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((institutionNameIRI, dct.identifier, Literal(institute, datatype=XSD.string)))\n",
    "  g.add((institutionNameIRI, obo.IAO_0000219, institutionIRI)) # Institution Name (identifier) iao:denotes Institution\n",
    "\n",
    "  addressIRI = URIRef(experimentIRI + \"_institute_BAM_address\")\n",
    "  g.add((addressIRI, a, obo.IAO_0000422)) # is an iao:postal address as subclass of textual entity\n",
    "  g.add((addressIRI, obo.OBI_0002815, Literal(f\"{address}\" + \" \" + f\"{location}\", datatype=XSD.string))) # Address obi:has representation \n",
    "  g.add((addressIRI, obo.IAO_0000136, institutionIRI)) # Address iao:is about institution\n",
    "\n",
    "  # The next section contains metadata concerning machines, components (processing nodes) used.\n",
    "  # 'Static' data such as manufacturers and serial numbers get a static URI (the same URI / instance for every process regarded)\n",
    "  # Caution: If several machines were used, the machineIRI will have to be changed:\n",
    "  # Then, it will have to contain the machine designation in the IRI (cf. e.g. institute)\n",
    "\n",
    "  # Tensile Testing Machine\n",
    "  machineFunctionIRI = URIRef(experimentIRI + \"_tensile_testing_machine_function\")\n",
    "  g.add((machineFunctionIRI, a, base.TensileTestingFunction)) # is a tto:tensile testing function\n",
    "  g.add((machineFunctionIRI, obo.BFO_0000054, processIRI)) # tensile testing function is bfo:realized in (tensile testing) process\n",
    "  g.add((machineFunctionIRI, obo.BFO_0000054, tensileTestISOIRI)) # tensile testing function is bfo:realized in ISO tensile testing process (subprocess)\n",
    "\n",
    "  machineIRI = URIRef(experimentIRI + \"_tensile_testing_machine\")\n",
    "  g.add((machineIRI, a, base.TensileTestingMachine)) # Machine is a tto:Tensile Testing Machine\n",
    "  g.add((machineIRI, obo.RO_0000085, machineFunctionIRI)) # Tensile Testing Machine ro:has function Tensile Testing Function\n",
    "  g.add((machineIRI, obo.RO_0002215, processIRI)) # Tensile Testing Machine is ro:capable of (tensile testing) process (can realize the process)\n",
    "  g.add((machineIRI, obo.RO_0002215, tensileTestISOIRI)) # Tensile Testing Machine is ro:capable of ISO tensile testing process (subprocess, can realize the process)\n",
    "  g.add((processIRI, obo.RO_0002608, machineIRI)) # Process (tensile testing) ro:process has causal agent Tensile Testing Machine\n",
    "  g.add((tensileTestISOIRI, obo.RO_0002608, machineIRI)) # ISO tensile testing process ro:process has causal agent Tensile Testing Machine  \n",
    "\n",
    "  machineNameIRI = URIRef(experimentIRI + \"_tensile_testing_machine_name\")\n",
    "  g.add((machineNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((machineNameIRI, dct.identifier, Literal(machineName, datatype=XSD.string)))\n",
    "  g.add((machineNameIRI, obo.IAO_0000219, machineIRI)) # Machine Name (identifier) iao:denotes Machine (Tensile Testing Machine)\n",
    "\n",
    "  machineManufacturerIRI = URIRef(experimentIRI + \"_machine_manufacturer\")\n",
    "  g.add((machineManufacturerIRI, a, pmdco.PMD_0000830)) # PMD_0000830 is a Manufacturer Company which is a subclass of Organization --> material entity\n",
    "  g.add((machineManufacturerIRI, dct.identifier, Literal(machineManufacturer, datatype=XSD.string)))\n",
    "  g.add((machineIRI, obo.OBI_0000304, machineManufacturerIRI)) # Tensile Testing Machine obi:is_manufactured_by Manufacturer Company\n",
    "\n",
    "  machineManufacturerRoleIRI = URIRef(experimentIRI + \"_machine_manufacturer_role\")\n",
    "  g.add((machineManufacturerRoleIRI, a, obo.OBI_0000571)) # is a Manufacturer Role which is a subclass of role --> realizable entity (in OBI)\n",
    "  g.add((machineManufacturerIRI, obo.RO_0000087, machineManufacturerRoleIRI)) # The Manufacturer ro:has role Manufacturer Role\n",
    "\n",
    "  machineTypeIRI = URIRef(experimentIRI + \"_tensile_testing_machine_type\")\n",
    "  g.add((machineTypeIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((machineTypeIRI, dct.identifier, Literal(machineType, datatype=XSD.string)))\n",
    "  g.add((machineTypeIRI, obo.IAO_0000219, machineIRI)) # Machine Type (identifier) iao:denotes Machine (Tensile Testing Machine)\n",
    "\n",
    "  machineSerialNumberIRI = URIRef(experimentIRI + \"_tensile_testing_machine_serial_number\")\n",
    "  g.add((machineSerialNumberIRI, a, obo.IAO_0000131)) # is an iao:serial number as subclass of iao:symbol --> iao:information content entity\n",
    "  g.add((machineSerialNumberIRI, dct.identifier, Literal(machineSerialNumber, datatype=XSD.string)))\n",
    "  g.add((machineSerialNumberIRI, obo.IAO_0000219, machineIRI)) # Machine Serial Number (symbol) iao:denotes Machine (Tensile Testing Machine)\n",
    "\n",
    "  machineStandardIRI = URIRef(experimentIRI + \"_tensile_testing_machine_standard\")\n",
    "  g.add((machineStandardIRI, a, base.DeviceSpecification)) # is a tto:DeviceSpecification as subclass of iao:directive information entity --> iao:information content entity\n",
    "  g.add((machineStandardIRI, dct.identifier, Literal(machineStandard, datatype=XSD.string)))\n",
    "  g.add((machineStandardIRI, obo.IAO_0000136, machineIRI)) # Machine Standard (symbol) iao:is about Machine (Tensile Testing Machine)\n",
    "\n",
    "  # Strain Rate\n",
    "  strainRateIRI_value_specification = URIRef(experimentIRI + \"_strain_rate_value_specification\")\n",
    "  g.add((strainRateIRI_value_specification, a, obo.OBI_0001931)) # Strain rate measurement value specification is a obi:scalar value specification\n",
    "  g.add((strainRateIRI_value_specification, obo.OBI_0001937, Literal(strainRate, datatype=XSD.float))) # strainRateIRI_value_specification has specified numeric value strainRate\n",
    "\n",
    "  strainRate_device_setting_IRI = URIRef(experimentIRI + \"_strain_rate_device_setting\")\n",
    "  g.add((strainRate_device_setting_IRI, a, obo.OBI_0000654)) # is a obi:device setting\n",
    "  g.add((strainRateIRI_value_specification, obo.OBI_0001927, strainRate_device_setting_IRI)) # strainRateIRI_value_specification obi:specifies value of strainRate device setting\n",
    "  g.add((machineIRI, obo.RO_0000086, strainRate_device_setting_IRI)) # Tensile Testing Machine ro:has quality strainRate device setting\n",
    "\n",
    "  strainRateQualityIRI = URIRef(experimentIRI + \"_strain_rate_quality\")\n",
    "  g.add((strainRateQualityIRI, a, base.StrainRate)) # is a tto:StrainRate as subclass of tto:TestingRate --> quality\n",
    "  g.add((strainRate_device_setting_IRI, obo.RO_0002566, strainRateQualityIRI)) # strainRate_device_setting ro:causally influences Strain Rate Quality\n",
    "  g.add((strainRateIRI_value_specification, obo.OBI_0001927, strainRateQualityIRI)) # strainRateIRI_value_specification obi:specifies value of Strain Rate Quality\n",
    "  g.add((machineIRI, obo.RO_0000086, strainRateQualityIRI)) # Tensile Testing Machine ro:has quality Strain Rate Quality\n",
    "\n",
    "  # Transition Point\n",
    "  transitionPointIRI_value_specification = URIRef(experimentIRI + \"_transition_point_value_specification\")\n",
    "  g.add((transitionPointIRI_value_specification, a, obo.OBI_0001931)) # Transition point measurement value specification is a obi:scalar value specification\n",
    "  g.add((transitionPointIRI_value_specification, obo.OBI_0001937, Literal(transitionPoint, datatype=XSD.float))) # transitionPointIRI_value_specification has specified numeric value transitionPoint\n",
    "  g.add((transitionPointIRI_value_specification, obo.IAO_0000039, unit.PERCENT)) # Transition point measurement value specification iao:has measurement unit label unit:PERCENT (QUDT)\n",
    "\n",
    "  transitionPoint_device_setting_IRI = URIRef(experimentIRI + \"_transition_point_device_setting\")\n",
    "  g.add((transitionPoint_device_setting_IRI, a, obo.OBI_0000654)) # is a obi:device setting\n",
    "  g.add((transitionPointIRI_value_specification, obo.OBI_0001927, transitionPoint_device_setting_IRI)) # transitionPointIRI_value_specification obi:specifies value of transitionPoint device setting\n",
    "  g.add((machineIRI, obo.RO_0000086, transitionPoint_device_setting_IRI)) # Tensile Testing Machine ro:has quality transitionPoint device setting\n",
    "\n",
    "  transitionPointQualityIRI = URIRef(experimentIRI + \"_strain_rate_quality\")\n",
    "  g.add((transitionPointQualityIRI, a, base.TransitionPoint)) # is a tto:TransitionPoint --> quality\n",
    "  g.add((transitionPoint_device_setting_IRI, obo.RO_0002566, transitionPointQualityIRI)) # transitionPoint_device_setting ro:causally influences Transition Point Quality\n",
    "  g.add((transitionPointIRI_value_specification, obo.OBI_0001927, transitionPointQualityIRI)) # transitionPointIRI_value_specification obi:specifies value of Transition Point Quality\n",
    "  g.add((machineIRI, obo.RO_0000086, transitionPointQualityIRI)) # Tensile Testing Machine ro:has quality Transition Point Quality\n",
    "\n",
    "  # Extensometer\n",
    "  extensometerFunctionIRI = URIRef(experimentIRI + \"_extensometer_function\")\n",
    "  g.add((extensometerFunctionIRI, a, obo.OBI_0000453)) # is a obi:measure function\n",
    "  g.add((extensometerFunctionIRI, obo.BFO_0000054, processIRI)) # measure function (of extensometer) is bfo:realized in (tensile testing) process\n",
    "  g.add((extensometerFunctionIRI, obo.BFO_0000054, tensileTestISOIRI)) # extensometer function is bfo:realized in ISO tensile testing process (subprocess)\n",
    "\n",
    "  extensometerIRI = URIRef(experimentIRI + \"_extensometer\")\n",
    "  g.add((extensometerIRI, a, pmdco.PMD_0000636)) # PMD_0000636 is a pmdco:Extensometer\n",
    "  g.add((extensometerIRI, obo.RO_0000085, extensometerFunctionIRI)) # Extensometer ro:has function extensometer function\n",
    "  g.add((machineIRI, obo.RO_0002180, extensometerIRI)) # Tensile Testing Machine ro:has component Extensometer\n",
    "\n",
    "  extensometerNameIRI = URIRef(experimentIRI + \"_extensometer_name\")\n",
    "  g.add((extensometerNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((extensometerNameIRI, dct.identifier, Literal(extensometerName, datatype=XSD.string)))\n",
    "  g.add((extensometerNameIRI, obo.IAO_0000219, extensometerIRI)) # Extensometer Name (identifier) iao:denotes Extensometer\n",
    "\n",
    "  extensometerSerialNumberIRI = URIRef(experimentIRI + \"_extensometer_serial_number\")\n",
    "  g.add((extensometerSerialNumberIRI, a, obo.IAO_0000131)) # is an iao:serial number as subclass of iao:symbol --> iao:information content entity\n",
    "  g.add((extensometerSerialNumberIRI, dct.identifier, Literal(extensometerSerialNumber, datatype=XSD.string)))\n",
    "  g.add((extensometerSerialNumberIRI, obo.IAO_0000219, extensometerIRI)) # Extensometer Serial Number (symbol) iao:denotes Extensometer\n",
    "\n",
    "  extensometerStandardIRI = URIRef(experimentIRI + \"_extensometer_standard\")\n",
    "  g.add((extensometerStandardIRI, a, base.DeviceSpecification)) # is a tto:DeviceSpecification as subclass of iao:directive information entity --> iao:information content entity\n",
    "  g.add((extensometerStandardIRI, dct.identifier, Literal(extensometerStandard, datatype=XSD.string)))\n",
    "  g.add((extensometerStandardIRI, obo.IAO_0000136, extensometerIRI)) # Extensometer Standard (symbol) iao:is about Extensometer\n",
    "\n",
    "  # Extensometer Gauge Length\n",
    "  extensometerGaugeLengthIRI_value_specification = URIRef(experimentIRI + \"_extensometerGaugeLength_value_specification\")\n",
    "  g.add((extensometerGaugeLengthIRI_value_specification, a, obo.OBI_0001931)) # is an obi:scalar value specification\n",
    "  g.add((extensometerGaugeLengthIRI_value_specification, obo.OBI_0001937, Literal(extensometerGaugeLength, datatype=XSD.float)))\n",
    "  g.add((extensometerGaugeLengthIRI_value_specification, obo.IAO_0000039, unit.MilliM))\n",
    "\n",
    "  extensometerGaugeLengthIRI = URIRef(experimentIRI + \"_extensometerGaugeLength_scalar_measurement_datum\")\n",
    "  g.add((extensometerGaugeLengthIRI, a, obo.IAO_0000032))\n",
    "  g.add((extensometerGaugeLengthIRI, obo.OBI_0001938, extensometerGaugeLengthIRI_value_specification))\n",
    "\n",
    "  extensometerGaugeLengthIRI_quality = URIRef(experimentIRI + \"_extensometer_gauge_length\")\n",
    "  g.add((extensometerGaugeLengthIRI_quality, a, base.ExtensometerGaugeLength)) # Extensometer Gauge Length used as subclass of pmdco:quality (instead, pmdco.quality could be used)\n",
    "  g.add((extensometerGaugeLengthIRI_quality, obo.IAO_0000417, extensometerGaugeLengthIRI))\n",
    "  g.add((extensometerGaugeLengthIRI_value_specification, obo.OBI_0001927, extensometerGaugeLengthIRI_quality))\n",
    "  g.add((extensometerIRI, obo.RO_0000086, extensometerGaugeLengthIRI_quality)) # Extensometer ro:has quality extensometerGaugeLengthIRI_quality\n",
    "\n",
    "  # Load Cell\n",
    "  loadCellFunctionIRI = URIRef(experimentIRI + \"_load_cell_function\")\n",
    "  g.add((loadCellFunctionIRI, a, obo.OBI_0000453)) # is a obi:measure function\n",
    "  g.add((loadCellFunctionIRI, obo.BFO_0000054, processIRI)) # measure function (of load cell) is bfo:realized in (tensile testing) process\n",
    "  g.add((loadCellFunctionIRI, obo.BFO_0000054, tensileTestISOIRI)) # load cell function is bfo:realized in ISO tensile testing process (subprocess)\n",
    "\n",
    "  loadCellIRI = URIRef(experimentIRI + \"_load_cell\")\n",
    "  g.add((loadCellIRI, a, pmdco.PMD_0000820)) # PMD_0000820 is a pmdco:LoadCell as subclass of pmdco:ForceMeasuringSystem\n",
    "  g.add((loadCellIRI, obo.RO_0000085, loadCellFunctionIRI)) # Load cell ro:has function load cell function\n",
    "  g.add((machineIRI, obo.RO_0002180, loadCellIRI)) # Tensile Testing Machine ro:has component Load cell\n",
    "\n",
    "  loadCellMaxForce_value_specification = URIRef(experimentIRI + \"_loadCellMaxForce_value_specification\")\n",
    "  g.add((loadCellMaxForce_value_specification, a, obo.OBI_0001931)) # is an obi:scalar value specification\n",
    "  g.add((loadCellMaxForce_value_specification, obo.OBI_0001937, Literal(loadCellMaxForce, datatype=XSD.float)))\n",
    "  g.add((loadCellMaxForce_value_specification, obo.IAO_0000039, unit.N))\n",
    "\n",
    "  loadCellMaxForceQualityIRI = URIRef(experimentIRI + \"_load_cell_max_force_quality\")\n",
    "  g.add((loadCellMaxForceQualityIRI, a, obo.OBI_0000654)) # is a obi:device setting\n",
    "  g.add((loadCellMaxForce_value_specification, obo.OBI_0001927, loadCellMaxForceQualityIRI)) # loadCellMaxForce_value_specification obi:specifies value of loadCellMaxForceQuality (device setting)\n",
    "  g.add((loadCellIRI, obo.RO_0000086, loadCellMaxForceQualityIRI)) # Load cell ro:has quality loadCellMaxForceQuality (device setting)\n",
    "\n",
    "  # Micrometer Gauge\n",
    "  micrometerGaugeFunctionIRI = URIRef(experimentIRI + \"_micrometer_gauge_function\")\n",
    "  g.add((micrometerGaugeFunctionIRI, a, obo.OBI_0000453)) # is a obi:measure function\n",
    "  g.add((micrometerGaugeFunctionIRI, obo.BFO_0000054, processIRI)) # measure function (of micrometer gauge) is bfo:realized in (tensile testing) process\n",
    "  g.add((micrometerGaugeFunctionIRI, obo.BFO_0000054, preMeasuringIRI)) # measure function (of micrometer gauge) is bfo:realized in preMeasuring process (subprocess)\n",
    "  g.add((micrometerGaugeFunctionIRI, obo.BFO_0000054, postMeasuringIRI)) # measure function (of micrometer gauge) is bfo:realized in postMeasuring process (subprocess)\n",
    "\n",
    "  micrometerGaugeIRI = URIRef(experimentIRI + \"_micrometer_gauge\")\n",
    "  g.add((micrometerGaugeIRI, a, pmdco.PMD_0000854)) # PMD_0000854 is a pmdco:Micrometer Gauge\n",
    "  g.add((micrometerGaugeIRI, obo.RO_0000085, micrometerGaugeFunctionIRI)) # Micrometer Gauge ro:has function measure function (of micrometer gauge)\n",
    "  g.add((micrometerGaugeIRI, obo.RO_0002215, preMeasuringIRI)) # Micrometer Gauge is ro:capable of preMeasuring process (can realize the process)\n",
    "  g.add((micrometerGaugeIRI, obo.RO_0002215, postMeasuringIRI)) # Micrometer Gauge is ro:capable of postMeasuring process (can realize the process)\n",
    "  g.add((processIRI, obo.RO_0002608, micrometerGaugeIRI)) # Process (tensile testing) ro:process has causal agent Micrometer Gauge\n",
    "  g.add((preMeasuringIRI, obo.RO_0002608, micrometerGaugeIRI)) # preMeasuring process ro:process has causal agent Micrometer Gauge\n",
    "  g.add((postMeasuringIRI, obo.RO_0002608, micrometerGaugeIRI)) # postMeasuring process ro:process has causal agent Micrometer Gauge\n",
    "\n",
    "  micrometerGaugeManufacturerIRI = URIRef(experimentIRI + \"_micrometer_gauge_manufacturer\")\n",
    "  g.add((micrometerGaugeManufacturerIRI, a, pmdco.PMD_0000830)) # PMD_0000830 is a Manufacturer Company which is a subclass of Organization --> material entity\n",
    "  g.add((micrometerGaugeManufacturerIRI, dct.identifier, Literal(micrometerGaugeManufacturer, datatype=XSD.string)))\n",
    "  g.add((micrometerGaugeIRI, obo.OBI_0000304, micrometerGaugeManufacturerIRI)) # Micrometer Gauge obi:is_manufactured_by Manufacturer\n",
    "\n",
    "  # Caliper\n",
    "  caliperFunctionIRI = URIRef(experimentIRI + \"_caliper_function\")\n",
    "  g.add((caliperFunctionIRI, a, obo.OBI_0000453)) # is a obi:measure function\n",
    "  g.add((caliperFunctionIRI, obo.BFO_0000054, processIRI)) # measure function (of caliper) is bfo:realized in (tensile testing) process\n",
    "  g.add((caliperFunctionIRI, obo.BFO_0000054, preMeasuringIRI)) # measure function (of caliper) is bfo:realized in preMeasuring process (subprocess)\n",
    "  g.add((caliperFunctionIRI, obo.BFO_0000054, postMeasuringIRI)) # measure function (of caliper) is bfo:realized in postMeasuring process (subprocess)\n",
    "\n",
    "  caliperIRI = URIRef(experimentIRI + \"_caliper\")\n",
    "  g.add((caliperIRI, a, pmdco.PMD_0000544)) # PMD_0000544 is a pmdco:Caliper\n",
    "  g.add((caliperIRI, obo.RO_0000085, micrometerGaugeFunctionIRI)) # Caliper ro:has function measure function (of Caliper)\n",
    "  g.add((caliperIRI, obo.RO_0002215, preMeasuringIRI)) # Caliper is ro:capable of preMeasuring process (can realize the process)\n",
    "  g.add((caliperIRI, obo.RO_0002215, postMeasuringIRI)) # Caliper is ro:capable of postMeasuring process (can realize the process)\n",
    "  g.add((processIRI, obo.RO_0002608, caliperIRI)) # Process (tensile testing) ro:process has causal agent Caliper\n",
    "  g.add((preMeasuringIRI, obo.RO_0002608, caliperIRI)) # preMeasuring process ro:process has causal agent Caliper\n",
    "  g.add((postMeasuringIRI, obo.RO_0002608, caliperIRI)) # postMeasuring process ro:process has causal agent Caliper\n",
    "\n",
    "  caliperManufacturerIRI = URIRef(experimentIRI + \"_caliper_manufacturer\")\n",
    "  g.add((caliperManufacturerIRI, a, pmdco.PMD_0000830)) # PMD_0000830 is a Manufacturer Company which is a subclass of Organization --> material entity\n",
    "  g.add((caliperManufacturerIRI, dct.identifier, Literal(caliperManufacturer, datatype=XSD.string)))\n",
    "  g.add((caliperIRI, obo.OBI_0000304, caliperManufacturerIRI)) # Caliper obi:is_manufactured_by Manufacturer\n",
    "\n",
    "  caliperSerialNumberIRI = URIRef(experimentIRI + \"_caliper_serial_number\")\n",
    "  g.add((caliperSerialNumberIRI, a, obo.IAO_0000131)) # is an iao:serial number as subclass of iao:symbol --> iao:information content entity\n",
    "  g.add((caliperSerialNumberIRI, dct.identifier, Literal(caliperSerialNumber, datatype=XSD.string)))\n",
    "  g.add((caliperSerialNumberIRI, obo.IAO_0000219, caliperIRI)) # Caliper Serial Number (symbol) iao:denotes Caliper\n",
    "\n",
    "  # Analysis Software Application\n",
    "  softwareApplicationIRI = URIRef(experimentIRI + \"_software_application\")\n",
    "  g.add((softwareApplicationIRI, a, obo.IAO_0000594)) # is an iao:software application as a subclass of software --> plan specification\n",
    "  g.add((processIRI, obo.STATO_0000102, softwareApplicationIRI)) # Tensile Test process stato:executes Software Application\n",
    "  g.add((analysisIRI, obo.STATO_0000102, softwareApplicationIRI)) # Analysis process (subprocess of tensile test) stato:executes Software Application\n",
    "\n",
    "  softwareApplicationNameIRI = URIRef(experimentIRI + \"_software_application_identifier\")\n",
    "  g.add((softwareApplicationNameIRI, a, obo.IAO_0020000)) # is an iao:identifier\n",
    "  g.add((softwareApplicationNameIRI, dct.identifier, Literal(\"BAM Tensile Test Analysis App\", datatype=XSD.string)))\n",
    "  g.add((softwareApplicationNameIRI, obo.IAO_0000219, softwareApplicationIRI)) # Software Application Name (identifier) iao:denotes Software Application"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ODbWo86egC5i"
   },
   "source": [
    "# Graph Serialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Hzt7LZWXhT5z",
    "outputId": "91c8cee3-2b30-4593-eb00-60fe29faf8b9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Graph identifier=Nad4e8a32694a4ddc8ecf99c4ffe47a7d (<class 'rdflib.graph.Graph'>)>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Graph g is serialized in two different data formats / notations, Turtle (ttl) and RDF\n",
    "g.serialize(\"RDF-TTO-data_S355.ttl\", format=\"ttl\")\n",
    "g.serialize(\"RDF-TTO-data_S355.rdf\", format='application/rdf+xml', encoding=\"utf-8-sig\")\n",
    "\n",
    "# Instead of serializing the data to be stored in the working directory, \n",
    "# the files could alternatively be stored in another repository or directly\n",
    "# uploaded to a triple store."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Information concerning Namespaces and Concepts\n",
    "\n",
    "As some semantic concepts used within this script do not use IRIs that can directly be interpreted by humans (humans will have to read the labels provided), the corresponding labels are given, here, for the most important concepts frequently used in this script. \n",
    "\n",
    "### PMD Core Ontology (PMDco)\n",
    "*(Namespace: [pmdco:](https://w3id.org/pmd/co/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [pmdco:PMD_0000544](https://w3id.org/pmd/co/PMD_0000544)       | Caliper         | Class |\n",
    "| [pmdco:PMD_0000583](https://w3id.org/pmd/co/PMD_0000583)       | Computing Process         | Class |\n",
    "| [pmdco:PMD_0000599](https://w3id.org/pmd/co/PMD_0000599)       | Department Role         | Class |\n",
    "| [pmdco:PMD_0000636](https://w3id.org/pmd/co/PMD_0000636)       | Extensometer         | Class |\n",
    "| [pmdco:PMD_0000820](https://w3id.org/pmd/co/PMD_0000820)       | Load Cell         | Class |\n",
    "| [pmdco:PMD_0000830](https://w3id.org/pmd/co/PMD_0000830)       | Manufacturer Company         | Class |\n",
    "| [pmdco:PMD_0000002](https://w3id.org/pmd/co/PMD_0000002)       | Material Designation         | Class |\n",
    "| [pmdco:PMD_0000854](https://w3id.org/pmd/co/PMD_0000854)       | Micrometer Gauge         | Class |\n",
    "| [pmdco:PMD_0000872](https://w3id.org/pmd/co/PMD_0000872)       | Operator         | Class |\n",
    "| [pmdco:PMD_0000873](https://w3id.org/pmd/co/PMD_0000873)       | Operator Role        | Class |\n",
    "| [pmdco:PMD_0000879](https://w3id.org/pmd/co/PMD_0000879)       | Organization        | Class |\n",
    "| [pmdco:PMD_0000909](https://w3id.org/pmd/co/PMD_0000909)       | Project        | Class |\n",
    "\n",
    "\n",
    "\n",
    "### Basic Formal Ontology (BFO)\n",
    "*(Namespace: [obo:](http://purl.obolibrary.org/obo/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [obo:BFO_0000063](http://purl.obolibrary.org/obo/BFO_0000063)       | precedes         | Object Property |\n",
    "| [obo:BFO_0000055](http://purl.obolibrary.org/obo/BFO_0000055)       | realizes         | Object Property |\n",
    "| [obo:BFO_0000054](http://purl.obolibrary.org/obo/BFO_0000054)       | realized in         | Object Property |\n",
    "| [obo:BFO_0000051](http://purl.obolibrary.org/obo/BFO_0000051)       | has part         | Object Property |\n",
    "\n",
    "\n",
    "### Information Artifact Ontology (IAO)\n",
    "*(Namespace: [obo:](http://purl.obolibrary.org/obo/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [obo:IAO_0020000](http://purl.obolibrary.org/obo/IAO_0020000)       | identifier         | Class |\n",
    "| [obo:IAO_0000032](http://purl.obolibrary.org/obo/IAO_0000032)       | scalar measurement datum         | Class |\n",
    "| [obo:IAO_0000003](http://purl.obolibrary.org/obo/IAO_0000003)       | measurement unit label         | Class |\n",
    "| [obo:IAO_0000027](http://purl.obolibrary.org/obo/IAO_0000027)       | data item         | Class |\n",
    "| [obo:IAO_0000131](http://purl.obolibrary.org/obo/IAO_0000131)       | serial number         | Class |\n",
    "| [obo:IAO_0000594](http://purl.obolibrary.org/obo/IAO_0000594)       | software application         | Class |\n",
    "| [obo:IAO_0000100](http://purl.obolibrary.org/obo/IAO_0000100)       | data set         | Class |\n",
    "| [obo:IAO_0000416](http://purl.obolibrary.org/obo/IAO_0000416)       | time measurement datum         | Class |\n",
    "| [obo:IAO_0000300](http://purl.obolibrary.org/obo/IAO_0000300)       | textual entity         | Class |\n",
    "| [obo:IAO_0000422](http://purl.obolibrary.org/obo/IAO_0000422)       | postal address         | Class |\n",
    "| [obo:IAO_0000578](http://purl.obolibrary.org/obo/IAO_0000578)       | centrally registered identifier         | Class |\n",
    "| [obo:IAO_0000039](http://purl.obolibrary.org/obo/IAO_0000039)       | has measurement unit label         | Object Property |\n",
    "| [obo:IAO_0000417](http://purl.obolibrary.org/obo/IAO_0000417)       | is quality measured as         | Object Property |\n",
    "| [obo:IAO_0000136](http://purl.obolibrary.org/obo/IAO_0000136)       | is about         | Object Property |\n",
    "| [obo:IAO_0000219](http://purl.obolibrary.org/obo/IAO_0000219)       | denotes         | Object Property |\n",
    "| [obo:IAO_0000115](http://purl.obolibrary.org/obo/IAO_0000115)       | has textual content         | Object Property |\n",
    "\n",
    "\n",
    "### Ontology for Biomedical Investigations (OBI)\n",
    "*(Namespace: [obo:](http://purl.obolibrary.org/obo/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [obo:OBI_0000011](http://purl.obolibrary.org/obo/OBI_0000011)       | planned process         | Class |\n",
    "| [obo:OBI_0000070](http://purl.obolibrary.org/obo/OBI_0000070)       | assay         | Class |\n",
    "| [obo:OBI_0001931](http://purl.obolibrary.org/obo/OBI_0001931)       | scalar value specification         | Class |\n",
    "| [obo:OBI_0000260](http://purl.obolibrary.org/obo/OBI_0000260)       | plan         | Class |\n",
    "| [obo:OBI_0000104](http://purl.obolibrary.org/obo/IAO_0000104)       | plan specification        | Class |\n",
    "| [obo:OBI_0000835](http://purl.obolibrary.org/obo/OBI_0000835)       | manufacturer        | Class |\n",
    "| [obo:OBI_0000571](http://purl.obolibrary.org/obo/OBI_0000571)       | manufacturer role       | Class |\n",
    "| [obo:OBI_0000453](http://purl.obolibrary.org/obo/OBI_0000453)       | measure function       | Class |\n",
    "| [obo:OBI_0000654](http://purl.obolibrary.org/obo/OBI_0000654)       | device setting       | Class |\n",
    "| [obo:OBI_0001937](http://purl.obolibrary.org/obo/OBI_0001937)       | has specified numeric value         | Datatype Property |\n",
    "| [obo:OBI_0002815](http://purl.obolibrary.org/obo/OBI_0002815)       | has representation         | Datatype Property |\n",
    "| [obo:OBI_0000293](http://purl.obolibrary.org/obo/OBI_0000293)       | has specified input         | Object Property |\n",
    "| [obo:OBI_0000299](http://purl.obolibrary.org/obo/OBI_0000299)       | has specified output         | Object Property |\n",
    "| [obo:OBI_0001927](http://purl.obolibrary.org/obo/OBI_0001927)       | specifies value of         | Object Property |\n",
    "| [obo:OBI_0001938](http://purl.obolibrary.org/obo/OBI_0001938)       | has value specification         | Object Property |\n",
    "| [obo:OBI_0000304](http://purl.obolibrary.org/obo/OBI_0000304)       | is_manufactured_by         | Object Property |\n",
    "\n",
    "\n",
    " ### Relation Ontology (RO)\n",
    "*(Namespace: [obo:](http://purl.obolibrary.org/obo/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [obo:RO_0000086](http://purl.obolibrary.org/obo/RO_0000086)       | has quality         | Object Property |\n",
    "| [obo:RO_0002090](http://purl.obolibrary.org/obo/RO_0002090)       | immediately precedes         | Object Property |\n",
    "| [obo:RO_0002012](http://purl.obolibrary.org/obo/RO_0002012)       | occurrent part of         | Object Property |\n",
    "| [obo:RO_0002224](http://purl.obolibrary.org/obo/RO_0002224)       | starts with         | Object Property |\n",
    "| [obo:RO_0001000](http://purl.obolibrary.org/obo/RO_0001000)       | derives from        | Object Property |\n",
    "| [obo:RO_0000059](http://purl.obolibrary.org/obo/RO_0000059)       | concretizes        | Object Property |\n",
    "| [obo:RO_0002180](http://purl.obolibrary.org/obo/RO_0002180)       | has component        | Object Property |\n",
    "| [obo:RO_0000085](http://purl.obolibrary.org/obo/RO_0000085)       | has function        | Object Property |\n",
    "| [obo:RO_0002215](http://purl.obolibrary.org/obo/RO_0002215)       | capable of        | Object Property |\n",
    "| [obo:RO_0002608](http://purl.obolibrary.org/obo/RO_0002608)       | process has causal agent       | Object Property |\n",
    "| [obo:RO_0000057](http://purl.obolibrary.org/obo/RO_0000057)       | has participant       | Object Property |\n",
    "| [obo:RO_0000087](http://purl.obolibrary.org/obo/RO_0000087)       | has role       | Object Property |\n",
    "| [obo:RO_0002566](http://purl.obolibrary.org/obo/RO_0002566)       | causally influences       | Object Property |\n",
    "\n",
    "\n",
    "### The Statistical Methods Ontology (STATO)\n",
    "*(Namespace: [obo:](http://purl.obolibrary.org/obo/)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [obo:STATO_0000102](http://purl.obolibrary.org/obo/STATO_0000102)       | executes         | Object Property |\n",
    "\n",
    "\n",
    "### Time Ontology in OWL\n",
    "*(Namespace: [time:](http://www.w3.org/2006/time#)):*\n",
    "\n",
    "| IRI  | Label | Concept |\n",
    "|:-------------|:--------------|:--------------|\n",
    "| [time:Duration](http://www.w3.org/2006/time#Duration)       | Duration         | Class |\n",
    "| [time:Instant](http://www.w3.org/2006/time#Instant)       | Instant         | Class |\n",
    "| [time:hasTime](http://www.w3.org/2006/time#hasTime)       | has time         | Object Property |\n",
    "| [time:inXSDDate](http://www.w3.org/2006/time#inXSDDate)       | in XSD Date         | Datatype Property |\n",
    "| [time:inXSDDateTime](http://www.w3.org/2006/time#inXSDDateTime)       | in XSD Date Time         | Datatype Property |"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "r1QFp5RGKPAo"
   ],
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}