#4394 Systems Engineering Knowledge Graph Taxonomy; +ICE, Bicycle, EV Examples

-

#4394 Systems Engineering Knowledge Graph Taxonomy; +ICE, Bicycle, EV Examples

#4394 Describe the ontology for a knowledge graph modeling system domains, systems, subsystems, components, parts and element function (e.g. Prime Movers, Motion/Transmission, Control Systems, Structure/Framework, etc.)

Designing an ontology for a technical knowledge graph requires a hierarchical structure that balances physical decomposition with functional logic. This allows you to trace a high-level system goal all the way down to a specific mechanical part.

1. The Physical Hierarchy (Structural Decomposition)

This represents the "What is it?" aspect of the system. It follows a classic parent-child relationship where complexity decreases as you move down the tree.

  • System Domain: The highest abstraction level (e.g., Aerospace, Automotive, Energy Grid).

  • System: A set of interrelated entities that work together toward a common objective (e.g., An Electric Vehicle).

  • Subsystem: A functional grouping within a system (e.g., The Drivetrain).

  • Component: A discrete unit that performs a specific task within a subsystem (e.g., The Electric Motor).

  • Part: The lowest level of repairable or replaceable hardware (e.g., A Rotor, a Bearing).

2. The Functional Taxonomy (The "Element Functions")

While the physical hierarchy tells you what a thing is, the Functional Taxonomy explains what it does. In a robust ontology, these are often "classes" or "tags" applied to the physical entities.

Functional ClassDescriptionExamples
Prime MoversEntities that convert energy into mechanical work.Internal Combustion Engines, Electric Motors, Turbines.
Motion/TransmissionComponents that modify or transfer mechanical energy.Gears, Drive Shafts, Belts, Hydraulics.
Control SystemsThe "brain" that regulates system behavior.PLCs, ECUs, Sensors, Feedback Loops.
Structure/FrameworkThe physical support that maintains spatial relationships.Chassis, Housings, Frames, Brackets.
Energy StorageComponents that hold potential energy for later use.Batteries, Fuel Tanks, Flywheels.

3. Relationships & Predicates (The Graph Logic)

In a knowledge graph, the "edges" (relationships) are just as important as the nodes. Here are the core predicates for this ontology:

  • consists_of / is_part_of: Defines the physical hierarchy.

  • performs_function: Links a physical component to a functional class (e.g., Motor performs_function Prime Mover).

  • interfaces_with: Defines how two components interact (e.g., Gearbox interfaces_with Drive Shaft).

  • powers / controls: Defines functional dependencies between systems.

4. Example Graph Instance: Electric Drivetrain

To see how this looks in practice, let’s map an Electric Vehicle (EV) segment:

  1. Domain: Automotive

  2. System: Tesla Model 3

  3. Subsystem: Powertrain (is_part_of Tesla Model 3)

  4. Component: Electric Motor (is_part_of Powertrain)

    • Function Class: Prime Mover

  5. Component: Inverter (is_part_of Powertrain)

    • Function Class: Control System

    • Relationship: controls -> Electric Motor

  6. Part: Stator (is_part_of Electric Motor)

5. Why This Structure Works

By separating Physical Structure from Functional Class, your knowledge graph becomes "query-flexible." You can ask the graph:

  • "Show me all Prime Movers across the Aerospace domain."

  • "What happens to the Control System if this specific Part fails?"

  • "Which Subsystems share the same Structure/Framework?"

Are you planning to implement this ontology in a specific graph database like Neo4j, or is this more for a conceptual systems engineering framework?


Provide Cypher Merge statements for Domain=Mechanical Systems, System=[internal combustion engine, bicycle, electric vehicle], with associated functional classes

To build this in Neo4j, we will use a MERGE strategy. This ensures that running the script multiple times won't create duplicate nodes, but will instead update or verify existing ones.

The following Cypher script establishes the Domain, the Systems, and links them to their respective Functional Classes.

// 1. Create the Domain
MERGE (d:Domain {name: 'Mechanical Systems'})

// 2. Create Functional Classes
MERGE (f1:Function {name: 'Prime Mover', description: 'Energy conversion to work'})
MERGE (f2:Function {name: 'Motion/Transmission', description: 'Transfer and modification of energy'})
MERGE (f3:Function {name: 'Control System', description: 'Regulation and logic'})
MERGE (f4:Function {name: 'Structure/Framework', description: 'Physical support and housing'})
MERGE (f5:Function {name: 'Energy Storage', description: 'Potential energy containment'})

// 3. Create Systems and Link to Domain
MERGE (s1:System {name: 'Internal Combustion Engine'})
MERGE (s2:System {name: 'Bicycle'})
MERGE (s3:System {name: 'Electric Vehicle'})

