Running Multi-Level SysML Simulations with Black Box and White Box Models

One of the powerful capabilities of SysML simulation in Cameo Systems Modeler is the ability to run simulations across multiple levels of system hierarchy while switching between Black Box and White Box models.

This technique allows system engineers to:

• Integrate subsystem models gradually

• Simulate partial architectures before all models are complete

• Roll up values (like mass, cost, or power) across system levels

• Toggle between simplified and detailed subsystem models

In this tutorial, we walk through a practical SysML modeling approach that enables multi-level simulation using Black Box and White Box blocks.

The example demonstrates how a top-level system can automatically aggregate subsystem values during simulation while allowing teams to swap between simplified and detailed subsystem representations.

---

Watch the Full Walkthrough

This article is based on the following tutorial video.

https://www.youtube.com/watch?v=jnMZp97d5No

In the video, we demonstrate how to:

• Structure projects for multiple teams

• Implement Black Box and White Box modeling

• Create parametric diagrams

• Run simulations across system hierarchy levels

• Roll up subsystem values to the system level

---

Understanding Black Box vs White Box Modeling in SysML

Before diving into simulation, it’s important to understand the Black Box vs White Box modeling concept.

These two modeling perspectives represent different levels of system visibility.

Black Box Modeling

A Black Box represents a system element without revealing its internal structure.

Characteristics:

• No internal part properties

• Represents external behavior or interface only

• Used for high-level abstraction

In the containment tree, a Black Box block will not contain any decomposed components.

---

White Box Modeling

A White Box exposes the internal structure of a system element.

Characteristics:

• Contains part properties

• Shows subsystem decomposition

• Enables internal analysis and simulation

White Box models allow engineers to examine how subsystems interact internally.

---

Hierarchical Levels in SysML System Modeling

Large systems are typically modeled across multiple hierarchical levels.

Example levels include:

At each level, a system can be represented using both:

• a Black Box block

• a White Box block

The White Box block typically inherits from the Black Box block through generalization relationships.

This allows engineers to maintain a consistent architecture while controlling how much detail is exposed.

---

Organizing Projects for Multiple Engineering Teams

In real programs, multiple engineering teams work on different parts of the system.

SysML projects help define the scope and responsibility of each team.

Example project structure:

Each project is responsible for specific parts of the containment tree.

For example:

• Project A manages the top-level system context

• Project B manages the system architecture

• Project C teams develop subsystem models

This structure allows teams to develop models independently while still integrating them into the overall architecture.

---

Integrating Supplier Subsystem Models

Subsystem teams often act as suppliers to the system engineering team.

They develop:

• subsystem architectures

• component models

• detailed simulations

These subsystem models are then integrated into the system model through composition relationships.

The system team can then run simulations using these subsystem models.

However, subsystem models are not always available at the same time.

This is where Black Box and White Box toggling becomes extremely useful.

---

Running SysML Simulations with Black Box and White Box Blocks

When running a simulation at the system level, you can dynamically choose whether to use:

• the Black Box representation

• the White Box implementation

For example:

You might run a system simulation using:

• Subsystem A → Black Box (placeholder estimate)

• Subsystem B → White Box (fully modeled)

• Subsystem C → White Box (fully modeled)

This allows engineers to simulate incomplete systems while subsystem teams continue development.

---

Using Abstract Blocks to Control Simulation Behavior

A useful technique is marking Black Box blocks as abstract.

When a block is marked Is Abstract = True, it becomes a pass-through element in simulation.

This means:

• the simulation automatically uses the White Box implementation

• the Black Box representation cannot run independently

This ensures simulations default to the most detailed available model.

---

Adding Value Properties for System Simulation

To perform meaningful simulations, we must add value properties to blocks.

In this example, we add a mass property to each subsystem.

Example:

Each subsystem then defines its own mass value.

Example values:

The goal is to automatically calculate the total system mass.

---

Creating Parametric Diagrams to Aggregate Values

To roll up subsystem values, we use SysML parametric diagrams.

A parametric diagram allows us to define constraints between value properties.

For this example, we create a constraint:

This constraint calculates the system mass by summing subsystem masses.

When connected properly in the parametric diagram, the simulation automatically aggregates these values.

---

Avoiding Duplicate Value Properties

When working across multiple levels of system hierarchy, duplicate value properties can occur due to inheritance.

To fix this, we use property redefinition.

This ensures that:

• inherited value properties

• locally defined value properties

represent the same variable in the simulation.

This step is critical for correct value roll-ups across system levels.

---

Running the System Simulation

Once the parametric relationships are established, we can run the simulation.

Example subsystem values:

The simulation automatically calculates:

The system White Box simulation then shows the total mass at the system level.

---

Scaling the Method Across the System Architecture

The same technique can be applied across the entire system hierarchy.

Each level can contain:

• subsystem parametric diagrams

• value property rollups

• system-level constraints

This allows values to propagate:

As a result, running the top-level system simulation can automatically pull values from lower-level models.

---

Handling Incomplete Subsystem Models

In real engineering programs, subsystem models are often delivered at different times.

Using the Black Box / White Box approach allows teams to continue simulation even when subsystem models are incomplete.

Example scenario:

Subsystem A model not ready yet.

Engineers can:

• keep Subsystem A as a Black Box

• assign a temporary estimated value

Meanwhile, Subsystem B and C can run their full White Box models.

This enables continuous system-level analysis throughout development.

---

Key Takeaways

This SysML modeling approach enables engineers to:

• Simulate across multiple system levels
• Integrate supplier subsystem models incrementally
• Roll up values across system hierarchy
• Toggle between Black Box and White Box implementations
• Continue simulation even when models are incomplete

These techniques are particularly valuable for large MBSE programs involving multiple teams and suppliers.

---

Learn More SysML Modeling Techniques

For more hands-on SysML tutorials, subscribe to the CameoMagic YouTube channel.

https://www.youtube.com/watch?v=jnMZp97d5No

You can find additional tutorials covering:

• SysML diagrams

• simulation techniques

• parametric modeling

• MBSE best practices

---

Final Thoughts

The ability to run multi-level simulations using Black Box and White Box models is one of the most powerful capabilities of SysML-based digital engineering.

By structuring projects correctly and leveraging parametric constraints, engineers can simulate systems even when parts of the architecture are still evolving.

This flexibility allows teams to perform system analysis earlier, identify issues sooner, and make better engineering decisions.