Study guide

3.1 Associations, Composite Aggregation & Reference Associations

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

3.1 Associations, Composite Aggregation & Reference Associations

Key Takeaways Explain This Topic AI

Composite aggregation (composition) represents strict whole-part ownership indicated by a solid black diamond at the composite/whole end.

Under composite aggregation semantics, a part instance can belong to at most one composite instance at any given point in time, requiring the multiplicity at the composite end to be strictly 0..1 or 1.

The lifecycle of a part in composite aggregation is bound to the composite; destroying the composite whole causes cascading destruction of all its owned parts.

OMG's MU100 coverage map includes composite aggregation but explicitly excludes shared aggregation (the white diamond), for which SysML 1.2 defines no specific semantics.

Association names may include a small solid triangle indicating the reading direction of the label, which must not be confused with open arrowheads that denote navigability.

Last updated: September 2026

3.1 Associations, Composite Aggregation & Reference Associations

Quick Summary: In Systems Modeling Language (SysML), associations define semantic connections between blocks on Block Definition Diagrams (BDDs). OMG's MU100 coverage map lists associations "including composite but not shared aggregation." Focus on composite aggregation (solid black diamond: exclusive whole-part ownership) versus reference associations (no diamond: one block refers to another without owning it). Recognize the hollow white diamond of shared aggregation , but do not expect it to be a tested topic.

Structural modeling in SysML relies on the Block Definition Diagram (BDD) to define system architecture, physical hierarchies, and logical relationships. While generalization establishes "is-a" relationships between general classifications and specialized types, associations define "has-a" and "relates-to" connections. Mastering the specific notations, constraints, and semantics of association types is essential for both practical modeling and achieving certification.

Association Fundamentals on the BDD

An association is a structural classifier relationship in SysML and UML that specifies a link between instances of blocks in an instantiated system. On a Block Definition Diagram, an association is rendered as a solid line connecting two block boundaries (or connecting a block to itself in a recursive relationship). +---------------+ +---------------+

  • | «block» | | «block» |
  • | BlockA |------------------------------| BlockB |
  • +---------------+ +---------------+

Associations can carry several semantic decorations:

Association Name : A label placed along the line describing the conceptual nature of the relationship (e.g., communicatesWith , suppliesPowerTo ).

Reading Direction Arrow : A small solid triangular arrowhead placed immediately beside the association name (e.g., transmitsData ▶ ). It indicates the grammatical reading direction of the relationship name and does not specify navigability.

Aggregation Kind : Diamond markers at one or both ends defining ownership semantics: composite (solid black diamond), shared (hollow white diamond), or none (no diamond).

Association Ends : The extremities of the line, which specify role names, visibilities, and multiplicities for the participating blocks.

Navigability Arrows : Open arrowheads ( --> ) indicating whether instances of one block can navigate to, query, or directly access instances of the connected block.

Composite Aggregation (Composition)

Composite aggregation , commonly referred to simply as composition , is the strongest form of aggregation in SysML. It models a strict whole-part relationship where the whole owns its constituent parts.

Visual Notation

On a BDD, composition is denoted by a solid black (filled) diamond attached directly to the "whole" (composite) block end of the association line. The opposite end connects to the "part" block. +---------------+ +---------------+

  • | «block» |◆-----------------------------| «block» |
  • | Whole | (solid diamond = composite) | Part |
  • +---------------+ +---------------+
  • The Three Inviolable Semantics of Composition

The SysML and UML specifications attach three mandatory semantic rules to composite aggregation that are heavily emphasized on the OCSMP Model User exam:

1. Exclusive Ownership

A part instance can belong to at most one composite instance at any given point in time. A physical or logical component cannot be simultaneously owned by two distinct parent assemblies.

Because ownership is strictly non-shared, the multiplicity at the composite (whole) end must be either 0..1 or 1 . If nothing is shown at the black diamond, SysML 1.2 lets you assume its default of 0..1 .

Exam Warning : Any BDD showing a multiplicity upper bound greater than 1 at a solid black diamond end (such as * , 1..* , or 2..4 ) is syntactically invalid under SysML rules. Spotting an illegal multiplicity on a black diamond is a classic exam question pattern.

