Length: 3 Days
SysML Training Crash Course
SysML is a general-purpose architecture modeling language for Systems Engineering applications.
Systems engineering is a field of engineering that deals with how to research, design and manage complex systems over their lifetime. It focuses on the whole system and typically involves a number of sub-disciplines including requirements, reliability, logistics, design, testing and maintenance; it requires sophisticated project management techniques.
Systems engineering not only deals with the problem of the system itself but also involves processes, optimization and risk management.
Enterprise Architect provides a platform for the system engineer using the Systems Modeling Language (SysML) and model based development, and in addition to the engineering models the tool provides support for project and process management.
The advantages of SysML over traditional approaches are considerable. For example, SysML provides the ability to have different views. When describing systems engineering projects, it is useful to have multiple views for different audiences and purposes.
Also, the use of a modeling language like SysML imposes a standard convention so that no matter which diagram the reader is looking at, the meaning of each symbol is unambiguous.
Additionally, SysML maintains consistency across all the views. The advantage of a modeling tool over these presentation or drawing tools is the model itself. If element names or relationships change over time, those changes are automatically propagated to all system views.
SysML gives you common rules, elements, and relationships to use to model your system. SysML are rules for drawing diagrams that help you communicate structure and behavior better than alternatives such as textual descriptions or naive block diagrams or traditional flow charts.
A useful starting point is with traditional flowcharts. SysML has a set of rules for Activity Diagrams. These are basically flowcharts that have benefits such as:
- Improved readability
- Improved express-ability
- Formalized so users can be more certain about meaning
Examples of improvements are a cleaner notation for decision branch points (no more trying to fit all your text inside an awkward diamond), support for parallel processes, and the potential for Petri Nets to be used to formalize meaning.
SysML and its predecessor UML can be used as part of sophisticated design processes but they can also be very successfully used in an ad-hoc manner to document processes (behaviors) and structures that need to be understood and agreed upon.
There are four sets of viewpoints that are captured in SysML:
- Structural – These viewpoints establish the definition of elements: the composition of systems, their properties and organizational grouping.
- Behavioral — Viewpoints that describe how these elements function.
- Requirements – These viewpoints allow for a systems engineer to create, relate, trace, and analyze the formal requirements within the SoS.
- Parametric – These viewpoints allow for the application of constraints on systems via logical and mathematical expressions.
SysML matches up well with MBSE and holds advantages over its predecessor, UML. For example, with SysML Requirement diagrams can be utilized to efficiently capture functional, performance and interface requirements, whereas with UML, systems engineers are subject to the limitations of use case diagrams to define high-level functional requirements.
SysML is also used with Parametric diagrams to precisely define performance and quantitative constraints like maximum acceleration, minimum curb weight, and total air conditioning capacity – this contrasted with UML which provides no straightforward mechanism to capture this sort of essential performance and quantitative information.
SysML Training Crash Course by Tonex
SysML Training Crash Course is a comprehensive 3-day training bootcamp. It provides the skills and knowledge to work with MBSE approach and SysML (Systems Modeling Language) diagrams Participants will learn how to work with modern systems engineering approach to create ConOps, Use Cases, Requirements, System Architecture and Design, Verification and Validation, and simulation.
SysML is based on UML and replaces the modeling of classes and objects by block modeling for a vocabulary more suited to systems engineering. A block encompasses all software, hardware, data, process and even people management concepts. SysML reuses part of UML2 and it also provides its own definitions (SysML extensions).
The term Model Based Systems Engineering (MBSE) is popular among systems engineers who advocate the use of SysML (Systems Modeling Language) as a standard architecture modeling language for systems engineering applications, and who want to distinguish their approach from Model-Driven Development and its variants, which tend to be software centric.
SysML supports the specification, analysis, design, verification and validation of a broad range of systems and systems-of-systems. These systems may include hardware, software, information, processes, personnel, and facilities.
SysML is a domain-specific language based on UML. It does this by specifying a superset of a subset of UML that takes the more generic UML and adapts it to the development of complex systems. As such, some elements are enhanced for that domain and others are not present.
SysML Training Crash Course helps you to make the appropriate architectural design of the system on the basis of your needs.
Such system architecture demonstrates a high level of agility to the embedded system software against changes as it provides a consistent traceability of the business rules captured in system functions and those of the usage choices (use cases) of the end-users toward the software implementation level.
TONEX SysML Training Crash Course Format
- The training is delivered in the form of interactive presentation
- The majority of the class is dedicated to practical activities
- The training is a combination of lectures, labs, individual/group activities, and hands-on workshops
- Participants are encouraged to bring in their own sample projects to work on under our instructors’ coaching, or they can use the real-world cases provided by our instructors
SysML Training Crash Course is a 3-day training course designed for:
- System analysts
- System architects
- Systems engineers
- Professionals moving into system-level engineering
- Managers who are responsible for the delivery of software intensive systems
Upon the completion of SysML Training Crash Course, the attendees are able to:
- Comprehend a general approach to MBSE
- Discuss various modeling techniques of the SysML
- Provide functional requirements
- Model dependencies between functional and non- functional requirements
- Model system structure by applying block diagrams with parts and ports
- Model physical and logical constraints, and studying trade-offs
- Assign functionality in use cases over the system parts
- Explain behavior by state machine diagrams
- Explain behavior by activity diagrams
- Address allocation of behavior, e.g. to software or hardware parts
- Apply appropriate heuristics and evaluation techniques to obtain high quality models
- Discuss the fundamental and the important detail of the Systems Modelling Language SysML
- Create and sustain a diagram of hierarchical and interdependent written requirements
- Generate and sustain traceability between requirements and produce reports of requirements and models
- Generate an overview of the external functional requirements of a system with actors and apply cases on a use case diagram
- Develop an efficient use case description in a satisfying way that pleases both non-technical and technical stakeholders
- Model high-level system framework and decomposition using block definition diagrams, blocks, ports and relationships
- Model the detailed internal framework of blocks on internal block diagrams using parts, ports, connectors and flows
- Describe structural and functional components and restrictions using constraint blocks, parametric diagrams and constraint properties
- Model simple, hierarchical and concurrent behavior using activities, actions, control and object flows on activity diagrams
- Model timing, interaction and messaging between actors, blocks and parts using synchronous and asynchronous messages on sequence diagrams
- Model state dependent behavior using states, transitions, events and actions on state machine diagrams
Overview of Modern Systems Engineering with MBSE and SysML
- Systems engineering definition
- Components of systems engineering
- System concepts
- SE process principles & elements
- Requirements analysis
- Development of physical solution description
- Development of logical solution description MBSE: (model-based architecting/design)
- System integration
- Verification and validation
- The system development life cycle with the harmony process
- Overview of the UML/SysML diagrams used in requirements gathering, system analysis and design of the System Engineering domain
- A Method based Framework for requirement gathering, system analysis and design
- SysML Language Architecture
- Design Principles
- Extension mechanisms
- SysML Diagrams
Overview of Model Elements
- Diagram Elements
- SysML Extensions
- Diagram Extensions
- Ports and Flows
- Diagram Elements
- Block Definition Diagram
- Internal Block Diagrams
- Constraint Blocks
- State Machines
- Use Cases
Gathering Requirements and Translating Them into System Specifications
- How to trace business and system requirements using the SysML requirement diagram
- How to define the scope of the system included functions and use cases that invoke these functions
- How to model the Life Cycle of the System that organizes transitions between its states where functions are activated
- Testing cases by scenarios that recognize Use Cases and System Functions
Profiles & Model Libraries
- Diagram Elements
- Profile Definition in Package Diagram
- Stereotypes Used On Diagrams
- Usage Examples
- Defining a Profile
- Adding Stereotypes to a Profile
- Defining a Model Library that Uses a Profile
- Guidance on Whether to Use a Stereotype or Class
- Using a Profile
- Using a Stereotype
- Using a Model Library Element
Transforming System Specifications into Design Level Components
- How to model the Block Diagram of the system and modify it by internal blocks
- How to develop the Communication Architecture between Sub-System using Parts, Ports and Interfaces
- How to model the description of white box Interactions in the design stage
- How to Map Operations on the Components (Parts) of Blocks
- Developing the Parametric Diagram of the System Functions
Workshops and Hands-on Activities (Using Cameo/Magic Draw or Medelio)
Workshop 1: SysML to Model Specification, Analysis, and Design of a System
- Problem Summary
- Package Overview (Structure of the Sample Model)
- Package Diagram – Applying the SysML Profile
- Defining value Types and Units to be Used in the Problem
- Package Diagram
- Establishing Structure of the User Model using Packages and Views (Package Diagram)
- Setting the Context (Boundaries and Use Cases)
- Internal Block Diagram – Setting Context
- Establishing the Context of a System using a User-Defined Context Diagram. (Internal Block
- Completeness of Diagram Noted in Diagram Description
- Use Case Diagram – Top Level Use Cases
- Establishing Top Level Use Cases for the Hybrid SUV (Use Case Diagram)
- Use Case Diagram – Operational Use Cases
- Elaborating Behavior (Sequence and State Machine Diagrams)
- Sequence Diagram – Drive Black Box
- Elaborating Black Box Behavior
- Finite State Machine (State Machine Diagram)
- Sequence Diagram – Black Box & White Box
Workshop 2: Agile System Engineering with MBSE and SysML
- Agile System Requirements Evaluation
- Agile Systems Architectural Evaluation
- Agile Systems Architectural Design
- Downstream Systems Engineering Applications
- Context Diagram (ibd or bdd)
- Use Case Diagrams
- Requirements Diagrams
- Modeling System Objectives
- Stakeholders Requirements
- System Requirements
- Functional Requirements
- Non-Functional Requirements (NFR)
- Part Catalogs
- Testing and Simulation
Workshop 3: Creating SysML Diagrams for a System of Systems (SoS)
- Blocks and Block Definition Diagrams
- Packages and Use Cases
- Requirements and Sequence Diagrams
- Analysis Parametric Diagrams
- Activities and Activity Diagrams
- Internal Block Diagrams
- State Machines and Advanced Interactions
- Establishing Requirements (Requirements Diagrams and Tables)
- Requirement Diagram – Requirement Hierarchy
- Requirement Diagram – Derived Requirements
- Establishing Derived Requirements and Rationale from Lowest Tier of Requirements Hierarchy (Requirements Diagram)
- Requirements Table
- Requirements Relationships Expressed in Tabular Format (Table)
- Breaking Down the Pieces (Block Definition Diagrams, Internal Block Diagrams)
- Block Definition Diagram – Automotive Domain
- Defining the System Domain (Block Definition Diagram)
- Internal Block Diagram
- Internal Structure of the Power Subsystem (Internal Block Diagram)
- Interfaces Typing Standard Ports Internal to the Subsystem (Block Definition Diagram)
- Defining Ports and Flows
- Parametric Diagram
- Detailed Internal Structure of Fuel Delivery Subsystem (Internal Block Diagram)
- Analyze Performance (Constraint Diagrams, Timing Diagrams, Views)
- Block Definition Diagram – Analysis Context
- Package Diagram – Performance View Definition
- Parametric Diagram – Measures of Effectiveness
- Establishing Mathematical Relationships for Fuel Economy Calculations (Parametric Diagram)
- Parametric Diagram – Dynamics
- Defining, Decomposing, and Allocating Activities
- Activity Diagram – Acceleration (top level)
- Detailed Behavior Model for “Provide Power” (Activity Diagram)
- Note hierarchical consistency with Figure 33.
- Internal Block Diagram – Power Subsystem Behavioral and Flow Allocation
- Flow Allocation to Power Subsystem (Internal Block Diagram)
- Acceleration Allocation
Workshop 4: Model Creation Process and Guidance
- Model Organization
- Planning Artifacts
- System Specification and Design Process
- Model Organization
- Derived Mission Requirements
- Supporting Elements (Interface Definition)
- Creating Custom Libraries and Stereotypes
- Failure modes
- Test component
- Verification objectives
Workshop 5: Architecting Complex Systems with MBSE and SysML
- Creating Model Organization
- User Requirements
- Operational Use Cases
- Modeling the Behavior
- Analysis of the Models
- System Specification and Design Process
- System of Systems (SoS), Systems and Subsystems
- Interface Definitions
- Models to Support Specifications, Integration and Testing
About MBSE, UML, SysML
While UML is software-centric, SysML is more engineering systems-oriented. For example, SysML is used in system level design of System on Chips. SysML provides graphical representations based on a semantic foundation for modelling system behavior, requirements, structure, and parametrical elements which are used to integrate with other engineering analysis models using the OML XML Metadata Interchange.
Some advantages SysML has over UML include:
- SysML’s semantics are more flexible and expressive. SysML reduces UML’s software-centric restrictions and adds two new diagram types, requirement and parametric diagrams. The former can be used for requirements engineering; the latter can be used for performance analysis and quantitative analysis. Consequent to these enhancements, SysML is able to model a wide range of systems, which may include hardware, software, information, processes, personnel and facilities.
- SysML is a comparatively little language that is easier to learn and apply. Since SysML removes many of UML’s software-centric constructs, the overall language measures smaller both in diagram types and total constructs.
- SysML allocation tables support common kinds of allocations. Whereas UML provides only limited support for tabular notations, SysML furnishes flexible allocation tables that support requirements allocation, functional allocation and structural allocation. This capability facilitates automated verification and validation (V&V) and gap analysis.
- SysML model management constructs support models, views and viewpoints. These constructs extend UML’s capabilities and are architecturally aligned with IEEE-Std-1471-2000 (IEEE Recommended Practice for Architectural Description of Software Intensive Systems).
Many companies, particularly those in aerospace, telecommunications, defense and automotive, have switched over to SysML (Systems Modeling Language).
Both the definition and maintenance of SysML is overseen by the Object Management Group (OMG), which describes itself as an international, open membership, not-for-profit technology standards consortium, founded in 1989.