You are previewing A Practical Guide to SysML: The Systems Modeling Language.
O'Reilly logo
A Practical Guide to SysML: The Systems Modeling Language

Book Description

Systems engineers and architects must understand how all the parts of a system work together to satisfy its requirements. SysML is a general purpose graphical modeling language used to specify, analyze, and design systems that may include hardware, software, and personnel. It allows engineers to describe how a system interacts with its environment, and how its parts must interact to achieve the desired system behavior and performance. The SysML model provides a shared view of the system, enabling a design team to surface issues early and prevent problems that would otherwise delay development and degrade design quality. Since SysML is based on UML, it also facilitates integration between systems and software development. SysML is now being adopted by companies across a broad range of industry, including Aerospace and Defense, Automotive, and IT System Developers. This book provides a comprehensive and practical guide for modeling systems with SysML. It includes a full description of the language along with a quick reference guide, and shows how the language can be applied to specify, analyze, and design systems. It contains examples to help readers understand how SysML can be used in practice. The book also includes guidance on how an organization or project can transition to model based systems engineering using SysML, with considerations for processes, methods, tools, and training.

Table of Contents

  1. Copyright
  2. Morgan Kaufmann OMG Press
  3. Preface
    1. Acknowledgments
  4. About the Authors
  5. I. Introduction
    1. 1. Systems Engineering Overview
      1. 1.1. Motivation for Systems Engineering
      2. 1.2. The Systems Engineering Process
      3. 1.3. Typical Application of the Systems Engineering Process
      4. 1.4. Multidisciplinary Systems Engineering Team
      5. 1.5. Codifying Systems Engineering Practice through Standards
      6. 1.6. Summary
      7. 1.7. Questions
    2. 2. Model-Based Systems Engineering
      1. 2.1. Contrasting the Document-Based and Model-Based Approach
        1. 2.1.1. Document-Based Systems Engineering Approach
        2. 2.1.2. Model-Based Systems Engineering Approach
          1. The System Model
          2. The Model Repository
          3. Transitioning to MBSE
      2. 2.2. Modeling Principles
        1. 2.2.1. Model and MBSE Method Definition
        2. 2.2.2. The Purpose for Modeling a System
        3. 2.2.3. Establishing Criteria to Meet the Model Purpose
          1. Is the model’s scope sufficient to meet its purpose?
          2. Is the model complete relative to its scope?
          3. Is the model well formed such that model constraints are adhered to?
          4. Is the model consistent?
          5. Is the model understandable?
          6. Are modeling conventions documented and used consistently?
          7. Is the model self-documenting in terms of providing sufficient supporting information?
          8. Does the model integrate with other models?
        4. 2.2.4. Model-Based Metrics
          1. What is the quality of the design?
          2. What is the progress of the design and development effort?
          3. What is the estimated effort to complete design and development?
        5. 2.2.5. Other Model-Based Metrics
      3. 2.3. Summary
      4. 2.4. Questions
    3. 3. SysML Language Overview
      1. 3.1. SysML Purpose and Key Features
      2. 3.2. SysML Diagram Overview
      3. 3.3. Using SysML in Support of MBSE
      4. 3.4. A Simple Example Using SysML for an Automobile Design
        1. 3.4.1. Example Background and Scope
        2. 3.4.2. Problem Summary
        3. 3.4.3. Capturing the Automobile Specification in a Requirement Diagram
        4. 3.4.4. Defining the Vehicle and Its External Environment Using a Block Definition Diagram
        5. 3.4.5. Use Case Diagram for Operate Vehicle
        6. 3.4.6. Representing Drive Vehicle Behavior with a Sequence Diagram
        7. 3.4.7. Referenced Sequence Diagram to Start Vehicle
        8. 3.4.8. Control Power Activity Diagram
        9. 3.4.9. State Machine Diagram for Drive Vehicle States
        10. 3.4.10. Vehicle Context Using an Internal Block Diagram
        11. 3.4.11. Vehicle Hierarchy Represented on a Block Definition Diagram
        12. 3.4.12. Activity Diagram for Provide Power
        13. 3.4.13. Internal Block Diagram for the Power Subsystem
        14. 3.4.14. Defining the Equations to Analyze Vehicle Performance
        15. 3.4.15. Analyzing Vehicle Acceleration Using the Parametric Diagram
        16. 3.4.16. Analysis Results from Analyzing Vehicle Acceleration
        17. 3.4.17. Using the Vehicle Controller to Optimize Engine Performance
        18. 3.4.18. Specifying the Vehicle and Its Components
        19. 3.4.19. Requirements Traceability
        20. 3.4.20. Package Diagram for Organizing the Model
        21. 3.4.21. Model Interchange
      5. 3.5. Summary
      6. 3.6. Questions
  6. II. Language Description
    1. 4. SysML Language Architecture
      1. 4.1. The OMG SysML Language Specification
      2. 4.2. The Architecture of the SysML Language
        1. 4.2.1. The General-Purpose Systems Modeling Domain
        2. 4.2.2. The Modeling Language (or Metamodel)
        3. 4.2.3. The System Model (or User Model)
        4. 4.2.4. Model Interchange
      3. 4.3. SysML Diagrams
        1. 4.3.1. Diagram Frames
        2. 4.3.2. Diagram Header
          1. Diagram Kind
          2. Model Element Type
          3. Diagram Name
          4. Diagram Usage
        3. 4.3.3. Diagram Description
        4. 4.3.4. Diagram Content
          1. Properties and Keywords
          2. Node Symbols
          3. Path Symbols
          4. Icon Symbols
          5. Note Symbols
        5. 4.3.5. Additional Notations
      4. 4.4. The Surveillance System Case Study
        1. 4.4.1. Case Study Overview
        2. 4.4.2. Modeling Conventions
      5. 4.5. Chapter Organization for Part II
      6. 4.6. Questions
        1. Discussion Topics
    2. 5. Organizing the Model with Packages
      1. 5.1. Overview
      2. 5.2. The Package Diagram
      3. 5.3. Defining Packages Using a Package Diagram
      4. 5.4. Organizing a Package Hierarchy
      5. 5.5. Showing Packageable Elements on a Package Diagram
      6. 5.6. Packages as Namespaces
      7. 5.7. Importing Model Elements into Packages
      8. 5.8. Showing Dependencies between Packageable Elements
      9. 5.9. Specifying Views and Viewpoints
      10. 5.10. Summary
      11. 5.11. Questions
        1. Discussion Topic
    3. 6. Modeling Structure with Blocks
      1. 6.1. Overview
        1. 6.1.1. Block Definition Diagrams
        2. 6.1.2. Internal Block Diagram
      2. 6.2. Modeling Blocks on a Block Definition Diagram
      3. 6.3. Modeling the Structure and Characteristics of Blocks Using Properties
        1. 6.3.1. Modeling Block Composition Hierarchies Using Part Properties
          1. Composite Associations
          2. Modeling Parts on an Internal Block Diagram
          3. Connecting Parts on an Internal Block Diagram
          4. Modeling Deeply Nested Structures and Connectors
        2. 6.3.2. Modeling Noncomposite Relationships between Blocks Using Reference Properties
          1. Reference Associations
          2. Modeling Reference Properties on Internal Block Diagrams
          3. Using Associations to Define Common Features of Connectors
          4. Association Blocks
        3. 6.3.3. Modeling Quantifiable Characteristics of Blocks Using Value Properties
          1. Modeling Value Types on a Block Definition Diagram
          2. Adding Units and Dimensions to Value Types
          3. The SI Standard for Units and Dimensions
          4. Adding Value Properties to Blocks
          5. Derived Properties
          6. Modeling Property Values and Distributions
      4. 6.4. Modeling Interfaces Using Ports and Flows
        1. 6.4.1. Modeling Items that Flow
        2. 6.4.2. Modeling Flows between Internal Block Diagram Parts
        3. 6.4.3. Modeling Flow-Based Interfaces Using Flow Ports
          1. Atomic Flow Ports
          2. Nonatomic Flow Ports
          3. Connecting Flow Ports on an Internal Block Diagram
          4. Delegating Responsibility between Ports
          5. Modeling Flows between Ports
      5. 6.5. Modeling Block Behavior
        1. 6.5.1. Modeling the Main Behavior of a Block
        2. 6.5.2. Specifying the Behavioral Features of Blocks
        3. 6.5.3. Modeling Service-Based Interfaces Using Standard Ports
          1. Modeling Interfaces
          2. Adding Interfaces to Standard Ports
        4. 6.5.4. Connecting Standard Ports on an Internal Block Diagram
        5. 6.5.5. Modeling Block-Defined Methods
      6. 6.6. Modeling Classification Hierarchies Using Generalization
        1. 6.6.1. Classification and the Structural Features of a Block
        2. 6.6.2. Modeling Overlapping Classifications Using Generalization Sets
        3. 6.6.3. Modeling Variants Using Classification
        4. 6.6.4. Using Property-Specific Types to Model Context-Specific Block Characteristics
        5. 6.6.5. Modeling Block Configurations as Specialized Blocks
          1. Modeling a Configuration on a Block Definition Diagram
          2. Modeling Configuration Details on an Internal Block Diagram
        6. 6.6.6. Classification and Behavioral Features
      7. 6.7. Summary
      8. 6.8. Questions
        1. Discussion Topic
    4. 7. Modeling Constraints with Parametrics
      1. 7.1. Overview
        1. 7.1.1. Defining Constraints Using the Block Definition Diagram
        2. 7.1.2. The Parametric Diagram
      2. 7.2. Using Constraint Expressions to Represent System Constraints
      3. 7.3. Encapsulating Constraints in Constraint Blocks to Enable Reuse
        1. 7.3.1. Additional Parameter Characteristics
      4. 7.4. Using Composition to Build Complex Constraint Blocks
      5. 7.5. Using a Parametric Diagram to Bind Parameters of Constraint Blocks
      6. 7.6. Constraining Value Properties of a Block
      7. 7.7. Capturing Values in Block Configurations
      8. 7.8. Constraining Time-Dependent Properties to Facilitate Time-Based Analysis
      9. 7.9. Using Constraint Blocks to Constrain Item Flows
      10. 7.10. Describing an Analysis Context
      11. 7.11. Modeling Evaluation of Alternatives and Trade Studies
      12. 7.12. Summary
      13. 7.13. Questions
        1. Discussion Topics
    5. 8. Modeling Flow-Based Behavior with Activities
      1. 8.1. Overview
      2. 8.2. The Activity Diagram
      3. 8.3. Actions—The Foundation of Activities
      4. 8.4. The Basics of Modeling Activities
        1. 8.4.1. Specifying input and Output Parameters for an Activity
        2. 8.4.2. Composing Activities Using Call Behavior Actions
      5. 8.5. Using Object Flows to Describe the Flow of Items between Actions
        1. 8.5.1. Routing Object Flows
        2. 8.5.2. Routing Object Flows from Parameter Sets
        3. 8.5.3. Buffers and Data Stores
      6. 8.6. Using Control Flows to Specify the Order of Action Execution
        1. 8.6.1. Depicting Control Logic with Control Nodes
        2. 8.6.2. Using Control Operators to Enable and Disable Actions
      7. 8.7. Handling Signals and Other Events
      8. 8.8. Advanced Activity Modeling
        1. 8.8.1. Interruptible Regions
        2. 8.8.2. Modeling Flow Rates and Flow Order
          1. Flow Rates
          2. Flow Order
        3. 8.8.3. Modeling Probabilistic Flow
        4. 8.8.4. Modeling Pre- and Postconditions and Input and Output States
      9. 8.9. Relating Activities to Blocks and Other Behaviors
        1. 8.9.1. Linking Behavior to Structure Using Partitions
        2. 8.9.2. Specifying an Activity in a Block Context
          1. Activities as Block Behaviors
          2. Activities as Methods
        3. 8.9.3. Relationship between Activities and Other Behaviors
      10. 8.10. Modeling Activity Hierarchies Using Block Definition Diagrams
        1. 8.10.1. Modeling Activity Invocation Using Composite Associations
        2. 8.10.2. Modeling Parameter and Other Object Nodes Using Associations
      11. 8.11. Enhanced Functional Flow Block Diagram
      12. 8.12. Executing Activities
        1. 8.12.1. Primitive Actions
        2. 8.12.2. Executing Continuous Activities
      13. 8.13. Summary
      14. 8.14. Questions
        1. Discussion Topic
    6. 9. Modeling Message-Based Behavior with Interactions
      1. 9.1. Overview
      2. 9.2. The Sequence Diagram
      3. 9.3. The Context for Interactions
      4. 9.4. Using Lifelines to Represent Participants in an Interaction
        1. 9.4.1. Events and Occurrences
      5. 9.5. Exchanging Messages between Lifelines
        1. 9.5.1. Synchronous and Asynchronous Messages
        2. 9.5.2. Lost and Found Messages
        3. 9.5.3. Weak Sequencing
        4. 9.5.4. Executions
        5. 9.5.5. Create and Destroy Messages
      6. 9.6. Representing Time on a Sequence Diagram
      7. 9.7. Describing Complex Scenarios Using Combined Fragments
        1. 9.7.1. Basic Interaction Operators
        2. 9.7.2. Additional Interaction Operators
        3. 9.7.3. State Invariants
      8. 9.8. Using Interaction References to Structure Complex Interactions
      9. 9.9. Decomposing Lifelines to Represent Internal Behavior
      10. 9.10. Summary
      11. 9.11. Questions
        1. Discussion Topic
    7. 10. Modeling Event-Based Behavior with State Machines
      1. 10.1. Overview
      2. 10.2. State Machine Diagram
      3. 10.3. Specifying States in a State Machine
        1. 10.3.1. Region
        2. 10.3.2. State
      4. 10.4. Transitioning between States
        1. 10.4.1. Transition Fundamentals
          1. Trigger
          2. Guard
          3. Effect
          4. Transition Notation
        2. 10.4.2. Routing Transitions Using Pseudostates
        3. 10.4.3. Showing Transitions Graphically
      5. 10.5. State Machines and Operation Calls
      6. 10.6. State Hierarchies
        1. 10.6.1. Composite State with a Single Region
        2. 10.6.2. Composite State with Multiple (Orthogonal) Regions
        3. 10.6.3. Transition Firing Order in Nested State Hierarchies
        4. 10.6.4. Using the History Pseudostate to Return to a Previously Interrupted State
        5. 10.6.5. Reusing State Machines
          1. Entry and Exit Points on State Machines
          2. Submachine States
          3. Entry- and Exit-Point Pseudostates on Composite States
      7. 10.7. Contrasting Discrete versus Continuous States
      8. 10.8. Summary
      9. 10.9. Questions
        1. Discussion Topic
    8. 11. Modeling Functionality with Use Cases
      1. 11.1. Overview
      2. 11.2. Use Case Diagram
      3. 11.3. Using Actors to Represent the Users of a System
        1. 11.3.1. Further Descriptions of Actors
      4. 11.4. Using Use Cases to Describe System Functionality
        1. 11.4.1. Use Case Relationships
          1. Inclusion
          2. Extension
          3. Classification
        2. 11.4.2. Use Case Descriptions
      5. 11.5. Elaborating Use Cases with Behaviors
        1. 11.5.1. Context Diagrams
        2. 11.5.2. Sequence Diagrams
        3. 11.5.3. Activity Diagrams
        4. 11.5.4. State Machine Diagrams
      6. 11.6. Summary
      7. 11.7. Questions
        1. Discussion Topics
    9. 12. Modeling Text-Based Requirements and Their Relationship to Design
      1. 12.1. Overview
      2. 12.2. Requirement Diagram
      3. 12.3. Representing a Text Requirement in the Model
      4. 12.4. Types of Requirements Relationships
      5. 12.5. Representing Cross-Cutting Relationships in SysML Diagrams
        1. 12.5.1. Depicting Requirements Relationships Directly
        2. 12.5.2. Depicting Requirements Relationships Using Compartment Notation
        3. 12.5.3. Depicting Requirements Relationships Using Callout Notation
      6. 12.6. Depicting Rationale for Requirements Relationships
      7. 12.7. Depicting Requirements and Their Relationships in Tables
        1. 12.7.1. Depicting Requirement Relationships in Tables
        2. 12.7.2. Depicting Requirement Relationships as Matrices
      8. 12.8. Modeling Requirement Hierarchies in Packages
      9. 12.9. Modeling a Requirements Containment Hierarchy
        1. 12.9.1. The Browser View of a Containment Hierarchy
      10. 12.10. Modeling Requirement Derivation
      11. 12.11. Asserting That a Requirement Is Satisfied
      12. 12.12. Verifying That a Requirement Is Satisfied
      13. 12.13. Reducing Requirements Ambiguity Using the Refine Relationship
      14. 12.14. Using the General-Purpose Trace Relationship
        1. 12.14.1. Reusing Requirements with the Copy Relationship
      15. 12.15. Summary
      16. 12.16. Questions
        1. Discussion Topics
    10. 13. Modeling Cross-Cutting Relationships with Allocations
      1. 13.1. Overview
      2. 13.2. Allocation Relationship
      3. 13.3. Allocation Notation
      4. 13.4. Types of Allocation
        1. 13.4.1. Allocation of Requirements
        2. 13.4.2. Allocation of Behavior or Function
        3. 13.4.3. Allocation of Flow
        4. 13.4.4. Allocation of Structure
        5. 13.4.5. Allocation of Properties
        6. 13.4.6. Summary of Relationships Associated with the Term “Allocation”
      5. 13.5. Planning for Reuse: Specifying Definition and Usage in Allocation
        1. 13.5.1. Allocating Usage
        2. 13.5.2. Allocating Definition
        3. 13.5.3. Allocating Asymmetrically
        4. 13.5.4. Guidelines for Allocating Definition and Usage
      6. 13.6. Allocating Behavior to Structure Using Functional Allocation
        1. 13.6.1. Modeling Functional Allocation of Usage
        2. 13.6.2. Modeling Functional Allocation of Definition
        3. 13.6.3. Notational Simplicity: Modeling Functional Allocation Using Allocate Activity Partitions (Swimlanes)
      7. 13.7. Connecting Functional Flow with Structural Flow Using Functional Flow Allocation
        1. 13.7.1. Options for Functionally Allocating Flow
        2. 13.7.2. Allocating an Object Flow to a Connector
        3. 13.7.3. Allocating Object Flow to Item Flow
      8. 13.8. Modeling Allocation between Independent Structural Hierarchies
        1. 13.8.1. Modeling Structural Allocation of Usage
        2. 13.8.2. Allocating a Logical Connector to a Physical Structure
        3. 13.8.3. Modeling Structural Allocation of Definition
      9. 13.9. Modeling Structural Flow Allocation
      10. 13.10. Evaluating Allocation across a User Model
        1. 13.10.1. Establishing Balance and Consistency
      11. 13.11. Taking Allocation to the Next Step
      12. 13.12. Summary
      13. 13.13. Questions
        1. Discussion Topics
    11. 14. Customizing SysML for Specific Domains
      1. 14.1. Overview
        1. 14.1.1. A Brief Review of Metamodeling Concepts
      2. 14.2. Defining Model Libraries to Provide Reusable Constructs
      3. 14.3. Defining Stereotypes to Extend Existing SysML Concepts
        1. 14.3.1. Adding Properties and Constraints to Stereotypes
      4. 14.4. Extending the SysML Language Using Profiles
        1. 14.4.1. Specifying a Profile’s Reference Metamodel and Other Inputs
      5. 14.5. Applying Profiles to User Models in Order to Use Stereotypes
      6. 14.6. Applying Stereotypes when Building a Model
        1. 14.6.1. What Happens When Model Elements with Applied Stereotypes Are Specialized?
      7. 14.7. Summary
      8. 14.8. Questions
        1. Discussion Topics
  7. III. Modeling Examples
    1. 15. Water Distiller Example Using Functional Analysis
      1. 15.1. Stating the Problem
      2. 15.2. Defining the Model-Based Systems Engineering Approach
      3. 15.3. Organizing the Model
      4. 15.4. Establishing Requirements
      5. 15.5. Modeling Behavior
        1. 15.5.1. Simple Behavior
        2. 15.5.2. Parallel Flow
        3. 15.5.3. Continuous Flow
        4. 15.5.4. Allocated Flow
      6. 15.6. Modeling Structure
        1. 15.6.1. Defining Distiller’s Blocks in the Block Definition Diagram
        2. 15.6.2. Defining the Ports on the Blocks
        3. 15.6.3. Creating the Internal Block Diagram with Parts, Connectors, and Item Flows
        4. 15.6.4. Allocation of Actions and Flows
      7. 15.7. Analyzing Performance
        1. 15.7.1. Item Flow Heat Balance Analysis
        2. 15.7.2. Resolving Heat Balance
      8. 15.8. Modifying the Original Design
        1. 15.8.1. Updating Behavior
        2. 15.8.2. Updating Allocation and Structure
        3. 15.8.3. Controlling the Distiller and the User Interaction
        4. 15.8.4. Developing a User Interface and a Controller
        5. 15.8.5. Startup and Shutdown Considerations
      9. 15.9. Summary
      10. 15.10. Questions
    2. 16. Residential Security System Example Using the Object-Oriented Systems Engineering Method
      1. 16.1. Method Overview
        1. 16.1.1. Motivation and Background
        2. 16.1.2. System Development Process Overview
          1. Manage System Development
          2. Specify and Design System
          3. Develop Hardware, Software, Database, and Operational Procedures
          4. Integrate and Verify System
          5. 16.1.3. OOSEM System Specification and Design Process
      2. 16.2. Residential Security Example Overview and Project Setup
        1. 16.2.1. Problem Background
        2. 16.2.2. Modeling Conventions and Standards
        3. 16.2.3. Model Organization
      3. 16.3. Applying the Method to Specify and Design the System
        1. 16.3.1. Analyze Stakeholder Needs
          1. Characterize As-Is System and Enterprise
          2. Perform Causal Analysis
          3. Specify Mission Requirements
          4. Capture Measures of Effectiveness
          5. Define To-Be Domain Model
          6. Define Enterprise Use Cases
        2. 16.3.2. Analyze System Requirements
          1. Define Enterprise Scenarios
          2. Define System Context
          3. Capture Critical System Properties and Constraints
          4. Specify Black-Box System Requirements
          5. Define System State Machine
          6. Analyze System Requirements Variation
          7. Identify System Design Constraints
        3. 16.3.3. Define Logical Architecture
          1. Define Logical Decomposition
          2. Define Interaction between Logical Components to Realize System Activity and/or Operation
          3. Define System Logical Internal Block Diagram
          4. Specify Logical Components
          5. Define Logical Component State Machine
        4. 16.3.4. Synthesize Candidate Physical Architectures
          1. Define Partitioning Criteria
          2. Define Logical Node Architecture
          3. Define Physical Node Architecture
          4. Define Software Architecture
          5. Define Data Architecture
          6. Define Hardware Architecture
          7. Define Operational Procedures
          8. Specify Component Requirements
          9. Defining Other Architecture Views
        5. 16.3.5. Optimize and Evaluate Alternatives
          1. Identify Analyses to Be Performed
          2. Define the Analysis Context
          3. Capture Constraints in Parametric Diagram
          4. Perform Engineering Analysis
        6. 16.3.6. Manage Requirements Traceability
          1. Define Specification Tree
          2. Capture Text-Based Requirements in Model
          3. Establish Requirements Relationships and Rationale
          4. Analyze Traceability Gaps
          5. Managing Requirements Updates
        7. 16.3.7. Integrate and Verify System
        8. 16.3.8. Develop Enabling Systems
      4. 16.4. Summary
      5. 16.5. Questions
  8. IV. Transitioning to Model-Based Systems Engineering
    1. 17. Integrating SysML into a Systems Development Environment
      1. 17.1. Understanding the System Model’s Role in a Systems Development Environment
        1. 17.1.1. Systems Development Environment
        2. 17.1.2. The System Model as an Integrating Framework
        3. 17.1.3. Relation of a System Model to an Executable System Model
      2. 17.2. Integrating the Systems Modeling Tool with Other Tools
        1. 17.2.1. Classes of Tools in a Systems Development Environment
        2. 17.2.2. An Interconnected Set of Tools
        3. 17.2.3. Interface with Requirements Management Tool
        4. 17.2.4. Interface with Performance Analysis and Other Engineering Analysis Tools
        5. 17.2.5. Interface with Documentation Generation Tool
        6. 17.2.6. Interface with Configuration Management Tool
        7. 17.2.7. Interface with Project Management Tool
        8. 17.2.8. Interface with Verification Tool
        9. 17.2.9. Interface with Development Tool
      3. 17.3. Data Exchange Mechanisms in an Integrated Systems Development Environment
        1. 17.3.1. Data Exchange Mechanisms
        2. 17.3.2. Role of Data Exchange Standards
          1. XML Metadata Interchange
          2. Application Protocol 233
          3. Diagram Interchange Standards
          4. Model Transformation
      4. 17.4. Selecting a System Modeling Tool
        1. 17.4.1. Tool Selection Criteria
        2. 17.4.2. Specific Tool Support for the MBSE Method
        3. 17.4.3. SysML Compliance
      5. 17.5. Summary
      6. 17.6. Questions
        1. Discussion Topics
    2. 18. Deploying SysML into an Organization
      1. 18.1. Improvement Process
        1. 18.1.1. Monitor and Assess
        2. 18.1.2. Plan the Improvement
        3. 18.1.3. Define Changes to Process, Methods, Tools, Metrics, and Training
          1. Process Changes
          2. Method Changes
          3. Tool Changes
          4. MBSE Metrics
          5. Training Changes
        4. 18.1.4. Pilot the Approach
        5. 18.1.5. Deploy Changes Incrementally
      2. 18.2. Summary
      3. 18.3. Questions
  9. SysML Reference Guide
    1. A.1. Overview
    2. A.2. Notational Conventions
    3. A.3. Package Diagram
    4. A.4. Block Definition Diagram
    5. A.5. Internal Block Diagram
    6. A.6. Parametric Diagram
    7. A.7. Activity Diagram
    8. A.8. Sequence Diagram
    9. A.9. State Machine Diagram
    10. A.10. Use Case Diagram
    11. A.11. Requirement Diagram
    12. A.12. Allocation
    13. A.13. Stereotypes
  10. References