2. Bound Lifecycle (Coincident Lifetime)

UML, on which SysML builds, says that if a composite is deleted, all of its parts are normally deleted with it. The lifecycle of the part is tied to the lifecycle of the composite whole:

When a composite block instance is destroyed, deleted, or removed from the system, all of its owned part instances are automatically destroyed as well (cascading deletion).

A part instance cannot outlive its composite whole under normal lifecycle execution. If a Spacecraft instance is decommissioned and destroyed, its composite PropulsionSubsystem and AvionicsBay parts cease to exist.

Exception/Transfer : If the multiplicity on the composite end is 0..1 , a part instance may theoretically be unlinked and reassigned to a different composite instance prior to destruction of the original parent. However, while linked, its lifetime remains subordinate to the current whole.

3. Part Property Instantiation

When a composite association is drawn from Block A (whole) to Block B (part), it defines a part property in Block A. Block A will display this feature in its parts compartment as +roleName : BlockB [multiplicity] .

Shared Aggregation (Recognize It; Not on the MU100 Map)

Shared aggregation is a weaker form of aggregation denoted by a hollow (unfilled / white) diamond attached to the aggregate block end of the association line. +---------------+ +---------------+

  • | «block» |◇-----------------------------| «block» |
  • | Aggregate | (hollow diamond = shared) | Part |
  • +---------------+ +---------------+
  • Semantics and SysML Specification Nuance

Shared aggregation is conventionally read as a non-exclusive grouping:

Non-Exclusive Membership : One part instance may be grouped by several wholes, so the multiplicity at the white diamond may exceed 1 (e.g., 0..* ).

No Lifecycle Coupling Implied : Nothing in SysML says the grouped instances are destroyed with the aggregate.

No Defined Semantics : SysML 1.2 states: "Like UML, SysML defines no specific semantics or constraints for properties with shared aggregation, but particular models or tools may interpret them in specific ways." Because it is not composite, a shared-aggregation property is classified as a reference property .

Why Composition Is the Focus

In model-based systems engineering (MBSE), systems engineers model real physical assemblies, modular software architectures, and hardware breakdowns. In these architectures, physical components cannot exist simultaneously in two places, and destroying a physical subsystem eliminates its components. Therefore:

Composite aggregation (black diamond) is the standard, rigorously supported mechanism for structural system decomposition in SysML.

Shared aggregation (white diamond) is generally avoided in practical systems modeling because it has no defined semantics, and the MU100 coverage map explicitly leaves it out. If you meet a white diamond in a practice question, read it as a reference property, not a part.

Reference Associations (Aggregation = None)

When two blocks must interact, communicate, or maintain awareness of one another without any whole-part relationship, modelers use a reference association :

Notation : A plain solid line between two blocks with no diamond at either end.

Navigability : Frequently drawn with an open arrowhead ( --> ) on one end to denote unidirectional reference.

Semantics : Neither block owns the other. Both blocks have completely independent lifecycles.

Resulting Feature : In the referring block, a reference association manifests as a reference property , listed in the references compartment (represented with a dashed outline or dashed box icon).

Comparison: Composition vs. Shared Aggregation vs. Reference Association

The following table summarizes the key differentiators tested on the OCSMP Model User examination:

Characteristic Composite Aggregation Shared Aggregation (not on MU100) Reference Association

Graphical Marker Solid black (filled) diamond (◆) Hollow white (unfilled) diamond (◇) None (no diamond at either end)

Diamond Placement Attached to the whole / composite block Attached to the aggregate block N/A

Ownership Semantics Strict, exclusive whole-part ownership Weak, non-exclusive shared membership No ownership; relationship or reference

Multiplicity at Diamond End Strictly 0..1 or 1 (never * or >1 ) Any valid multiplicity (can be 0..* , 1..* , etc.) Any valid multiplicity at either end

Part Lifecycle Coupling Dependent: parts are normally deleted with the whole None defined by SysML Independent: neither element controls other's lifecycle

Can Part Belong to Multiple Wholes? No : strictly one composite at any point in time Yes : multiple aggregates can reference the same part Yes : multiple blocks can reference the same target

