MIDA (Multiple Instances and Data Animator) is a BPMN animator based on the Camunda bpmn.io web modeler. MIDA integrates our BPMN formal semantics into the bpmn.io token simulation plug-in. We have enriched this plug-in with a wider set of BPMN elements and redefined their semantics. Moreover, we have implemented data objects, data-driven gateways, pattern-matching for messages and correlation.
MIDA is freely available here, for users convenience, we provide a list of BPMN example models that can be run on MIDA
To access the MIDA tool open this link http://pros.unicam.it:8080/Mida/modeler.html. The interface provides an example model for showing the MIDA capabilities.
Modelling with MIDA
MIDA embeds a user-friendly BPMN modeling environment by which design the BPMN models (including data) using the element palette on the left, or load their own model by uploading the .bpmn file already defined. Information regarding data, multiple instances and messages can be accessed via Property Panel at the custom tab Mida. Choosing a Pool element the user can define the multiple instance characteristics specifying the minimum and the maximum of the desired participant multiplicity.
To define multiple instance activities modelers have to click on the element for opening its palette, then click on the wrench and click on a multiple instance marker. Then, by opening the Property Panel the designer can fill the loop cardinality filed with an integer value.
Define: x Assign: x = 9 Compare: x >= 2
To specify variables into data objects we use the element Data Field. It can be accessed via Property Panel. Here, users can define variables also with an initial value. Each definition has its own text field.
Mida supports also Data Input/Output for representing process input/output data, and Data Collection that represent a collection of Data Objects. For instance, a Data Collection field
x is a list of values that can be singularly accessed by multiple instances tasks.
// x = [0,0,0,0] getItem(DataCollection) // x = [0,0,0] x = 2 putItem(DataCollection) // x = [0,0,0,2]
Guards and the assignments can be specified in the same way inside the Guard and Assignment field of the activity. The guard has to be a boolean expression over data fields or constant values:
eld & field2 != 0 //guard
The assignments have to be expressions such as:
field3 = field; //expressions fiels2 ++;
Data can be related to a particular instance by using the predefined keyword instance inside data objects or data. This variable represents dynamically the unique identifier of the instance that is performing the operation.
Condition expressions for the data-driven gateways have to be defined into the property panel of each outgoing sequence flows. From the condition, type select Expression and specify a boolean expression.
Messages can share data between pools. To do that, the designer has to specify the content of the message sent by the element (Send Task or Intermediate Throw Event). The property panel provides custom Message fields in which is possible to insert variables and constant values. To receive this data, the designer has to specify a message template in the Message field of the Property Panel of the receiving element (Receive Task or Intermediate Catch Event). The template consists of a list of fields containing variables and constants. Possibly the user can check the correlation box to match a specific message.
The message will be correctly delivered if:
- the send and the receive have the same number of fields
- the correlation fields in the receive are equal to the corresponding sent field
Following the example, the result of the message passing is the following:
a; b; 0; c //send x; !y; z; !'ok' //receive if b === y and c === 'ok' then x = a; and z = 0;
Task Type specifies the execution behavior of an activity that can be either atomic, non-atomic concurrent and non-atomic non-concurrent. The first choice runs the activity in one time while non-concurrent divides the activity execution into two or more steps. The concurrent non-atomic execution allows also to run the same activity more than once at the same time.