MERGE (s1)-[:IN_DOMAIN]->(d)
MERGE (s2)-[:IN_DOMAIN]->(d)
MERGE (s3)-[:IN_DOMAIN]->(d)

// 4. Map Internal Combustion Engine Functions
MERGE (s1)-[:HAS_FUNCTIONAL_ELEMENT]->(f1) // Piston/Cylinder Assembly
MERGE (s1)-[:HAS_FUNCTIONAL_ELEMENT]->(f2) // Crankshaft
MERGE (s1)-[:HAS_FUNCTIONAL_ELEMENT]->(f3) // ECU/Carburetor
MERGE (s1)-[:HAS_FUNCTIONAL_ELEMENT]->(f4) // Engine Block

// 5. Map Bicycle Functions
MERGE (s2)-[:HAS_FUNCTIONAL_ELEMENT]->(f1) // Human/Rider (The biological prime mover)
MERGE (s2)-[:HAS_FUNCTIONAL_ELEMENT]->(f2) // Chain/Derailleur
MERGE (s2)-[:HAS_FUNCTIONAL_ELEMENT]->(f3) // Handlebars/Brake Levers
MERGE (s2)-[:HAS_FUNCTIONAL_ELEMENT]->(f4) // Frame

// 6. Map Electric Vehicle Functions
MERGE (s3)-[:HAS_FUNCTIONAL_ELEMENT]->(f1) // Electric Motor
MERGE (s3)-[:HAS_FUNCTIONAL_ELEMENT]->(f2) // Reduction Gear/Half-shafts
MERGE (s3)-[:HAS_FUNCTIONAL_ELEMENT]->(f3) // Power Electronics/Inverter
MERGE (s3)-[:HAS_FUNCTIONAL_ELEMENT]->(f4) // Chassis/Skateboard
MERGE (s3)-[:HAS_FUNCTIONAL_ELEMENT]->(f5) // Battery Pack

Key Logic in this Script:

  • Labels: I used :Domain, :System, and :Function to allow for easy filtering.

  • Reusability: Note that the Function nodes are created once and linked to multiple systems. This is the "Graph" way—showing that a "Prime Mover" is a concept shared by an EV, a bike, and an ICE.

  • Relationship Direction: The relationship flows from the specific (System) to the general (Domain) and the categorical (Function).

Would you like to extend this further by adding the specific Components (like the "Crankshaft" or "Battery Cells") that act as the children of these systems?


Include the subsystems, components and parts with functional classes for each

Expanding the ontology to include subsystems, components, and parts requires a "is_part_of" chain. Each node at every level can be tagged with its functional class to maintain traceability.

Below are the Cypher statements to build out these hierarchies for the Internal Combustion Engine, Bicycle, and Electric Vehicle.

1. Internal Combustion Engine (ICE) Hierarchy

This set focuses on the transition from the fuel system to the mechanical output.

// Subsystem: Fuel Delivery
MERGE (sub1:Subsystem {name: 'Fuel Injection System'})-[:IS_PART_OF]->(:System {name: 'Internal Combustion Engine'})
MERGE (sub1)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Control System'})

// Component: Fuel Injector
MERGE (c1:Component {name: 'Fuel Injector'})-[:IS_PART_OF]->(sub1)
MERGE (c1)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Motion/Transmission'}) // Fluid motion

// Part: Nozzle Valve
MERGE (p1:Part {name: 'Injector Nozzle'})-[:IS_PART_OF]->(c1)
MERGE (p1)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Control System'}) // Precision metering

2. Bicycle Hierarchy

The bicycle provides an excellent example of structural framework and mechanical transmission interfaces.

// Subsystem: Drivetrain
MERGE (sub2:Subsystem {name: 'Bicycle Drivetrain'})-[:IS_PART_OF]->(:System {name: 'Bicycle'})
MERGE (sub2)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Motion/Transmission'})

// Component: Derailleur
MERGE (c2:Component {name: 'Rear Derailleur'})-[:IS_PART_OF]->(sub2)
MERGE (c2)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Control System'}) // Directs the chain

// Part: Jockey Wheel
MERGE (p2:Part {name: 'Jockey Wheel'})-[:IS_PART_OF]->(c2)
MERGE (p2)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Motion/Transmission'})

// Subsystem: Frame Assembly
MERGE (sub3:Subsystem {name: 'Frame Group'})-[:IS_PART_OF]->(:System {name: 'Bicycle'})
MERGE (sub3)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Structure/Framework'})

3. Electric Vehicle (EV) Hierarchy

This highlights the integration of high-energy storage and electronic control systems.