Resulting Property Type Part Property ( parts compartment) Reference Property (any non-composite block-typed property) Reference Property ( references compartment, dashed icon)

Primary System Modeling Role Physical breakdown, subsystem containment, hardware hierarchy Logical grouping, shared pools of resources Communication links, interface awareness, data routing

Association Directionality and Navigability

Understanding how associations are navigated and read prevents frequent misinterpretations on exam diagrams:

Navigability Arrowheads vs. Reading Direction Triangles

SysML diagrams utilize two completely different arrow notations on or near association lines:

Navigability Arrowhead (Open Arrowhead --> ) :

Located directly at the end of the association line, touching the target block boundary.

Denotes navigability : software or operational flow can traverse from the source block to the target block.

Unidirectional association: an open arrowhead at one end and no arrowhead at the opposite end. The source block owns a property referring to the target, but the target block does not possess a property pointing back to the source.

Bidirectional association: no arrowheads on either end (or occasionally explicit arrowheads on both ends), indicating mutual traversability where both blocks own reference properties typed by each other.

Name Reading Direction Triangle (Solid Triangle ▶ or ◀ ) :

Positioned alongside the textual name of the association, floating near the middle of the line (e.g., transmitsCommand ▶ ).

Indicates solely how a human reader should read the phrase grammatically (e.g., "FlightComputer transmitsCommand to Actuator").

Crucial Distinction : The reading triangle does not specify navigability, data flow, or signal transmission direction. Confusing the reading direction triangle with navigability is one of the most common distractors on the OCSMP Model User exam.

Worked Engineering Scenario: Spacecraft Architecture

Consider a Block Definition Diagram for an earth-observation satellite system:

Spacecraft to PropulsionSubsystem :

Relationship: Composite aggregation (solid black diamond at Spacecraft ).

Role at part end: +propulsion : PropulsionSubsystem [1] .

Multiplicity at diamond end: 1 .

Lifecycle: The propulsion subsystem is an integral, non-shared part of the spacecraft. If the spacecraft instance is decommissioned and disposed, its propulsion subsystem is destroyed with it.

PropulsionSubsystem to Thruster :

Relationship: Composite aggregation (solid black diamond at PropulsionSubsystem ).

Role at part end: +thruster : Thruster [4..12] .

Multiplicity at diamond end: 1 .

Lifecycle: The thrusters are owned parts of the propulsion subsystem. A thruster cannot be simultaneously mounted to two different propulsion subsystems.

Spacecraft to GroundStation :

Relationship: Reference association (solid line with open arrowhead pointing to GroundStation ).

Role at target end: +downlinkStation : GroundStation [0..1] .

Semantics: The spacecraft communicates with an active ground station during orbital passes. The spacecraft does not own the ground station, and destroying the satellite has no impact on the ground station's existence.

SatelliteConstellation to GroundStation (shown for recognition only):

Relationship: Shared aggregation (hollow white diamond at SatelliteConstellation ).

Role at part end: +trackingFacility : GroundStation [1..*] .

Multiplicity at diamond end: 0..* .

Semantics: Multiple constellations can share access to the same ground stations across a global tracking network.

Common Exam Traps & Pitfalls

Trap 1: Diamond Placement Inversion : Always check which block touches the diamond. The diamond is anchored to the composite/whole , while the bare or roled end touches the part . If a question shows a solid black diamond attached to Engine and a line to Automobile , the diagram claims the Engine owns the Automobile as a part, which is an architectural inversion error!

Trap 2: Illegal Multiplicities at Black Diamonds : Whenever you see a solid black diamond, immediately check the multiplicity number next to it. If it reads * , 1..* , 2 , or any number greater than 1, it violates the core rule of composite aggregation.

Trap 3: Treating a White Diamond as Composition : Distractors may claim that a white diamond deletes its members with the whole. Only composite aggregation (solid black diamond) carries that meaning; SysML defines no semantics for shared aggregation.

Trap 4: Conflating Name Reading Direction with Message/Signal Flow : A triangle next to an association name (e.g., operates ▶ ) does not mean signals or messages only flow in that direction; it only tells you how to read the English label.

Loading diagram... Composite vs. Shared Aggregation and Reference Associations