Use Case Diagram (available in CORE Spectrum)

Use cases describe the functionality of a system from the user perspective. The use case diagram is a graphical representation of actors (humans), blocks (components), and use cases.

Use cases are effectively the names of MBSE threads, capturing concepts and context that should be translated into threads and the integrated system logic. They are often used as elicitation and discovery tools, helping to better understand the system under consideration and transition from requirements and operational context to behavioral threads. The conceptual modeling flow (in top-down design) begins with the requirements. From the requirements, you define the system boundary – physical and functional – and identify the context. From this context and the operational concept that drives it, use cases are identified. Use cases are then elaborated by functional threads which provide the insight needed to develop the integrated logic. A view of how use cases fit into the greater language of MBSE is shown below.

Note that this is not the only flow nor is it the prescribed flow. For example, use cases can be tied to requirements. They can also exist free-floating. However, the conceptual flow places use cases into the overall context of the MBSE model. They serve to make the development of threads more disciplined, explicit, and rich. At any layer of development, you can identify the threads that influenced the development of the integrated logic by

1. Starting with the component’s root function
2. Getting the component that performs the function
3. Getting the use cases that describe the component
4. Getting the threads that elaborate the use case

For the use case diagram

• The subject (the large box in the middle of the diagram labeled Surveillance System) identifies the system that this use case describes. Note that this subject is “inherited” and does not have to be linked to every level of the use case model. CORE starts with the element Use Cases and looks up the ancestor hierarchy until it finds a use case that describes a component. In this traversal, CORE considers the included in, extends, and generalization of relationships.
• Two levels of use cases are represented within the system frame:
• • The direct children of Use Cases as identified by the includes relationship. In this example, Monitor Environment and Setup Track are included in Use Cases.
  • The use cases linked to these children by the includes, extends, and generalization of relationships. In this example, Initialize System and Shutdown System are included in Monitor Environment. Handle Camera Fault extends the Monitor Environment in the event of a fault. Manually Monitor Environment is a specialization of the Monitor Environment use case.
• The actors represented around the boundary of the diagram are the components involved in (i) the use case on which the diagram was opened plus (ii) any use case shown on the diagram.
• Actors are shown in two different formats. By default, components of type human are drawn as stick figures with the name displayed below. All other component types are drawn as rectangles with a corresponding icon template defining the content. In the example above, no non-human actors are displayed.
• Classification (the generalization of / kind of relationship) is shown for both use cases and actors if both elements in the relationship appear on the use case diagram.
• Extension points represent the places at which a use case can be extended. On each extends relationship, there is an “extension point” attribute. This field is displayed in the label of the extended use case as well as on the line connecting the extending use case. In the example, Handle Camera Fault uses the extension point “fault” for Monitor Environment.

The use case diagram is a free-form diagram. CORE defaults to specific layout behaviors, but you are free to rearrange content within the bounds of certain constraints:

• All nodes are resizable. Note that while actors are resizable, stick figures are drawn at a specific size in all cases.
• Use cases are drawn in a two-column format. The children of the use case upon which the diagram was opened are drawn on the left edge of the subject frame. All second-level use cases (includes, extends, kind of) are drawn along the right edge of the subject frame.
• The subject frame is automatically sized to include all use cases. It can be enlarged to provide additional space, but it cannot be resized smaller than its content.
• Actors are displayed along the left, right, and bottom edges of the diagram.
• • Actors participating in the child use-cases are drawn in the left column.
  • Actors participating in the secondary use cases are drawn in the right column.
  • Actors participating in the top-level use case but unrelated to the children or secondary use cases are drawn below the subject frame.
• Actors can be moved from region to region but cannot be displayed within the subject frame. If dropped in this region, CORE will automatically move them to the closest diagram edge.

A good reference for further information on use case diagrams is chapter 12 of A Practical Guide to SysML: The Systems Modeling Language by Sanford Friedenthal, Alan Moore, and Rick Steiner (2012).

Diagram Options

In addition to the classic diagram options, the use case diagram settings include:

• Use Stick Figures - determines whether human actors are drawn as stick figures. By default, components of type human are drawn as stick figures with the name displayed below. All other component types are drawn as rectangles with a corresponding icon template defining the content. If this option is toggled off, all component types will be drawn as rectangles.

Diagram Palette

The constructs and key entities tabs allow you to quickly develop your use case model, while the all entities tab enables you to relate your use case model to the remainder of your system definition.

• Constructs

• • New Use Case - drop onto any diagram node to create a new block (component) as part of the node composition (built from)

  • Use Cases - drop onto any diagram node to relate an existing block (component) as part of the node composition (built from)

  • New  Actor - drop onto any diagram node to create a new block (component) as part of the node composition (built from)

  • Actors - drop onto any diagram node to relate an existing block (component) as part of the node composition (built from)

  • New Information Block - drop onto the diagram to insert an information block (a mini property sheet)

  • New Note - drop onto the diagram to insert a new note (descriptive text in a note icon)

  • New Shape - drop onto the diagram to insert a new shape (a rectangle, rounded rectangle, circle, or ellipse with text, if desired)

  • New Graphic - drop onto the diagram to insert a new picture

• Key Entities

• • Component - drop an existing component onto a node to establish any valid relationship. Most often, this will be composition (built from).

  • UseCase - drop an existing component onto a node to establish any valid relationship. Most often, this will be composition (built from).

• All Entities - all classes and elements in the system model, allowing you to drag any element on top of a diagram node to establish relationships with the balance of your system model

Diagram Menu Commands

• Rename Element

• Renumber Element

• Set Attribute

• Remove Selection

• Delete Selection

• Select All

• Insert

• Information Block

• Note

• Graphic

• Shape

• Edit Actors

• Edit Use Cases

• Edit Extensions

• Edit Specializations

• Set Extension Point

• Set Actor Type

• Set Subject

• Open Element view submenu

Tips and Tricks

• In general, it is best to represent use case nodes using the Name icon template. However, when a use case extends another use case on the diagram, shift the icon template for the extended node to Use Case Extension Points.
• The use case diagram is frequently used as a high level communication tool for interacting with stakeholders and eliciting insight. Frequently, using images for non-human actors can improve communication. However, for most audiences, it is best to leave the human actors as stick figures since this is a recognizable trait of use case diagrams that may make the audience more comfortable.