Leveraging Alf for SysML, Part 1: Better Simulation Modeling

Leveraging Alf for SysML
Part 1: Better Simulation Modeling
Copyright © 2019 Ed Seidewitz / Model Driven Solutions, Inc.
Ed Seidewitz
Model Driven Solutions, Inc. ● http://www.modeldriven.com
ed-s@modeldriven.com ● @Seidewitz
http://slideshare.net/seidewitz

Goals
Part 1 –Simulation Modeling
• Learn the basics of the Alf action language for executable modeling.
• Learn how to use Alf as an action language in SysML models.
• Practice executing simulations of models that use Alf.
Part 2 – Trade Study Modeling
• Learn how to use the Trade Study Pattern.
• Use Alf together with parametric constraints in SysML models.
• Use simulation models in trade studies.

Prerequisites
• Participant
– Knowledge of SysML modeling using MagicDraw or Cameo System Modeler
– Some experience with model execution using Cameo Simulation Toolkit
– Introductory understanding of using Alf with SysML (e.g., from Part 1 of this tutorial)
• System (for hands-on exercises)
– Cameo System Modeler 19.0 SP2 (or MagicDraw and SysML)
– Cameo Simulation Toolkit 19.0 SP2 (included in CSM Enterprise Edition)
– Alf Plugin 19.0 SP2
• Slides: Available at https://www.slideshare.net/seidewitz

4
Installing the Alf Plugin
Plugin documentation is available at:
https://docs.nomagic.com/display/ALFP190SP2/Alf+plugin
Under Plugins
(commercial),
download / install the
Alf plugin v19.0 SP2.
Select Help ► Resource/Plugin
Manager to open the Resource/
Plugin Manager window.

Background

Executable UML
Executable UML is a (growing) subset of standard UML that can be used to define, in
an executable, operational style, the structural and behavioral semantics of systems.
• Foundational UML (structural and activity models)
– http://www.omg.org/spec/FUML
• Precise Semantics of UML Composite Structure (PSCS)
– http://www.omg.org/spec/PSCS
• Precise Semantics of UML State Machines (PSSM)
– http://www.omg.org/spec/PSSM
• Action Language for Foundational UML (Alf)
– http://www.omg.org/spec/ALF
A textual surface representation for UML modeling elements with the
primary purpose of acting as the surface notation for specifying executable
(fUML) behaviors within an overall graphical UML model.
Alf Plugin

Why an action language?
Graphical notations are good for…
Structural models High-level behavioral models

Why an action language?
…but not so good for detailed behavior
Full executability requires complete
specification of behavior and
computation. This is often much more
easy to specify using a textual notation.

