SysML Block Definition Diagrams Explained: Blocks, Properties, and Relationships
SysML Block Definition Diagrams Explained: Blocks, Properties, and Relationships
The block definition diagram (BDD) is one of the most important diagrams in SysML because it defines the structural backbone of a system model. If you want to understand how a system is organized, what its main elements are, and how those elements relate to one another, the block definition diagram is the place to start.
In this tutorial, we’ll walk through what a SysML block definition diagram is, the types of properties and relationships it includes, and how it connects to internal block diagrams, parametric diagrams, requirements, and behavior.
We’ll also use practical examples such as:
-
hot air balloons
-
pets and inheritance
-
NASCAR wheels
-
an iPhone system model
Watch the full video here:
https://www.youtube.com/watch?v=z8GZVuHpkF4
What Is a Block Definition Diagram in SysML?
A block definition diagram is the SysML diagram used to define the main structural elements of a system.
It shows:
-
blocks
-
classes
-
special types of blocks
-
value types
-
signals
-
structural relationships
A good way to think about it is this:
-
the BDD defines the reusable building blocks
-
other diagrams show how those definitions are used
That makes the BDD the foundation for many other parts of the model.
Where the Block Definition Diagram Fits in SysML
SysML includes nine diagram types, and the block definition diagram is one of the most important structural diagrams.
The BDD works closely with other diagrams, especially:
-
internal block diagrams for showing how parts connect
-
parametric diagrams for applying equations and constraints
-
behavioral diagrams for simulating how the system operates over time
If you are building a system model from scratch, the BDD is often one of the first places to begin.
Core Element: The Block
The central element of the block definition diagram is the block.
A block is a modular unit of structure. It can represent:
-
a whole system
-
a subsystem
-
a component
-
a logical element
-
a physical element
Blocks are reusable definitions. They are not instances themselves. Instead, they define the thing that can later be used elsewhere in the model.
This distinction becomes very important when moving from the BDD to the internal block diagram.
The Three Main Property Types in a Block
One of the most important concepts in a BDD is understanding the three main types of properties associated with blocks.
1. Part Properties
A part property represents something that is owned as part of the system.
Example:
-
an iPhone has a battery
-
a hot air balloon has a basket
-
a NASCAR car has wheels
Part properties are created through composition relationships.
2. Reference Properties
A reference property represents a weaker relationship where one element references another rather than owning it as a true part.
Reference properties are often created through:
-
aggregation
-
association
3. Value Properties
A value property represents a numeric or descriptive attribute, such as:
-
mass
-
cost
-
speed
-
battery percentage
-
yearly food cost
These are critical for analysis, requirements checking, and simulation.
Directed Composition in SysML
A directed composition relationship is one of the most important relationships in a block definition diagram.
This is the classic whole-part relationship.
For example:
-
hot air balloon → basket
-
hot air balloon → parachute
-
hot air balloon → burner system
A directed composition creates a part property on the owning side.
This is typically the structural relationship you will use most often when defining system architecture.
Multiplicity in Composition Relationships
Composition relationships also allow you to specify multiplicity, which tells you how many of a given part may exist.
Examples:
-
one hot air balloon has one basket
-
one hot air balloon may have one to six people
-
an iPhone may have zero or one case
Multiplicity is important because it adds realism and precision to the architecture.
It helps answer questions such as:
-
Is the part optional?
-
Is it required?
-
Can there be many?
Directed Aggregation and Association
The tutorial also explains directed aggregation and association.
These relationships create reference properties rather than part properties.
Directed Aggregation
Directed aggregation uses the open diamond and indicates a weaker structural relationship than composition.
Association
Association is an even looser relationship and often creates reference properties on both sides if used without direction.
The practical guidance from the tutorial is that, in many modeling situations, directed composition is the most useful default because it gives clearer ownership.
Aggregation and association can be helpful, but they are often weaker and less informative for system structure.
Generalization and Inheritance in SysML
Another major concept in block definition diagrams is generalization.
A generalization relationship goes from the specific classifier to the general classifier.
Examples from the tutorial include:
-
dog is a type of pet
-
visible light is a type of light
-
distance is a type of real value
This relationship creates inheritance.
That means the specific classifier inherits the properties and features of the more general classifier.
Example: Pets and Inherited Qualities
A useful example in the tutorial shows a general Pet block with common value properties such as:
-
name
-
weight
-
speed
-
lifespan
-
yearly food cost
Then specific classifiers such as:
-
frog
-
horse
-
rabbit
-
dog breeds
inherit those qualities automatically through generalization.
This is a powerful modeling pattern because it avoids duplicating the same value properties across many specific types.
Example: Balloon Inheritance
The balloon example shows the same idea in a different way.
A general Balloon block can contain value properties such as volume, and specific types of balloons inherit those properties.
Specific classifiers can then redefine inherited values if necessary.
This is helpful when you want common structure across many specialized system types but still need individual tailoring.
Special Types of Blocks
SysML also includes specialized block stereotypes such as:
-
system
-
subsystem
-
domain
-
system context
These are all special types of blocks that come from the SysML profile.
One nice point from the tutorial is that you can explore these directly in the SysML profile inside Cameo rather than relying only on external documentation.
This is helpful for understanding:
-
superclass relationships
-
stereotypes
-
metaclasses
-
built-in documentation
Elements of Definition vs Elements of Usage
One of the most important conceptual distinctions in SysML is the difference between:
-
elements of definition
-
elements of usage
Elements of Definition
Blocks are elements of definition. They are reusable definitions.
Elements of Usage
Part properties are elements of usage. They represent the use of those reusable definitions within a specific context.
For example, in the NASCAR example:
-
Wheel is the reusable block definition
-
left front, right front, left rear, and right rear are part properties using that definition
This distinction is essential because it explains why:
-
BDDs show definitions
-
IBDs show usages
How the BDD Connects to the Internal Block Diagram
Once you create composition relationships in a block definition diagram, those relationships create part properties.
Those part properties are what appear on the internal block diagram (IBD).
So the flow is typically:
-
Define the reusable blocks on the BDD
-
Create composition relationships
-
Use the resulting part properties on the IBD
-
Connect those parts with ports and connectors
That is why the BDD is the foundation for internal structure modeling.
How the BDD Connects to Parametric Diagrams
The tutorial also shows how the BDD can connect to parametric diagrams.
For example, an iPhone model contains parts such as:
-
battery
-
screen
-
processor
-
frame
-
case
A general Hardware block provides common inherited properties like:
-
mass
-
material
From there, you can create a constraint block and then a parametric diagram to roll up the mass of the subcomponents into the total iPhone mass.
This allows the model to support:
-
mass rollups
-
cost rollups
-
performance calculations
-
requirement evaluation
Requirements and Simulation with Block Definition Diagrams
A particularly valuable example in the tutorial connects the BDD to a requirement.
The iPhone has a weight requirement, and the total mass value is linked to that requirement through a satisfy relationship.
In simulation:
-
if the total mass is below the threshold, the requirement is satisfied
-
if the mass rises above it, the requirement fails
This shows how the BDD is not just a static architecture picture. When connected properly, it supports executable analysis and design evaluation.
Running Behavior with Context
The tutorial also demonstrates connecting a block to an activity diagram as its classifier behavior.
This allows the block to be run with context, meaning the behavior has access to the block’s value properties.
For example, if an iPhone block has a batteryPercentage value property, an activity can decrement that value over time during simulation.
If you run the activity without context, the behavior fails because the property is undefined.
This is an important lesson:
-
the BDD defines the structure and values
-
the behavior uses those values when run with context
Roll-Up Patterns in SysML
Another useful feature discussed is the ability to apply roll-up patterns such as:
-
cost roll-up
-
mass roll-up
-
power roll-up
These can automatically create subset properties and calculate totals.
This is very convenient for small examples, but the tutorial also gives a good caution: roll-up patterns can become difficult to understand in larger models because the logic is more hidden.
So while they are useful, they should be applied carefully and with awareness of the tradeoffs.
Interface Blocks and Constraint Blocks on a BDD
The tutorial also covers two special block types often shown on a BDD:
Interface Blocks
Interface blocks type proxy ports and help formalize interfaces between parts.
Constraint Blocks
Constraint blocks hold equations for parametric analysis.
For example, a simple sum constraint can be defined in a constraint block and then applied later in a parametric diagram.
This is a nice reminder that the BDD can serve as a central place for structural definitions, interface definitions, and analytical definitions.
Best Practices for SysML Block Definition Diagrams
Here are some practical takeaways from the tutorial.
Use directed relationships
Directed composition, directed aggregation, and directed association usually create clearer models than non-directed versions.
Favor composition for true structure
If an element is truly part of a system, directed composition is often the best relationship.
Use generalization to avoid duplication
If many specific classifiers share common properties, model those once in a general block and let the specifics inherit them.
Remember BDD = definition
Blocks define reusable things. They are not the same as part properties used on an IBD.
Connect the BDD to other diagrams
The real power of the BDD comes when it supports:
-
IBDs
-
parametric diagrams
-
requirements
-
behavior and simulation
Final Thoughts
The SysML block definition diagram is one of the most foundational tools in systems modeling. It defines the structural vocabulary of the system and creates the architecture that later supports internal structure, analysis, requirements, and simulation.
In this tutorial, we covered:
-
what a block definition diagram is
-
blocks and special types of blocks
-
value, part, and reference properties
-
composition, aggregation, association, and generalization
-
inheritance and reusable structure
-
how the BDD connects to IBDs, parametrics, behavior, and requirements
If you want to build strong SysML models, mastering the BDD is one of the best places to start.
Watch the full tutorial here: