Table of Contents

Introduction

Part V provides hands-on exercises that let you apply the concepts of ontologies and digital engineering to real-world modeling challenges. These exercises bridge theory and practice, helping you develop the skills to align ontologies with engineering models and implement interoperable systems.

This section is your opportunity to transform theoretical knowledge into practical engineering skills through guided exercises that mirror real-world digital engineering challenges.

Overview

Part V contains a curated set of practical exercises designed to reinforce the concepts covered in previous sections of the handbook. These exercises focus on:

  • Applying ontology alignment principles to engineering models

  • Implementing interoperable workflows using the Armaments Interoperability and Integration Framework (IoIF)

  • Creating and extending ontologies with Protégé

  • Integrating SysML models with ontology-aligned data

  • Executing and analyzing workflows using Jupyter Notebooks

The exercises progress from foundational to advanced, with increasing complexity to build your skills incrementally. Each exercise includes clear objectives, step-by-step instructions, and deliverables to guide your learning.

This section provides practical experience in aligning ontologies with digital engineering models, a crucial skill for effective knowledge representation and interoperability in complex systems development.

The exercises in Part V are designed to be completed using the tools and methodologies described in Parts I-IV of the handbook. If you haven’t completed those sections, it’s recommended to review them before attempting these exercises.

Position in Knowledge Hierarchy

Broader concepts: - Handbook on Digital Engineering with Ontologies (contains)

Details

Part V contains a series of exercises that progressively build your skills in ontology alignment and digital engineering integration. Each exercise follows a consistent structure:

  1. Learning Objectives: Clear statements of what you’ll learn

  2. Software Requirements: Tools needed to complete the exercise

  3. Step-by-Step Instructions: Detailed guidance for completing the exercise

  4. Deliverables: What to submit upon completion

  5. Additional Resources: References to relevant sections of the handbook

The exercises are designed to be completed in sequence, as each builds upon concepts from the previous one. The following table summarizes the exercises in Part V:

Exercise Number

Focus Area

Exercise 1: Basic Ontology Alignment

Aligning a simple SysML model with an ontology

Exercise 2: Extending an Existing Ontology

Adding new features to a domain ontology

Exercise 3: Implementing an IoIF Workflow

Creating a workflow that integrates SysML models with ontology-aligned data

Exercise 4: Advanced Verification and Validation

Using semantic verification techniques to ensure model integrity

Exercise 1: Basic Ontology Alignment

Learning Objectives: - Understand the relationship between SysML diagrams and OWL ontologies - Apply basic ontology alignment principles to a simple engineering model - Create a basic ontology using Protégé