Why not just use a scripting language?
• Scripting language:
No standard syntactic or semantic integration with UML
• Alf:
Full, standardized syntactic and semantic integration with UML
this.lineItems->remove(item)
this.totalAmount = Subtract(this.totalAmount, item.amount)
ALH.removeValue(self, "lineItems", item);
arguments = ALH.createList();
arguments.add(ALH.getValue(self, "totalAmount"));
arguments.add(ALH.getValue(item, "amount”));
ALH.setValue(self, "totalAmount",
ALH.callBehavior("Subtract", arguments));
Example using the MagicDraw-
specific Action Language
Helper API for JavaScript.

Hands On
SysML Hello

Create the Hello project
Select Create New Project
under Manage Projects or
File ► New Project to open
the project creation window.
Create a Hello
project.
Under System
Engineering, select
SysML Project. (This is
the default for CSM.)

Load the Alf Library
Select Tools ► Alf ► Load Library
to load the Alf Library.

Open the Alf Editor window
Select Window ► Alf to
open the Alf Editor window.
You can dock it here,
if you wish.

Create a Block Definition Diagram

Create a block
Add a value property
whose value is your
name.

Create a classifier behavior for the block
Create a
new Activity.
Enter Alf code in the
Alf editor window.
When the code is
correct, click Save.

Execute the block
Right click on the
Activity and select
Simulation ► Run.
Set Animation Speed
to the highest level…
…and click
here to run.
Output appears in
the console pane.

Introduction

The basic idea: Alf maps to fUML
activity DoSomething(in input: Integer, out output Integer): Integer {
output = A(input);
return B();
}
Alf behavioral notation
maps to fUML activity
models.
The semantics of the Alf notation is
defined by its mapping to fUML

Assignment as data flow
a = +1;
b = -a;
a = A(a) + B(b);
Local names map to
forked object flows.
Subexpressions are
evaluated concurrently.
A re-assigned local
name actually maps
to a new flow.
 The literal “1” has type
Natural. The expression
“+1” has type Integer. The
expression “A(a) + B(b)” has
type Integer, which is not
compatible with Natural.
The local name a implicitly
gets the type Integer.
Statements map to structured
activity nodes with control flows
to enforce sequential execution.
a = 1;
a = A(a); ✗
type conformance

Operations and methods
this.powerLevel = powerLevel;
this.output = powerLevel * this.maxOutput;
return this.output;
newPowerLevel = … ;
this.fan.setPowerLevel(newPowerLevel);
fanOutput = this.fan.getOutput();
Operation calls.
The behavior that implements an
operation is called its method.
Property access.
ⓘ Operation calls are synchronous invocations.
The caller waits until the operation method
execution completes.

Transition and state behaviors
Alf can be used to define
transition and state behaviors
in state machines.

Signal receptions
this.fan.TurnOn();
…
this.fan.TurnOff();
A signal send has a similar syntax to
operation calls, but referencing a signal
reception, rather than an operation.
 A signal can only be sent using Alf
to an object whose class has a
reception declared for the signal.
ⓘ Signal sends are asynchronous
invocations. The sender continues
immediately after the signal is sent.

Ports and interfaces
this.fan_out.TurnOn();
fanOutput = this.fan_out.getOutput();
A port is referenced
like a property.
 Signal sends and operation
calls through a (proxy) port
must be handled by the block
classifier behavior or delegated.
Signal receptions
are necessary only
on the interface.

Opaque actions and guards
An Alf expression (no final semicolon)
in an opaque action produces its
value on a single output pin.
The (pin) name of the input to a
decision node can be used in guards.
An opaque action body may
contain one more Alf statements
(with final semicolons).
ⓘ The Alf code in an opaque
action is essentially compiled into
a call to a generated activity.

Hands On
Heating Simulation

Create the Heating Simulation project

Load the Alf Library and open the Alf Editor window

Create the model package structure

Create the Cooling_IF interface block
Create a signal…
…then create an interface
block with a signal
reception for the signal.

Create an initial block definition diagram
Add value properties, ports
and operations as shown.

Create an initial internal block diagram
Connect the environment
to the house climate.

Create the Environment state machine
Add a self-transition with a
time-event trigger.

Create an opaque behavior
Under Effect, set the
Behavior Type to
Opaque Behavior.

Add Alf code
Click on the transition to enter
code for its effect behavior in
the Alf editor window.
Arguments give values
for signal attributes.

Create the House Climate state machine
Add a self-transition triggered
by the Cool signal.

Add Alf Code
Create an effect behavior, and
then add Alf code for it.
The special evt parameter refers to
the received signal instance.

Create the cool method
Right click on the cool operation
and select Create Method ►
Behavior to open the Behavior
selection window.
Enter the Alf code in
the Alf editor window.
Choose either
Activity or
Opaque Behavior.
ⓘ The braces { } are
required in if statement
clauses in Alf.

Execute the model so far
Move the Animation speed
slider all the way right.
Right click on the Heating Simulation
block and select Simulation ► Run
to execute the model.
Click here to start
the simulation
Watch the temperature
change here.

Add an interface block with
a signal reception for the
new Heat signal.
Add the Heating_IF interface block
Add additional signals.

Add the Heater block
Add new operation.
Add new block.
Add new attribute.
Add new port.

Update the internal block diagram
Connect the heater to
the house climate.
Add the heater
part property.

Update the Climate state machine
Add a new transition
triggered by the Heat
signal with Alf code to
call the heat operation.
Create a method behavior
for the heat operation.

Create the Heater state machine

Execute the model again
Start the simulation,
then select the Heater.
Right click on the Heating Simulation
block and select Simulation ► Run
to execute the model again.
Click here to turn the
Heater on and off.

Add Heater_IF and Thermostat_IF interface blocks
Add one additional signal. Add additional interface
blocks with signal
receptions as shown.

Add the Thermostat block
Add new block.
Add new port.
Add new port.

Update the internal block diagram
Connect the thermostat
to the heater and the
house climate.
Add the thermostat
part property.

Update the Climate state machine
Double click on the Running
state (as a whole) to open its
specification window.
Under Entry, set the
Behavior Type to
Opaque Behavior.
Click on just the entry
behavior line and enter code
in the Alf editor window.

Create the Thermostat activity
Set Is Unmarshall to true in the
specification for the accept-event
action before setting the signal.
Click on an opaque action to
add code for it in the Alf editor.
 In the opaque action symbol
properties, set Show Tagged
Values to false and Show
Stereotypes to Do Not Display.

Add guards in Alf
Double-click on the
control flow to open
its specification.
Select Guard and click
on the … symbol.
Select Alf as the
Language.
Enter a Boolean Alf expression
(no semicolon) here.

Execute the complete model

Bonus: The Thermostat activity in Alf
The block must have a signal
reception for Monitor.
A loop is required to permit
multiple signal acceptances.
An accept statement can
assign a received signal
instance to a name.

Leveraging Alf for SysML, Part 1: Better Simulation Modeling

In this document