Study guide

11.3 Refine, Trace & Containment Hierarchies

OMG Certified Systems Modeling Professional — Model User OCSMP OMG-OCSMP-MU100

Track your progress as you read

Finished sections get a check mark.

1 Introduction & Exam Overview

About the OCSMP Model User (OMG-OCSMP-MU100) Exam

2 Chapter 1: SysML Overview, Diagram Framework & Model Organization

1.1 SysML Overview, MBSE Foundations & Diagram Frame Syntax 1.2 Model Organization, Packages & Viewpoints

3 Chapter 2: Block Definition Diagrams — Blocks & Structural Features

2.1 Block Definitions, Features & Compartments 2.2 ValueTypes, Units, Dimensions & Primitive Types 2.3 Specialization, Generalization & Inheritance Hierarchies

4 Chapter 3: Block Definition Diagrams — Associations, Composition & Multiplicities

3.1 Associations, Composite Aggregation & Reference Associations 3.2 Multiplicities, Reference Properties & Association Ends

5 Chapter 4: Internal Block Diagrams — Internal Structure & Interconnection

4.1 Enclosing Blocks & Part Usages 4.2 Standard Ports, Flow Ports & Interfaces 4.3 Connectors, Item Flows & Flow Specifications

6 Chapter 5: Parametric Diagrams & Constraint Modeling

5.1 Constraint Blocks, Properties & Mathematical Expressions 5.2 Parametric Diagrams & Binding Connectors

7 Chapter 6: Activity Diagrams — Control & Object Flows

6.1 Activity Diagram Anatomy & Control Nodes 6.2 Object Flow, Pins & Activity Parameter Nodes 6.3 Decision, Merge, Fork & Join Execution

8 Chapter 7: Activity Diagrams — Partitions & Action Types

7.1 Activity Partitions (Swimlanes) & Structural Allocation 7.2 Action Types: Call Behavior, Send Signal & Accept Event

9 Chapter 8: State Machine Diagrams — States, Transitions & Events

8.1 State Machine Basics: States, Regions & Orthogonality 8.2 Transitions, Trigger-Guard-Effect Syntax & State Behaviors 8.3 Event Types & Run-to-Completion Semantics

10 Chapter 9: Sequence Diagrams — Message Interactions & Lifelines

9.1 Sequence Diagram Fundamentals, Lifelines & Execution 9.2 Message Types & Interaction References (ref)

11 Chapter 10: Cross-Cutting Constructs — Allocations & Metadata

10.1 The «allocate» Dependency: Semantics & Types 10.2 Allocation Representations: Callouts, Compartments, Partitions & Tables 10.3 Comments, Rationales, Problems, Stereotypes, Frames & Diagram Descriptions

12 Chapter 11: Requirement Diagrams — Requirements Modeling & Traceability

11.1 Requirement Element Definition, ID, Text & Compartments 11.2 Key Relationships: Derive, Satisfy & Verify 11.3 Refine, Trace & Containment Hierarchies

13 Chapter 12: Use Case Diagrams — System Context & Capabilities

12.1 Actors, Use Cases & Subject Boundaries 12.2 Associations, Include, Extend & Generalization

11.3 Refine, Trace & Containment Hierarchies

Key Takeaways Explain This Topic AI

The «refine» dependency indicates that a behavioral or structural model element (client) provides a more detailed, unambiguous specification of a requirement (supplier).

The «trace» dependency represents the weakest semantic relationship in SysML, serving as an auditable tracking link without behavioral or mathematical constraints.

Requirement Containment models hierarchical namespace decomposition where a compound parent requirement owns its constituent sub-requirements.

Containment is rendered visually either by physical nesting (box-in-box) or by a solid line with a circle-plus (+) symbol placed strictly at the parent requirement end.

Containment represents structural/namespace ownership breakdown, whereas «deriveReqt» represents logical derivation between distinct requirements across abstraction levels.

Last updated: September 2026

11.3 Refine, Trace & Containment Hierarchies

Quick Reference: While «deriveReqt» , «satisfy» , and «verify» form the core requirements-to-design backbone, SysML provides three additional mechanisms for structuring and contextualizing specifications: «refine» (where a behavioral model element elaborates what a requirement means), «trace» (a general-purpose, semantically unconstrained audit tracking link), and Containment (composite parent-child ownership rendered via a circle-plus (+) symbol or physical nesting).

1. The «refine» Relationship: Behavioral Clarification

Natural language requirements—no matter how meticulously drafted—suffer from inherent semantic ambiguity. A requirement stating "The automated teller machine shall authenticate customer credentials securely" does not describe the chronological exchange of PIN digits, biometric encryption tokens, or retry limit lockouts.

