Logo

Celebrating 25 Years of Excellence in Systems Engineering

MBSE Tools

MBSE Tools

MBSE Primer

MBSE, CORE, and GENESYS Training

Vitech offers multiple training opportunities focused on providing MBSE, CORE, and GENESYS users and managers with a common framework that can be applied using any systems engineering methodology.

Designed to elevate your team’s MBSE command, Vitech’s training reflects far more than product knowledge. Delivered by practicing senior and principal systems engineers, Vitech courses cover key systems concepts, the latest processes and methods, and the software capabilities to support your systems efforts.


MBSE


  To request information regarding availability, options, and arrangements to host a class for your team, please follow this link, or email Vitech Training.


To explore the offerings, select a course from the table below.


Available Courses

For teams that wish to learn about model-based systems engineering – whether simply to appreciate the fundamental concepts and applicability or to transform their practice – our supporting team of seasoned practitioners at Vitech Corporation delivers a variety of sessions ranging from two hours to two days designed to suit your team’s needs. The objective of these sessions in model-based systems engineering is to provide your team with a basic familiarity with the concepts of model-based systems engineering as practiced in Vitech Corporation’s layered approach known as the STRATA™ method.

These sessions can be presented in a variety of formats, tailored to the needs of the audience. The training design allows it to target both technical and non-technical audiences. In either case, the basic concepts of model-based systems engineering are presented using language and examples appropriate to the audience. The content is also designed so that it can be delivered in varying levels of detail. This allows the training to be tailored to a two day, one day, half day, or two hour format. (One hour and keynote presentations are also available, though these thought-provoking sessions are certainly of a different scope than the training courses). Vitech will work with you to identify the appropriate delivery and timeframe for the course.

Participants completing these sessions will emerge with a basic understanding of the concepts of model-based systems engineering and the value adding advantages of the model-based approach. Whether a program or project manager or a hands-on systems engineer, he or she will have an understanding of how and why the model-based approach differs from other, more traditional methodologies.

These sessions are designed to serve the needs of a variety of role players on your team. Vitech will use its ability to tailor this offering to your exact audience in order to emphasize those subjects and perspectives that best meet their needs.

  • Program or project managers who desire to achieve a basic understanding of the nature and advantages of model-based systems engineering will understand the MBSE principles in the context of their responsibilities.
  • Acquisition professionals seeking an understanding of model-based systems engineering methodologies and the potential value add to acquisitions programs and projects they procure will see how MBSE can leverage their understanding of the problem driving their acquisition and result in proposals that address program needs.
  • Systems engineers familiar with the concepts of traditional systems engineering but new to the model-based systems engineering methodology will build on their existing knowledge and experience to see how to use MBSE as a “force multiplier” for their engineering efforts.
  • Agile developers seeking to bring a systems perspective to their agile development work will learn how MBSE can feed their backlog and tie their work to the system design effort while enhancing the agility they value.

The training begins by exploring the traditional approaches to systems engineering focusing on document-centric waterfall approaches. The problems with these approaches are discussed in ways which provide a contrast to model-based systems engineering. In particular the issues of stove piping, limitation to clean sheet or top-down design, and complexity management are explored.

This is followed by an explanation of the model-based approach. The course sets out the characteristics of the model and how it can be used to obtain an efficient and effective system design. Beginning with the definition of the system boundary, the training explains the major tasks of model-based system design. As these tasks are discussed the system design issues facing the engineering team are described. The handling of these issues in the model-based systems engineering methodology is contrasted with their treatment in the more traditional approaches.

In addition, depending upon the time available and the needs of the audience, specific issues and opportunities can be discussed. The course can be constructed to include modules discussing leveraging service-oriented architectures, working within the DoDAF environment, dealing with model-based systems engineering in an agile development setting and other timely issues.

Training Outline

  1. Systems and Systems Engineering
  2. Context – 4 Domains, 3 Systems, 2 Ways of Thinking and 1 Model
  3. System Life Cycle
  4. Problem Classes
  5. Traditional Engineering- Process and Problems
  6. What is a Model?
  7. MBSE – Process and Tasks
  8. Views
  9. Supplemental Topics (Service-Oriented Architectures, Agile Processes et al.)

Using case studies and real-life problems, you will learn the interfaces of CORE and how to best apply it to the management of requirements and risks, verification of system concepts, and re-engineering of processes in your workgroup. You will learn how CORE's modeling and simulation capability quickly and easily allows you to bound and verify vague requirement sets. You will build complete design models, produce supporting documentation and automatically generate the reports required for any complex system design. Throughout the course you will receive tips from our systems engineers which will enable you to fully maximize all components of CORE software so you can effectively manage it across domains in your environment.

The course is designed for practitioners who will be using CORE to implement their organization’s MBSE approach. It provides a complete familiarization with the CORE tool and its application to practical systems engineering problems.

1.0  Model-based Systems Engineering- Introduction and Concepts

