The commands available on a Block are as follows:
SysML diagram: Launch the SyML diagram creation wizard.
Distributed property: Creates a Distributed Property.
Reference: Creates an Reference.
Connector property: Creates a Connector Property.
Participant property: Creates a Participant Property.
Part: Creates a Part.
Flow port: Creates a Flow Port.
Port: Creates a Port.
The commands available on a Constraint Block are as follows:
SysML diagram: Launch the SyML diagram creation wizard.
Flow port: Creates a FlowPort.
Port: Creates a Port.
Part: Creates a Part or an Instance.
The following commands are accessible by right-clicking on a Package element in the model browser.
SysML diagram: Launch the SyML diagram creation wizard.
Block: Creates a Block.
Constraint block: Creates a ConstraintBlock.
Flow specification: Creates a FlowSpecification.
Quantity kind: Creates a QuantityKind.
Unit: Creates a Unit.
Value type: Creates a ValueType.
View: Creates a View.
Viewpoint: Creates Viewpoint.
SysML Activity diagrams are dedicated to specifying the flow of inputs/outputs and control, including sequences and conditions for activities.
Most of the elements required for modeling the activity behavior of a Block element come from UML Activity diagrams. SysML adds some further extensions, such as support of continuous flow modeling.
In the following list we show only the activities elements added by the SysML specification.
Continuous: Creates a Continuous parameter.
Discrete: Creates a Discrete parameter.
Optional: Creates an Optional parameter.
Rate: Creates a Rate parameter.
Continuous: Creates a Continuous activity edge between two activity nodes.
Discrete: Creates a Discrete activity edge between two activity nodes.
Probability: Creates a Probability activity edge between two activity nodes.
Rate; Creates a Rate activity edge between two activity nodes.
Item Flow: Creates an Item Flow.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
The following example is extracted from the MIWG Test case list and implemented in the SysML Architect module.
Block diagrams are used to design system composition in terms of blocks and the relations between them, such as associations, generalizations, and dependencies. Blocks can be placed in packages to separate domains.
Block: Creates a Block.
ConstraintBlock: Creates a ConstraintBlock. ConstraintBlocks are an extension of the Block
concept.
FlowSpecification: Creates a FlowSpecification.
Connector property: Creates a ConnectorProperty. This command is only available for Block
elements.
Contraint property: Creates a ConstraintProperty. This command is only available for
ConstraintBlock elements.
Participant property: Creates a ParticipantProperty. This command is only available for Block
elements.
Part: Creates an Instance inside a Package or creates a Part inside a Classifier.
Distributed property: Creates a DistributedProperty. A DistributedProperty can only be created
inside Block elements.
Flow property: Creates a FlowProperty. A DistributedProperty can only be created inside Block
or FlowSpecification elements.
Attribute: Creates an Attribute.
Operation: Creates an Operation.
Associations: Creates an Association link.
Aggregation: Creates an Association link of kind “aggregation”.
Composition: Creates an Association link of kind “composition”.
SmartGeneralization: Creates a Generalization or an InterfaceRealization link.
Note: If the target element is a Class, a Generalization link will be created. If the target element is an Interface, this command creates an InterfaceRealization link.
Generalization link: Creates a Generalization link.
InterfaceRealization link: Create an InterfaceRealization link.
ValueType: Creates a ValueType.
DataType: Creates a DataType.
Enumeration: Creates an Enumeration.
EnumerationLiteral: Creates an EnumerationLiteral.
ClassAssociation: Creates a ClassAssociation.
FlowPort: Creates a FlowPort .
Port: Creates a Port.
ProvidedInterface: Creates a ProvidedInterface.
RequiredInterface: Creates a RequiredInterface.
QuantityKind: Creates a QuantityKind.
Unit: Creates a Unit.
Part: Creates an Instance or a Part inside a Classifier.
AttributeLink: Creates an AttributeLink.
Delegate: Creates a delegate connector.
Link: Creates a Link.
Item flow: Creates an ItemFlow.
Information Flow: Creates an Information flow
Realized Information Flow: Creates a realized information flow
Information Item: Creates an Information Item
Allocate: Creates an Allocate dependency.
Conform: Creates a Conform dependency.
Copy: Creates a Copy dependency.
Refine: Creates a Refine dependency.
Satisfy: Creates a Satisfy dependency.
Verify: Creates a Verify dependency.
Dependency: Creates a Dependency.
: Creates a Traceability link.
Related diagram link: Create a link between an element and its related diagram.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
Note: Creates a Note.
Constraint: Creates a Constraint.
The following example is extracted from the SysML 1.2 specification and implemented in the SysML Architect module.
Internal Block diagrams are dedicated to modeling the internal structure of Blocks in terms of properties and the relationships between properties.
Connector property: Creates a ConnectorProperty. This command is only available for Block
elements.
Contraint property: Creates a ConstraintProperty. This command is only available for
ConstraintBlock elements.
Participant property: Creates a ParticipantProperty. This command is only available for Block
elements.
Part: Creates an Instance inside a Package or create a Part inside a Classifier.
Distributed property: Creates a DistributedProperty. A DistributedProperty can only be created
inside Block elements.
Flow property: Creates a FlowProperty. A DistributedProperty can only be created inside Block
or FlowSpecification elements.
Attribute: Creates an Attribute.
Operation: Creates an Operation.
Delegate: Creates a delegate connector.
Link: Creates a Link.
FlowPort: Creates a FlowPort.
Port: Creates a Port.
ProvidedInterface: Creates a ProvidedInterface.
RequiredInterface: Creates a RequiredInterface.
Item Flow: Creates an Item Flow.
Information Flow: Creates an Information flow
Realized Information Flow: Creates a realized information flow
Information Item: Creates an Information Item
Allocation: Creates an Allocate dependency.
Conform: Creates a Conform dependency.
Copy: Creates a Copy dependency.
Refine: Creates a Refine dependency.
Satisfy: Creates a Satisfy dependency.
Verify: Creates a Verify dependency.
Dependency: Creates a Dependency .
: Creates a Traceability link.
Related diagram link: Create a link between an element and its related diagram.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
Note: Creates a Note.
Constraint: Creates a Constraint.
This example is extracted from the SysML specification and implemented in the SysML Architect module.
Package diagrams are dedicated to organizing or grouping the model into views and viewpoints.
The following commands list highlights only those SysML elements present in the package diagram palette.
View: Creates a View.
Viewpoint: Creates a Viewpoint.
QuantityKind: Creates a QuantityKind.
Unit: Creates a Unit.
Conform: Creates a Conform dependency.
Item Flow: Creates an Item Flow.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
This example is extracted from the SysML 1.2 specification and implemented in the SysML Architect module.
Parametric diagrams are used to express constraints (equations) existing between value properties. They are a restricted form of internal block diagram and represent constrained use in a particular context.
The most important elements are Constraint Properties and FlowPorts composing the ConstraintBlock, as well as their relationships modeled using Connectors or Item Flow links.
Connector property: Creates a ConnectorProperty.
Contraint property: Creates a ConstraintProperty.
Participant property: Creates a ParticipantProperty.
Part: Creates an Instance or a Part inside a Classifier.
Distributed property: Creates a DistributedProperty.
Flow property: Creates a FlowProperty.
Attribute: Creates an Attribute.
AttributeLink: Creates an AttributeLink.
Delegate: Creates a delegate connector.
Link: Creates a Link.
FlowPort: Creates a FlowPort.
Port: Creates a Port.
ProvidedInterface: Creates a ProvidedInterface.
RequiredInterface: Creates a RequiredInterface.
Item Flow: Creates an Item Flow.
Information Flow: Creates an Information flow
Realized Information Flow: Creates a realized information flow
Information Item: Creates an Information Item
Allocation: Creates an Allocate dependency.
Conform: Creates a Conform dependency.
Copy: Creates a Copy dependency.
Refine: Creates a Refine dependency.
Satisfy: Creates a Satisfy dependency.
Verify: Creates a Verify dependency.
Dependency: Creates a Dependency .
Traceability: Creates a Traceability link.
Related diagram link: Create a link between an element and its related diagram.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
Note: Creates a Note.
Constraint: Creates a Constraint.
The following example is extracted from the literature and implemented in the SysML ARchitect module.
SysML Requirement diagrams are dedicated to modeling system requirements, in other words, the capabilities or conditions that must be fulfilled. Requirement relationships related to other requirements as to other model elements can be also specified using this type of diagram.
The following list represents the elements available in SysML requirement diagrams.
RequirementContainer: Creates a Requirement Container.
Requirement: Creates a Requirement.
Allocate: Creates an Allocate dependency.
Part: Creates a Part dependency.
Derive: Creates a Derive link.
Copy: Creates a Copy dependency.
Satisfy: Creates a Satisfy dependency.
Verify: Creates a Verify dependency.
Refine: Creates a Refine dependency.
Trace: Creates a Traceability link.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
Note: Creates a Note.
Constraint: Creates a Constraint.
The following example is extracted from the MIWG test case list and implemented in the SysML Architect module.
SysML Sequence diagrams are dedicated to specifying the flow of control between actors and blocks, or between parts of a system. They represent the sequence of sending and receiving messages between the considered entities through the lifelines exposed.
In the following list only those elements added to sequence diagrams by theSysML specification are detailed.
Item Flow: Creates an Item Flow.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
The following example is extracted from the SysML specification and implemented in the SysML Architect module.
SysML State diagrams describe the behavior of an element as a succession of state linked by transitions.
Most of the elements required for modeling the state machine behavior of a Block element come from UML state diagrams.
In the following list only those elements added to state diagrams by the SysML specification are detailed.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
The following example is extracted from the SysML 1.2 specification and implemented in the SysML Architect module.
SysML Use case diagrams describe how a system is used by its environment (external actors). The system provides services which are used by the actors in order to realize their goals. Use case diagrams are often seen as a picture of the list of functionalities provided by the system and the set of interacting user types or external systems.
In the following listonly those elements added to use case diagrams by the SysML specification are detailed.
Item Flow: Creates an Item Flow.
Problem: Creates a Problem note.
Rationale: Creates a Rationale note.
The following example is extracted from the SysML specification and implemented in the SysML Architect module.
We are now going to illustrate the modeling of a complex application using the SysML Architect module. This case study has already been presented in literature [M. V. Linhares et al] and is based on the modeling of an industrial automation unit, which expresses different operations and control strategies. For the purposes of this Modelio user guide, we will present the high level models which are modeled using the SysML ARchitectmodule developed by Softeam.
The modeling starts from the highest level of the industrial automation unit, by first modeling the different top level components of the system. Next, a behavioral SysML use case diagram is presented to determine the different case scenarios present in the system. Following that, we gradually descend to the low level components and illustrate their relative aspects such as behavior expressed via SysML diagrams like state and sequence diagrams.
M. V. Linhares et al. 2006.Empirical Evaluation of SysML through the Modeling of an Industrial Automation Unit. In 11th IEEE International Conference on Emerging Technologies and Factory Automation. Prague, Czech Republic
As seen in the previous figure, the pressure device block consists of several sub modules, among which we also find the ARTH (arithmetic functions) block. We will now describe the block diagram of this module using the SysML Block diagram. Here, using SysML constraint blocks, we will first define the relationships between the ARTH module and various other arithmetic equations that are used in this functional block, as shown in Figure 26.
In order to precisely determine how the ARTH module performs its operations, the SysML parametric diagram is used, as shown in Figure 27.
The physical subsystem represents the physical structure of the system in terms of the equipment installed within the system. Figure 21 represents the block diagram of the physical subsystem and determines its composition, consisting of modules such as valves, tanks and devices, among others.
While Figure 21 showed the relation of the physical subsystem with other modules, Figure 22 displays the internal composition of the physical subsystem by means of a SysML internal block diagram. Here, the structure of the subsystem is clearer compared to the previous figure. The ports of the sub modules of the physical subsystem are SysML flow ports, which indicate the flow of a specific entity. For example, ElectricPower represents an electric flow that passes between several modules of the physical subsystem. Similarly, other flow ports are typed with FS_FLUID, Pressure, etc., representing the flow of a fluid or pressure respectively.
Once the modeling of the three subsystems has been completed, the other parts of the automation unit can be modeled. Regarding this aspect, we will first model the pressure device block, as described earlier in Figure 21. The internal composition of this block is also illustrated by means of a SysML internal block diagram as shown in Figure 25. The internal composition consists of several sub modules or functional blocks such as AI (analog input functions), DSP (display functions) and ARTH (arithmetic functions), among others.
Figure 31 gives an overview of the requirements applied to the system. Here specifically, the requirements are related to the level control strategy. The different requirements are satisfied by some system blocks. The SysML allocation mechanism also enables system designers to map/allocate different elements, activities or other aspects.
Normally use case diagrams are detailed by related behavioral diagrams such as sequence diagrams. These enable control flow to be expressed, and we illustrate the sequence of operations/events related to the “Operate the Plant” use case scenario described in the previous figure. Sequence diagrams in turn can also be related to block diagrams, since they express interaction between the different elements present in the system. Here in the figure, we see several actions, such as the starting/stopping of the experimental plant unit in question and actions based on some control strategies, among others.
We are now going to model the control strategy action. This action is expressed by means of a SysML activity diagram that focuses on the inputs, outputs, sequences and the related conditions. The control strategy is related to the global system and is among one of several strategies that the plant can implement.
Let us first look at the modeling of the global system structure as illustrated in Figure 19. This figure illustrates the composition of the system and the internal interactions, mainly by using a SysML block diagram. Here, the unit has been composed of three subsystems: the physical subsystem, the control subsystem and finally the supervisory subsystem. As shown in the figure, the control subsystem controls the physical subsystem by means of certain smart devices.
Let’s now look at the modeling of the supervisory subsystem. This subsystem is responsible for:
· the verification of the executing operations of the control strategy, implemented via the data acquisition from devices present in the field,
· the subsequent conveyance of this information to the user by means of a graphical display.
Once again, we will use the SysML internal block diagram to represent the internal composition of this subsystem. This diagram in turn represents a logical view of the system. Here it should be mentioned that the ports of the sub modules are not flow ports in nature, but are service ports, and have their required and provided interfaces respectively.
Figure 20 gives an abstract overview of system behavior through a SysML use case diagram. The use case illustrates the system behavior visible to the end user external to the system. In the figure, there are several use cases present, related to how the system is operated, controlled, supervised etc. Here, plant refers to the experimental industrial automation unit.
The previous sections presented the Modelio approach to SysML modeling using dedicated diagrams. These diagrams enable the clear separation of concerns and concentrate on major use cases for SysML modeling. For the sake of clarity and user-friendliness, this is achieved by reducing the use of SysML.
The SysML module supports the entire collection of stereotypes defined in the specification. In order to benefit from this, users can work with Modelio in expert mode. In this mode, a user should create UML models and then annotate them with SysML stereotypes.
The following example gives instructions on the annotation of UML elements using SysML stereotypes.
Create any UML element. Go to the MDA annotations window and choose the stereotype button (Figure 17).
Only applicable SysML stereotypes are shown in the dialogue window (Figure 18).
This mechanism is applicable for all stereotypes described in the SysML specification.
SysML is an OMG standard, defined as an extension of the UML language for specifying, analyzing, designing, and verifying complex systems. The Modelio SysML Designer module is based on the analysis of the SysML specification version 1.2, available since June 2010. The SysML module does not support requirement diagrams, but these diagrams are supported by the Modelio Analyst module. This module should be used in conjunction with the SysML module to get complete SysML support. Analyst module provides editors dedicated to requirement analysis, spreadsheet editors, requirement document generation, and requirement imports from MS-Word documents. Requirements can be traced from each SysML diagram, using SysML predefined dependencies (e.g.: refine, satisfy, verify ).
The current documentation describes how to use Modelio with this SysML extension. For further information on how to use Modelio, the principal Modelio user guide should be consulted.
The SysML specification defines a model library. This library contains a subset of the SysML quantities and units defined in order to represent the International System of Units. A model component has been packaged in order to model this library. For deploying this model component, go to the Configuration menu, then Deploy a model Component… as shown in Figure 1.
The window depicted in Figure 2 should appear. In the File path field select the SIDefinitions.ramc file available here, and click Deploy.
The Figure 3 represents the result of the model component deployment.
After installing Modelio, start the modeler and create a simple UML model.
Go to the MDA menu and choose Install a module… as shown in Figure 2.
You will now be in the mdastore folder. Proceed to the location of the SysML Architect module (see Figure 3).
Choose SysMLArchitect_x.yy.zz.jmdac and click on the Open button.
SysMLArchitect_x.yy.zz.jmdac contains SysML UML2 Profile. It is compatible with Modelio.