To eliminate ambiguity, systems engineers construct formal behavioral models (Use Cases, Activities, State Machines, or Sequence Diagrams). SysML connects these descriptive models to requirements using the «refine» dependency.

Metamodel Semantics and Visual Syntax

Client (Tail): The refining model element (most commonly a Use Case, Activity, State Machine, Interaction, or SysML Model View).

Supplier (Head): The requirement being refined.

Arrowhead: A dashed line with an open arrowhead pointing from the refining model element to the requirement . UseCase / Activity - - - «refine» - - - > Requirement

SysML 1.2 also permits the reverse use, where a text requirement refines a less detailed model element. Before reading a «refine» arrow, check which end is the requirement. +---------------------------+ +---------------------------+

  • | «useCase» | | «requirement» |
  • | AuthenticateOperator |-----«refine»--->| OperatorSecurity |
  • | | | id = "REQ-SEC-001" |
  • +---------------------------+ +---------------------------+
  • The Critical Distinction: «refine» vs. «satisfy»

Candidates frequently confuse «refine» and «satisfy» . While both point from a model element to a requirement, their engineering purposes are fundamentally different:

«refine» (Clarifying WHAT the requirement means): Connects a descriptive model (e.g., a Use Case, Activity flow, or State Machine) that elaborates, disambiguates, or formalizes the requirement's operational intent.

«satisfy» (Asserting HOW the design realizes it): Connects a concrete architectural component (e.g., a physical Block, software module, or hardware part) that implements the requirement in the final system architecture.

Modeling Question Appropriate Relationship Client Type Supplier Type

"Which behavioral scenario explains the operational workflow of this requirement?" «refine» Use Case / Activity Requirement

"Which physical component or structural part accomplishes this requirement?" «satisfy» Block / Part Usage Requirement

2. The «trace» Relationship: General-Purpose Audit Tracking

A «trace» relationship is a standard, general-purpose dependency used to record a historical, auditable, or tracking connection between two model elements, at least one of which is typically a requirement.

Characteristics of «trace»

Weakest Semantic Relationship: «trace» imposes no behavioral constraints , no mathematical bindings, and no design realization obligations. It merely asserts: "An auditable relationship exists between these two model elements for tracking, history, or compliance auditing."

Client and Supplier: Drawn as a dashed line with an open arrowhead pointing from client to supplier ( ElementA ----«trace»----> ElementB ).

Broad Applicability: Used to link model requirements back to external regulatory documents, customer request-for-proposal (RFP) paragraphs, legacy specifications, or hazard analyses where a more specific relationship (such as «satisfy» or «deriveReqt» ) does not apply.

Exam Warning: Modeler candidates should not use «trace» as a lazy substitute when a semantically richer relationship is applicable. If a Block fulfills a requirement, use «satisfy» . If a test validates a requirement, use «verify» . If one requirement is deduced from another, use «deriveReqt» . Reserve «trace» strictly for general historical or cross-reference auditing. SysML 1.2 itself recommends that trace "not be used in conjunction with the other requirements relationships."

3. Requirement Containment Hierarchies: Namespace Decomposition

Complex engineering systems frequently involve massive, multi-tiered compound requirements. For example, a high-level requirement EnvironmentalControl encompasses cabin temperature, cabin pressurization, oxygen replenishment, and humidity control.

SysML supports this compositional decomposition through Requirement Containment .

Ownership Semantics of Containment

Requirement containment is not a dependency relationship. It is a strict namespace ownership relationship governed by standard UML package/namespace containment rules:

Single Owner: Every contained sub-requirement is owned by exactly one parent requirement namespace.

Cascading Lifecycle: If the parent requirement is deleted from the model repository, all of its contained sub-requirements are automatically deleted with it.

Namespace Qualified Name: Contained requirements reside inside the parent requirement's namespace path (e.g., SpacecraftReqs::EnvironmentalControl::CabinPressure ).

Graphical Notations for Containment

SysML provides two alternative visual representations for requirement containment on a Requirement Diagram ( req ):

1. Circle-Plus Connector Notation

A solid line links the parent requirement to the child sub-requirement. At the end touching the parent (container) requirement , the line terminates in a circle enclosing a plus sign ( (+) ) . No arrowhead is used. +-----------------------+ +-----------------------+

  • | «requirement» | | «requirement» |
  • | EnvironmentalControl |(+)--------------| CabinPressure |
  • | id = "REQ-ENV-001" | | id = "REQ-ENV-002" |
  • +-----------------------+ +-----------------------+

Exam Trap: The circle-plus (+) symbol must always touch the parent (enclosing) requirement . Placing the circle-plus at the child end is a syntactic violation frequently used as an incorrect answer choice on certification exams.

2. Physical Nesting (Box-in-Box Notation)