Description: Introduces the basic concepts of MBSE as contrasted with more traditional approaches. This segment is the foundation for the effective use of the CORE tool.

Key Concepts: system; systems engineering; system life cycle; return on investment; role of the Systems Engineer; systems engineering process; model; model-based systems engineering; synthetic thinking; MBSE layered process; views, diagrams, and models

2.0  CORE Environment

Description: Introduces the concept of operations and technology of the CORE tool. The student will start the tool and explore the operating environment.

Key Concepts: CORE CONOP;  technology; system definition language; importing and opening projects; Project Explorer; project navigation; facilities; elements; Element Browser; attributes; relationships; versions; perspectives; schema; View Window; Exiting CORE; repository; view generation

3.0  Getting Started- Walkthrough

Description: Covers the creation of new accounts and projects as well as setting project permissions and user preferences.

Key Concepts: logging in; new account; new project; project explorer properties; project permissions; user preferences; file locations; diagram preferences; preparing for development activities

4.0  Capturing Originating Requirements

Description: This section introduces the Geospatial Library model and describes the process for capturing the originating requirements beginning at the highest level. The various tools and methods for requirements capture are discussed. The production of diagram views is introduced.

Key Concepts: document parser; element extractor; elements; source documents; parsing; creating elements; parsed requirements; debris; component; editing, numbering and renaming requirements; composite requirements; child requirements; relationships

5.0  Parameters

Description: This section presents the differences and similarities between attributes and parameters and their uses.

Key Concepts: attributes and parameters; versioning

6.0  Filter & Sort

Description: This section introduces Filtering and Sorting data in the tool.

Key Concepts: filters; creating and editing filters; sort blocks; creating and editing sort blocks

7.0  Saving Your Work

Description: Regular saving to the database is important. This section covers the steps to saving the data and exiting the tool as well as the various types of files that can be created by CORE.

Key Concepts: save repository; exit CORE; CORE file types

8.0  Document Generation

Description: This section treats the powerful advantage available in CORE as a result of the capability to generate documents FROM the database directly. Using the Requirements Table and the System Description Document (SDD) as examples the student will generate reports form the tool.

Key Concepts: reports; generating standard reports; requirements table; SDD

9.0  Concerns & Risks

Description: Concerns and risks become apparent as the model is constructed. These must be captured and preserved in an organized way. This section covers using the tool to capture, preserve, display, and manage Concerns and Risks.

Key Concepts: concerns; risks; target; traceability; risk element; hiding elements on diagrams

10.0  Presenting Your Work

Description: The production of diagram views is introduced. The use and production of various diagrams is discussed.

Key Concepts: diagrams; hierarchy, spider and requirements diagrams

11.0  Behavior Constructs

Description: Behavior is the most neglected domain in the SE discipline but it is critical to the modeling process. Behavior depends upon the relationships between entities and their arrangement through control constructs to support the logical architecture of the system.

Key Concepts: behavior; logic; logic constructs; graphical notation; control constructs; constructs in combination; items; execution and conditions; graphical representation; creating behavior; COREsim; constructs and behavior; exits; loop; iterate; replicate; concurrency; sequence; data stores; triggers

12.0  Complete The Context Layer

Description: This section discusses the system and functional boundary definitions and continues the development of the requirements. It also introduces the Model Assistant as an aid to the modeling process.

Key Concepts: system boundary; external systems; physical context; structure block definition diagrams; interfaces; interface diagrams; interface elements; N2 diagrams; Model assistant; relating functional and physical; functional boundary; requirement types and relations; constraints; performance objectives

13.0  Bitmap Graphics

Description: The ability to use bitmap graphics from internal and external sources to enhance visualizations in CORE is discussed in this section.

Key Concepts: external graphics path; associating graphics with elements; using graphics in diagrams

14.0  Use Cases And Threads

Description: This section covers the construction, use, and representation of use cases and threads. The student will construct use cases and threads for the example system.

Key Concepts: external interactions; use case; use case relationships; use case diagrams; relating use cases to requirements; threads; behavior diagrams

15.0  Folders

Description: This section introduces the use of folders in the CORE tool.

Key Concepts: folders; creating and using folders

16.0  Derive Integrated System Behavior

Description: The integration of threads into an integrated behavior for the system is covered here. Requirements are linked through functions to the threads and traceability through the integrated behavior is established.

Key Concepts: integrated behavior; relating threads; linking requirements to use cases and functions; traceability diagrams

17.0  Executable Behavior I

Description: This section introduces the methodology and tool (COREsim) for analyzing dynamic system performance and behavior. This will be contrasted to the traditional methods for simulating and evaluating system behavior. The student will apply the tool to the system model of the sample problem to learn how they work in a real-world implementation.

Key Concepts: COREsim; integrated simulation; kill branch; function decomposition

18.0  Allocation