Software Requirements: - Protégé (https://protegewiki.stanford.edu/wiki/Main_Page) - SysML modeling tool (e.g., MagicDraw, Cameo Systems Modeler) - Jupyter Notebook (for optional workflow demonstration)

Step-by-Step Instructions:

  1. Review the Catapult Example:

    • Study the Catapult example from Section 5 of "Semantic Web for the Working Ontologist" (referenced in the handbook)

    • Pay attention to how different SysML diagrams (BDD, IBD) correspond to OWL classes and relationships

  2. Create a SysML Block Definition Diagram (BDD):

    • Open your SysML modeling tool

    • Create a new model for a simple engineering system (e.g., a water pump)

    • Add a block representing the "Water Pump" and its key components (e.g., "Motor," "Impeller," "Housing")

  3. Create an OWL Ontology in Protégé:

    • Open Protégé and create a new ontology

    • Add a class for "WaterPump" and subclasses for "Motor," "Impeller," and "Housing"

    • Define relationships such as "hasPart" between the WaterPump and its components

  4. Align the Models:

    • In your SysML tool, apply stereotypes to the blocks that correspond to the ontology classes

    • For example, apply a stereotype "WaterPump" to the Water Pump block

    • Use the "hasPart" relationship to connect the Water Pump block to its components

  5. Verify Alignment:

    • Export the SysML model to a format that can be analyzed with the ontology

    • Use Protégé’s reasoner to verify that the alignment is consistent

    • Check for any inconsistencies or missing mappings

Deliverables: - Screenshot of your SysML BDD showing the aligned model - The OWL ontology file (.owl) showing the class structure - A brief explanation (1-2 paragraphs) of your alignment decisions

When applying stereotypes in SysML, ensure that the stereotype names match exactly with the ontology class names to maintain proper alignment. Mismatched names will prevent the models from being correctly linked in the IoIF workflow.

Exercise 2: Extending an Existing Ontology

Learning Objectives: - Extend an existing ontology with new domain-specific terms - Apply ontology alignment principles to new features - Maintain coherence with the top-level ontology (BFO)

Software Requirements: - Protégé - SysML modeling tool - Git (for version control)

Step-by-Step Instructions:

  1. Start with a Baseline Ontology:

    • Load the existing Catapult ontology in Protégé

    • Review the existing classes, properties, and relationships

  2. Identify a New Feature to Add:

    • Choose a new feature for the catapult (e.g., "Safety Mechanism" as described in the context)

    • Analyze the existing ontology to determine where the new feature fits

  3. Extend the Ontology:

    • Create a new class "SafetyMechanism" in Protégé

    • Define appropriate properties and relationships (e.g., "hasPart," "isActivatedBy")

    • Ensure the new class is properly integrated with the existing ontology structure

    • Add a definition and documentation for the new class

  4. Update the SysML Model:

    • Create a new SysML Block Definition Diagram (BDD) for the SafetyMechanism

    • Connect the SafetyMechanism block to the existing Catapult block

    • Apply the appropriate stereotype to align with the new ontology class

  5. Verify the Extension:

    • Use Protégé’s reasoner to verify that the new class is properly integrated

    • Check that the new relationships are consistent with the existing ontology

    • Validate that the extension maintains coherence with BFO

Deliverables: - Updated OWL ontology file showing the new SafetyMechanism class - Screenshot of the extended SysML model with the SafetyMechanism - Brief explanation of how you maintained coherence with BFO

When extending ontologies, always refer back to the principles of ontology alignment discussed in Section 5 of the handbook. This ensures your extension remains consistent with the overall ontology structure and purpose.

Practical applications and examples

Here’s an example of how to extend the Catapult ontology with a SafetyMechanism using Protégé:

= Create a new class for SafetyMechanism
:SafetyMechanism rdf:type owl:Class .

= Define the relationship to the Catapult
:SafetyMechanism rdfs:subClassOf :Mechanism .

= Add a property for activation
:isActivatedBy rdf:type owl:ObjectProperty ;
    rdfs:domain :SafetyMechanism ;
    rdfs:range :UserAction .

= Add a definition for the SafetyMechanism
:SafetyMechanism rdfs:comment "A mechanism that prevents the catapult from firing unless it is actively engaged." .

This example shows how to create a new class and define its relationships in OWL. The SafetyMechanism is a subclass of Mechanism, and it has a relationship "isActivatedBy" that connects it to UserAction. The comment provides a clear definition for human understanding.

When defining new classes and properties, ensure they are properly documented with clear definitions. This is critical for maintaining the usability of the ontology for both humans and machines.

The following Python code demonstrates a simple IoIF workflow for the Catapult example, which would be part of Exercise 3:

= Initialize IoIF
from ioif import IoIF
ioif = IoIF()

= Load the Catapult model from Teamwork Cloud
ioif.load_model("catapult_model", "SpringConstantWorkflow")

= Define the Analysis Type (e.g., Analysis as Designed)
analysis_type = "Analysis as Designed"
ioif.set_analysis_type(analysis_type)

= Pull data from the triplestore
data = ioif.get_data("catapult_parameters")

= Run the safety mechanism simulation
safety_result = run_safety_simulation(data)

= Push results back to the triplestore
ioif.push_data("safety_results", safety_result)

= Generate a report
report = ioif.generate_report()
print(report)

This code snippet shows how to initialize an IoIF workflow, load a model, run a simulation, and generate a report. The workflow would be implemented in a Jupyter Notebook as described in the context.

Related wiki pages

Part I
Part II
Part III
Part IV
Part VI
Ontology
SysML
Protégé
IoIF
DEFII

References

Protégé Ontology Editor
SysML v2 Documentation
Semantic Web for the Working Ontologist
OWL 2 Web Ontology Language
Driving Digital Engineering Integration and Interoperability Through Semantic Integration of Models with Ontologies
Systems Engineering for the Digital Age: Practitioner Perspectives
Basic Formal Ontology (BFO)

Knowledge Graph

Visualize the relationships between Part V exercises and related concepts

graph TD A[Part V] --> B[Exercise 1: Basic Ontology Alignment] A[Part V] --> C[Exercise 2: Extending an Existing Ontology] A[Part V] --> D[Exercise 3: Implementing an IoIF Workflow] A[Part V] --> E[Exercise 4: Advanced Verification and Validation] B[Exercise 1] --> F[Protégé] B[Exercise 1] --> G[SysML] C[Exercise 2] --> H[BFO] C[Exercise 2] --> I[Ontology Extension] D[Exercise 3] --> J[IoIF] D[Exercise 3] --> K[Workflow Implementation] E[Exercise 4] --> L[Semantic Verification] E[Exercise 4] --> M[Model Consistency] F[Protégé] --> N[OWL] G[SysML] --> O[BDD] H[BFO] --> P[Top-Level Ontology] J[IoIF] --> Q[DEFII] Q[DEFII] --> R[Digital Engineering Framework]

Associated Diagrams

figure_114.png