The child requirement box is drawn physically inside the boundary of the parent requirement box. This notation visually illustrates encapsulation without connecting lines, though it is practical only for small hierarchies. +-------------------------------------------------------------+

  • | «requirement» |
  • | EnvironmentalControl |
  • | id = "REQ-ENV-001" |
  • +-------------------------------------------------------------+
  • | +---------------------------------------------------------+ |
  • | | «requirement» | |
  • | | CabinPressure | |
  • | | id = "REQ-ENV-002" | |
  • | +---------------------------------------------------------+ |
  • +-------------------------------------------------------------+
  • Containment vs. «deriveReqt» : The Crucial Distinction

A central topic on the OCSMP Model User exam is distinguishing between Containment and «deriveReqt» :

  • Characteristic Containment ( (+) ) Derive Requirement ( «deriveReqt» )
  • Relationship Category Namespace Ownership (Compositional breakdown) Directed Dependency (Logical deduction)
  • Metamodel Construct Namespace Containment Stereotyped Dependency ( «deriveReqt» )

Graphical Line Style Solid line with circle-plus (+) at parent end Dashed line with open arrowhead at source end

Lifecycle Dependency Tightly bound: Deleting the parent destroys the child sub-requirements. Independent: Deleting the source requirement does not delete the derived requirement.

Abstraction Tier Same tier: Part-whole breakdown of a single compound requirement. Cross-tier: Subsystem requirement deduced from a system-level requirement through design synthesis.

Conceptual Meaning "Requirement A is composed of sub-requirements A.1 and A.2." "Requirement B was deduced from Requirement A as a consequence of choosing architecture X."

The Complete 6-Way Requirement Relationship Comparison Matrix

Relationship Metamodel Type Visual Line Style Adornment / Arrowhead Client (Tail) Supplier (Head) Core Meaning

Containment Namespace Ownership (not a dependency) Solid line Circle-plus (+) at parent Parent (owner) Child (owned) Structural/compositional decomposition of a compound requirement into owned parts.

«deriveReqt» Trace dependency Dashed line Open arrow at supplier Derived Requirement Source Requirement Logical deduction of a lower-level requirement from a higher-level requirement.

«satisfy» Trace dependency Dashed line Open arrow at supplier Design Element (Block) Requirement Assertion that an architectural design element fulfills a requirement.

«verify» Trace dependency Dashed line Open arrow at supplier «testCase» (Activity) Requirement Assertion that a test procedure or evaluation proves compliance with a requirement.

«refine» UML Refine (abstraction) Dashed line Open arrow at supplier Behavior (Use Case) Requirement Elaboration of a requirement's operational meaning via a formal behavioral scenario.

«trace» UML Trace (abstraction) Dashed line Open arrow at supplier Any Model Element Any Model Element General-purpose, weak historical or audit tracking link without behavioral constraints.

Worked Example: Comprehensive Requirements Model

Consider an automated baggage handling airport system:

«requirement» BaggageHandlingSystem (Top-Level Container)

Contains via (+) : BagRouting and BagTracking .

«requirement» BagRouting

Refined by ( «refine» ): Use Case RouteLuggageToFlight .

Derived to ( «deriveReqt» ): ConveyorMotorSpeed (Subsystem Requirement).

«requirement» ConveyorMotorSpeed

Satisfied by ( «satisfy» ): Block ElectricRollerConveyor .

Verified by ( «verify» ): Activity ConveyorTachometerTest stereotyped as «testCase» .

«requirement» BaggageHandlingSystem

Traced to ( «trace» ): External document FAA-Airport-Safety-Standard-402 .

This integrated scenario demonstrates the clean separation of concerns among all six requirement relationships.

Exam Pitfalls & Misconceptions

Concept Correct SysML Rule Common Exam Trap / Distractor

Circle-Plus Placement The (+) symbol must be placed at the parent requirement end. Placing (+) at the child sub-requirement end.

Refine vs. Satisfy «refine» clarifies what the requirement means (via behaviors/use cases); «satisfy» asserts how design realizes it (via blocks). Claiming a Block refines a requirement or an Activity satisfies a requirement when clarifying meaning.

Containment Line Style Containment is drawn as a solid line with (+) . Drawing containment with a dashed line or an open arrowhead.

Trace Semantics «trace» is an unconstrained audit pointer with the weakest semantics in SysML. Claiming «trace» proves requirement fulfillment or enforces behavioral execution.

Derivation vs. Containment «deriveReqt» connects separate requirements across tiers; Containment is parent-child namespace ownership. Using «deriveReqt» to represent simple paragraph sub-clause numbering within a single requirement.

Loading diagram... SysML Requirement Relationships: Containment, Refine, and Trace