Description: Allocation of behavior to physical components is the linchpin of systems engineering. This section introduces the student to the concept of allocation and discusses aspects of allocation such as aggregation and determining when the allocation is complete.

Key Concepts: allocation; partitioning;  completion; decomposition; failure modes; physical architecture; system-level architecture; allocation decisions; trial allocation; trade studies; primary design traceability

19.0  Interfaces And Links- Context Level

Description: In this section the student will identify interfaces, create the links that make them up and represent the interfaces and links in the tool using a number of diagrams.

Key Concepts: external interactions; interfaces; interface termination; links; interface hierarchy diagram; physical block diagram; physical N2 diagram; flow block diagram

20.0  Verification Requirements And Test Planning

Description: This section introduces verification and test planning. Using the sample problem the student will learn how to develop verification requirements and a test plan. The section covers test threads and sequences as well as the use of the Dynamic Analyzer.

Key Concepts: verification; testing; test threads; verification hierarchy; verification property sheets; component interfaces; test sequences; Dynamic Analyzer

21.0  Versioning

Description: The CORE tool capability for versioning is covered in this section.

Key Concepts: versioning; attribute version browser; purging; baseline control; attribute history; project compare; schema attribute properties; audit log

22.0  CORE Scripts

Description: The ability to customize the behavior of the CORE tool using scripts is one of its most powerful features. This section introduces the student to scripting and a sample of its uses.

Key Concepts: script; external file; generating reports; html reports; data exchange; standard scripts

23.0  Formal Documentation

Description: This section covers generating customized formal documentation using scripts. The student will generate documentation from the sample problem model.

Key Concepts: formal documentation; document management; document production; templates; PUIDs; modifying documents

24.0  Executable Behavior II

Description: The discussion of the definition and modeling of executable behavior is extended in this section. Resources and function duration are introduced.

Key Concepts: resources; function duration; resource timing; resupply; replenishment; database queries; IF, THEN, ELSE constructs

25.0  Organizing, Navigating, And Focusing On Models

Description: The CORE tool capability for packaging as an organization strategy and the use of perspectives to focus model aspects are discussed in this section.

Key Concepts: package; package hierarchy; perspectives; navigation

26.0  SysML Diagram Representations

Description: This section discusses the SysML views available in CORE.

Key Concepts: requirements diagram; structure block definition diagram; activity diagram; use case diagram; interface N2 diagram; interface block diagram; flow interface block diagram; sequence diagram; physical block diagram; physical N2 diagram; flow internal block diagram; package diagram; classification block definition diagram

27.0  DoDAF 2.0

Description: The Department of Defense Architectural Framework (DoDAF 2.0) is included in CORE as a separate schema. This section discusses the DoDAF and its use in modeling and the CORE tool in particular. Specific modeling and design challenges arising DoDAF are covered as well.

Key Concepts: DoDAF; architecture; software architecture; system architecture; enterprise architecture; integration and federation; frameworks; architecture definition; DoDAF views; DoDAF schema

This class is designed for users who want to be able to unleash the power of CORE by tailoring the schema, using advanced CORE features, and applying the COREscript language for document production, enhanced simulations, and data exchange.

This course is designed to acquaint the experienced CORE use with CORE's powerful scripting and customization capabilities. We strongly recommend that the potential participant have completed the MBSE with CORE Introductory course and have 3 to 6 months experience hands on in the tool.

Course Outline

  • Using the CORE Schema extender to tailor the database and displays
  • Building sort blocks
  • Creating and applying filters
  • Scripting with COREscript - CORE's internal scripting language
  • Applying script constructs, data types, and expressions
  • Debugging scripts
  • Using RTF for document production
  • Applying the standard reports and queries

You will learn the .NET interface of GENESYS and how to best apply it to the management of system design including the management of requirements and risks, verification of system concepts, and re-engineering of processes in your workgroup. You will see how GENESYS capability allows you to intuitively create robust system models. You will build complete design models using the designer-friendly user interface. Throughout the course, you will receive tips from our systems engineers, which will enable you to fully maximize all components of the GENESYS software so you can effectively manage it across domains in your environment.

The course is designed for practitioners who will be using GENESYS to implement their organization’s MBSE approach. It provides a complete familiarization with the GENESYS tool and its application to practical systems engineering problems.

Course Outline

  1. Module 1
    • Model-based systems engineering introduction and concepts
    • GENESYS concept of operation & walk-through
    • Getting started with GENESYS
    • Introduction to our GENESYS example
    • Capture originating requirements
    • Issues and risks
  2. Module 2
    • Introduction to behavior and constructs
    • Define the system boundary
    • System threads
  3. Module 3
    • Derive integrated system behavior
    • Allocation
    • Executable behavior
    • Interfaces and links
  4. Module 4
    • Verification Requirements and Test Planning
    • Versioning
    • GENESYS Scripts
    • Formal Documentation
    • Simulation – Resources
    • DoDAF 2.0
    • Summary and Review

Follow Us: