In today’s rapidly evolving engineering landscape, the complexity of cyber-physical systems—from autonomous drones to smart vehicles—demands modeling languages that are both precise and accessible. SysML v2 represents a paradigm shift in Model-Based Systems Engineering (MBSE), introducing a standardized textual syntax that complements traditional graphical diagrams . This textual approach enables engineers to write system specifications as readable code, facilitating version control, automated analysis, and seamless integration with modern development toolchains.
This case study walks through the design of a Smart Drone System using SysML v2 textual notation. We’ll demonstrate how the language’s four core pillars—Requirements, Structure, Behavior, and Verification—translate into practical, executable specifications. Whether you’re a systems engineer transitioning from SysML v1 or a software developer exploring MBSE, this guide provides the foundational knowledge to model complex systems with confidence.
By the end of this article, you will understand:
How to define system components using Definition vs. Usage patterns
How to express hierarchy through Specialization and Redefinition
How to specify component quantities with Multiplicity constraints
How to embed mathematical logic and safety constraints directly in your model
How to document and annotate models for team collaboration
Let’s build a Smart Drone System—from concept to verified specification.
SysML v2 organizes system modeling into four interconnected domains, all expressed through a unified textual language :
| Pillar | Purpose | Key Constructs |
|---|---|---|
| Requirements | Define system constraints and verification criteria | requirement def, constraint expressions, assumed conditions |
| Structure | Handle system decomposition, interconnection, and classification | part def, port def, connection def, specialization (:>), redefinition (:>>) |
| Behavior | Model function-based, state-based, sequence-based, and use case actions | action def, state def, transition, occurrence |
| Verification | Validate that designs satisfy requirements through analysis cases | verification case, analysis case, test scenarios |
Keep your models readable and maintainable:
// Line note: Single-line comment (ignored by parsers)
//* Block note: Multi-line descriptive text */
/* Comment: Standard block comment for model annotations */
doc /* Documentation: Formal description attached to model elements */
The cornerstone of SysML v2’s reusable architecture:
// Definition: Create a reusable blueprint
part def Vehicle {
attribute fuelType;
}
// Usage: Instantiate the blueprint in context
part myCar : Vehicle;
// Specialization: Create a specialized subtype
part def SportsCar :> Vehicle;
// Redefinition: Override inherited features
part def ElectricCar :> Vehicle {
:>> fuelType = “electric”; // Successfully overrides inherited attribute
}
Organize large models with modular packages:
private import ISQ::*; // Import all from International System of Quantities
alias qualifiedRef for ISQ::MassValue; // Correct way to declare an alias
Specify exactly how many instances are required:
part def Vehicle {
part wheels : Wheel [4]; // Exactly 4 wheels
part sensors : ObstacleSensor [2..*]; // At least 2, unlimited max
part cargo : CargoBay [0..1]; // Optional: 0 or 1
}
// Stub definitions to ensure the types exist
part def Wheel;
part def ObstacleSensor;
part def CargoBay;
Embed engineering logic directly in your model:
private import SI::*; // Import SI units library
private import ISQ::*; // Import international System of Quantities library
private import ScalarValues::*; // Bring ‘Real’, ‘Integer’, ‘String’, etc. into scope
@Approval {
author = “Engineering Team”;
version = “2.1”;
}
part def FlightSystem {
// Corrected: Use the ‘default’ keyword to assign values inside definitions
attribute mass : MassValue default 1500 [kg];
// Declare attributes used in the constraint expression
attribute currentAltitude : Real;
attribute maxAltitude : Real;
// Boolean constraint expression
assert constraint { currentAltitude <= maxAltitude }
}
// Define as a ‘metadata def’
metadata def Approval {
attribute author;
attribute version;
}
Before building components, define their blueprints. This separation enables reuse across projects.
package DroneSystem {
private import ISQ::*; // Import System of Quantities value types
private import SI::*; // Import SI units for [kg], [min], [W]
// === DEFINITIONS (Reusable Blueprints) ===
part def Drone {
attribute maxPayload : MassValue; // Use MassValue instead of Mass
attribute batteryLife : TimeValue; // Use TimeValue instead of Time
port commandPort : CommandInterface;
}
port def CommandInterface;
part def Controller {
attribute processingPower : PowerValue; // Use PowerValue instead of Power
action processSensorData; // Remove empty parentheses
}
part def Propeller {
attribute diameter : LengthValue; // Use LengthValue instead of Length
attribute maxRPM : FrequencyValue; // Use FrequencyValue instead of Frequency
}
// === USAGE (Concrete System Instance) ===
part def SmartDroneSystem {
part primaryDrone : Drone {
:>> maxPayload = 2.5 [kg];
:>> batteryLife = 45 [min];
}
part flightController : Controller {
// Remove ‘attribute’ prefix keyword during direct feature redefinitions
:>> processingPower = 15 [W];
}
part propellers : Propeller [4]; // Quadcopter configuration
}
}
SysML v2’s textual syntax represents more than a notational change—it’s a fundamental evolution in how we specify, analyze, and verify complex systems. By treating system models as executable code, engineers gain:
✅ Precision: Unambiguous specifications with formal semantics
✅ Automation: Direct integration with CI/CD pipelines and analysis tools
✅ Collaboration: Git-friendly models with diff/merge support
✅ Reusability: Library-based components with clear interfaces
✅ Traceability: Requirements linked directly to design and verification
The Smart Drone System case study demonstrates that SysML v2 is not just theoretically powerful but practically applicable. From defining component hierarchies to embedding safety constraints and verification scenarios, the textual syntax enables end-to-end model-based engineering.
As the OMG finalizes the SysML v2 specification, early adopters who master this textual approach will lead the next wave of MBSE innovation. Start small: model a single subsystem, validate a critical constraint, or automate a verification check. The journey from blueprint to code begins with a single part def.
