Business process simulation is a flexible technique that allows analysts to compare alternative scenarios and contribute to the analysis and improvement of business processes. This work presents BPSimpy, a business process simulation Python library, to generate a simulation specification file in a standard format that allows seamless integration with diferent simulators. BPSimpy can, e.g., be integrated with libraries for Data and Process Mining, thus bringing together the worlds of mining and business process simulation. For instance, event logs can be used to discover accurate business process simulation models consisting of a business process model and several simulation aspects that parametrize diferent process perspectives, such as the time perspective, the resource perspective, and the decision perspective.
Business process simulation refers to techniques for the simulation of business process behavior
on the basis of a simulation model consisting of a business process model extended with additional
information for the definition of the diferent run-time
simulation aspects: case arrival rate, task
durations, routing probabilities, resource allocation and utilization, etc. Simulation provides
a flexible approach to analyse and improve business processes [
Typically, a business process simulation requires, as a first step, to extract a business process
model from the process information (e.g. process documentation, stakeholders interviews,
observational data, process data, event logs, etc.) such as a BPMN model [
This paper reports on BPSimpy, a business process simulation Python library to programmatically generate business simulation files. This way, one can write Python code that leverages on data- and/or process-mining libraries to obtain simulation models that accurately reflect the reality. In fact, the choice of Python is driven by the fact that this language is already equipped with libraries for process mining (e.g. PM4Py1), machine learning, data science (e.g. Pandas, Numpy, Scipy, Tensorflow, Keras, etc.), and more.
One of the strongest points of BPSimpy is the ability to generate simulation models compliant with the Business Process Simulation Specification (BPSim), a standard format by the Workflow 1 import BPSimpy 2 example = BPSimpy . BPSim ( `BPMN . xml ' ) 3 s c e n a r i o = example . a d d S c e n a r i o ( i d = ` S1 ' , name= ` P i z z a shop ' ) 4 s t a r t = s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` S t a r t ' ) ) 5 s t a r t . a d d I n t e r T r i g g e r T i m e r ( v a l u e = d a t e t i m e . t i m e d e l t a ( minutes = 5 ) ) 6 r e c e i v e O r d e r = s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` R e c e i v e Orde r ' ) ) 7 r e c e i v e O r d e r . a d d P r o p e r t y ( name= ` n o O f P i z z a s ' , n a m e D i s t r i b u t i o n = ` P o i s s o n D i s t r i b u t i o n ' , mean = 4 ) 8 r e c e i v e O r d e r . a d d P r o c e s s i n g T i m e ( n a m e D i s t r i b u t i o n = ` T r u n c a t e d N o r m a l D i s t r i b u t i o n ' , min=0 , max=10 , mean =2 , s t a n d a r d D e v i a t i o n = 1 ) 9 r e c e i v e O r d e r . addWaitTime ( v a l u e = d a t e t i m e . t i m e d e l t a ( minutes = 1 ) ) 10 bake = s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` Bake P i z z a ' ) ) 11 bake . a d d P r o c e s s i n g T i m e ( e x p r e s s i o n = ` ` bpsim : g e t P r o p e r t y ( ` n o O f P i z z a s ' ) ∗ 7 ' ) 12 bake . addWaitTime ( n a m e D i s t r i b u t i o n = ` T r u n c a t e d N o r m a l D i s t r i b u t i o n ' , min=0 , max=100 , mean =5 , s t a n d a r d D e v i a t i o n = 2 ) 13 d e l i v e r y P i z z a = s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` D e l i v e r y P i z z a ' ) ) 14 d e l i v e r y P i z z a . a d d P r o c e s s i n g T i m e ( n a m e D i s t r i b u t i o n = ` T r u n c a t e d N o r m a l D i s t r i b u t i o n ' , min=0 , max=120 , mean =10 , s t a n d a r d D e v i a t i o n = 8 ) 15 d e l i v e r y P i z z a . addWaitTime ( v a l u e = d a t e t i m e . t i m e d e l t a ( minutes = 5 ) ) 16 YesSeq = s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` yes ' ) ) 17 YesSeq . a d d P r o b a b i l i t y ( v a l u e = 0 . 0 2 ) 18 NoSeq= s c e n a r i o . g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` no ' ) ) 19 NoSeq . a d d P r o b a b i l i t y ( v a l u e = 0 . 9 8 ) 20 O r d e r C o l l e c t o r = g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` Order C o l l e c t o r ' ) ) 21 O r d e r C o l l e c t o r . a d d Q u a n t i t y ( v a l u e = 1 ) 22 PizzaMaker = g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` P i z z a Maker ' ) ) 23 PizzaMaker . a d d Q u a n t i t y ( v a l u e = 3 ) 24 DeliveryMan = g e t E l e m e n t P a r a m e t e r s ( example . getIdByName ( ` D e l i v e r y Man ' ) ) 25 DeliveryMan . a d d Q u a n t i t y ( v a l u e = 3 ) 26 r e c e i v e O r d e r . a d d S e l e c t i o n ( e x p r e s s i o n = ` ` bpsim : g e t R e s o u r c e ( ` O r d e r C o l l e c t o r ' , 1 ) ” ) 27 bake . a d d S e l e c t i o n ( e x p r e s s i o n = ` ` bpsim : g e t R e s o u r c e ( ` PizzaMaker ' , 1 ) ” ) 28 d e l i v e r y P i z z a . a d d S e l e c t i o n ( e x p r e s s i o n = ` ` bpsim : g e t R e s o u r c e ( ` DeliveryMan ' , 1 ) ” )
Management Coalition (WfMC) [
The BPSimpy library takes a BPMN process model and the simulation parameters as input and generates a BPSim simulation model. The BPSim simulation model is organized in simulation scenarios. A simulation scenario specifies the initial conditions at the beginning of the situation and the diferent simulation parameters, necessary to set up a simulation run. Simulation parameters are also attached to the elements of the BPMN process model (events, tasks, gateways, sequences, etc.) to configure their simulation-time behavior. BPSimpy supports simulation parameters related to the various process perspectives: time, control, resources, cost, priority, and data. The definition of process’ data objects is done via a set of process properties.
We describe the functionalities of the BPSimpy library through the example in Fig. 1. The 2https://www.lanner.com/en-us/technology/l-sim-bpmn-simulation-engine.html 3https://sparxsystems.com/products/ea/trial/request.html diferent elements of the BPMN model are associated with some simulation parameters related to the perspectives on time, resources and control. Note how the example defines waiting times independently of the availability of resources: often, process tasks are not started as soon as they are enabled and resources are available, because resources work on multiple processes, take working breaks, execute duties that leave no trails in event logs, and other practical factors.
Fig. 2 shows the Python code to implement this simulation scenario. After importing the BPSimpy library (line 1), we call the constructor of a BPSim object passing the BPMN specification file (line 2). The next step is to create a scenario ( method a d d s c e n a r i o ( ) , line 3). Once the scenario is created, the simulation parameters are associated to the diferent elements of the BPMN model, such as tasks, events, sequences, etc. The method g e t E l e m e n t P a r a m e t e r s ( i d ) (line 4,6,10,...) returns an handle object to invoke the methods to associate the parameters to the BPMN element with a given i d . If this is not known the method g e t I d B y N a m e ( n a m e ) (line 4) allows one to retrieve it by the element name. Line 5 associates a control parameter to the start event: the interTriggerTimer, which models the case arrival rate. Line 7 sets a property parameter, that models the attribute ‘noOfPizzas’ for the first task Receive Order. In line 17 and 19 the routing probabilities for the XOR gateway are added through the method a d d P r o b a b i l i t y ( ) . Lines 22 to 30 associate the quantity of resources to each roles (method a d d Q u a n t i t y ( ) ). Each task is linked to the corresponding role that resources need to be able to play to perform it (method a d d S e l e c t i o n ( ) ).
Note how BPSim’s simulation parameters are typed according to their nature and necessary
configuration, which our library BPSimpy fully supports: constants, distributions , enumerations,
and XPATH 1.0 expressions (see the BPMSim guide for details [
This section reports a case study of a real business process. The event log is taken from the Second International Business Process Intelligence Challenge (BPI2012).4 The event log refers to an application process for a personal loan or overdraft within a global financing organization. The event log is a merger of three intertwined sub processes and we decided to showcase on an individual subprocess (subprocess A). We leveraged on the Pm4Py library and other statistic libraries in Python to first mine a fitting, precise BPMN process model and later complement with the other simulation parameters, namely: (i) the probability distribution function of the inter arrival rate, considering the case-arrival calendar from 8am to 11pm; (ii) the branching probabilities for each XOR split in the process model; (iii) the probability distributions of the processing time of every model task; (iv) the set of roles with the resources belonging to each; (v) the working calendar hours for each role, and (vi) the mapping of each activity a to each role that resources must play to be able to perform a. Once we discovered the BPMN process model and the simulation parameters, we employed our BPSimpy library to write a BPSim simulation 4https://www.win.tue.nl/bpi/doku.php?id=2012:challenge ifle. As last step, this file was given as input to the Lanner simulator (L-sim) to carry out the simulation. L-sim returns a zip file as output that contains the simulated event log and a file with the simulation statistics of interests. The result-request configuration was employed through our library to analyze the performance the queue length and the waiting time for each task. This analysis can be useful to individuate process improvements. Note that the generation of an event-log file in XES format is supported by the Lanner simulator through a so-called vendor extension, a concept supported by the BPSim and configurable via our BPMSimpy library.
Further information on the case study is available in the library Github repository.5 The repository also contains a tutorial based on a Jupiter Notebook on Google Colab that presents the case study along with a screencast demonstrating the usage of the BPSimpy library. This way, the Github repository incorporates a collaborative system where users can download and use the BPSimpy library, report problems and contribute to the code.
This paper reports on BPSimpy, a mature Python library that allows for programmatically creating business process simulation models in BPSim, a WfMC standard supported by multiple simulators. The library and the underneath standard supports several simulation parameters to enhance incorporate information related to time, control, resources and decision. The library is meant to enable the integration of the Process- and Data-Mining worlds to create accurate simulation models. These models enables monitoring processes, determining such critical aspects as resource over- and under-use, bottlenecks, cost and time wasting, to provide actionable insights to enable for a subsequent process improvement.
Acknowledgement. This research work is partly supported by the Department of Mathematics of University of Padua through the SID/BIRD 2020 project “Deep Graph Memory Networks”.