// Subsystem: Energy Storage System (ESS)
MERGE (sub4:Subsystem {name: 'Battery Pack Assembly'})-[:IS_PART_OF]->(:System {name: 'Electric Vehicle'})
MERGE (sub4)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Energy Storage'})

// Component: Battery Module
MERGE (c3:Component {name: 'Lithium-Ion Module'})-[:IS_PART_OF]->(sub4)
MERGE (c3)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Energy Storage'})

// Part: Battery Cell
MERGE (p3:Part {name: '2170 Form Factor Cell'})-[:IS_PART_OF]->(c3)
MERGE (p3)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Energy Storage'})

// Subsystem: Traction System
MERGE (sub5:Subsystem {name: 'Electric Drive Unit'})-[:IS_PART_OF]->(:System {name: 'Electric Vehicle'})
MERGE (sub5)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Prime Mover'})

// Component: Inverter
MERGE (c4:Component {name: 'Traction Inverter'})-[:IS_PART_OF]->(sub5)
MERGE (c4)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Control System'})

// Part: IGBT/SiC MOSFET
MERGE (p4:Part {name: 'Power Transistor'})-[:IS_PART_OF]->(c4)
MERGE (p4)-[:HAS_FUNCTIONAL_ELEMENT]->(:Function {name: 'Control System'})

Implementation Note: Recursive Queries

By structuring the data this way with a consistent IS_PART_OF relationship, you can perform recursive pathfinding in Neo4j to see the entire functional "ancestry" of a part.

For example, to find every functional class associated with a Power Transistor, you would query:

MATCH (p:Part {name: 'Power Transistor'})-[:IS_PART_OF*1..]->(parent)
MATCH (parent)-[:HAS_FUNCTIONAL_ELEMENT]->(f:Function)
RETURN parent.name, f.name

This allows you to see that the transistor is part of a Control System at the Component level, which is part of a Prime Mover at the Subsystem level.


From <https://gemini.google.com/app/>  Google Gemini 3.0 (Fast)

Comments

Post a Comment

Popular posts from this blog

#2892 Example of ChatGPT o1 Prompt

-
#2892 Example of ChatGPT o1 Prompt #2892 Consider this prompt example from a tutorial:  """The Anatomy of an o1 Prompt Goal: I want a list of the best medium-length hikes within two hours of San Francisco. Each hike should provide an unique adventure, and be lesser know. Return Format: For each hike, return the name of the hike as I'd find it on AllTrails, then provide the starting address of the hike, the ending address of the hike, distance, drive time, hike duration, and what makes it a cool and unique adventure. Warnings: Be careful to make sure the name of the trail is correct, that it actually exists, and that the time is correct! Context Dump: For context: my girlfriend and I hike a ton! We've don pretty much all of the local SF hikes, whether that's Presidio or Golden Gate Park. we definitely want to get out of town -- we did mount tam pretty recently, the whole thing from the beginning of the stairs to Stinson -- it was really long and we are def...
Read more
-
#65 Compose a song about mankind traveling to the stars to find life, riches and happiness Verse 1 : We set out on a journey to the stars Searching for a new world, free from scars A place where we can find our destiny And build a life that's meant to be Chorus : We are the explorers, the brave and true On a mission to find what's waiting for us In the vast expanse of the universe We'll go where no man has gone before Verse 2 : We'll cross the galaxy, we'll go far and wide To find a home where we can thrive We'll brave the dangers that come our way And find the riches that lay hidden in the stars Chorus : We are the explorers, the brave and true On a mission to find what's waiting for us In the vast expanse of the universe We'll go where no man has gone before Bridge : We'll meet new friends and see new sights And learn about the mysteries of the night We'll find new worlds and new life And see what the future holds in our sights Chorus : We are ...
Read more

#3679 Google Gemini 2.5 Pro: Create Python Application to View and Query Neo4j KG

-
Image
#3679 Google Gemini 2.5 Pro: Create Python Application to View and Query Neo4j KG #3679 Create a python application for me to view data and ask questions from my Neo4j graph database. Semantic search of embedded documents should be supported in addition natural language queries and Cypher queries Of course. I will create a Python application that allows you to interact with your Neo4j graph database. You'll be able to execute Cypher queries directly, ask questions in natural language, and perform semantic searches on embedded documents. Here are the files for your application: a requirements.txt file to manage dependencies, the main Python application file, and an HTML file for the user interface. requirements.txt flask neo4j sentence-transformers numpy import os import json from flask import Flask, render_template, request, jsonify from neo4j import GraphDatabase, exceptions import numpy as np from sentence_transformers import SentenceTransformer # --- Configuration --- # It'...
Read more