**Classification tags**: business operations management, DES, next-event time progression

The potentially relevant object types are:

- customers,
- service desks,
- service queues,
- service clerks.

Potentially relevant types of events are:

- customer arrivals,
- customers queuing up,
- customers being notified/invited to move forward to the service desk,
- start of service,
- end of service,
- customer departures.

Both object types and event types, with their participation associations, can be visually described in a UML class diagram, as shown below.

ON (event type) | DO (event routine) | Diagram |
---|---|---|

customer arrival | If the service desk is busy, then the new customer queues up, else the service starts. | |

service start | After some time, the service ends. | |

service end | The served customer departs. If there are still customers waiting in the queue, then the next service starts. |

The involved types of events can be related with each other via their (possibly conditional) temporal succession, as visualized in the following BPMN process diagram:

A computational design for the purpose of computing one statistic: the *mean response time*,
defined as the average length of time a customer spends in the system from arrival to departure,
which is equal to the average waiting time plus the average service duration. For being able to compute the
mean response time, we need to store the arrival time of all arrived customers.
This can be achieved by explicitly modeling customers as an object type, in addition to service desks. So,
we get the following types of objects:

having one (decimal-valued) attribute`Customer`

`arrivalTime`

;having an association with`ServiceDesk`

`Customer`

representing the multi-valued reference property`waitingCustomers`

, and a random variable`serviceDuration()`

that models the random variation of service durations (expressed as a function).

There are two event types:

having two participation associations representing the reference properties: (1)`CustomerArrival`

`customer`

with the class`Customer`

as range, and (2)`serviceDesk`

with the class`ServiceDesk`

as range. As an exogenous event type,`CustomerArrival`

has a`recurrence`

function representing a random variable for computing the time in-between two subsequent event occurrences.having one participation association with`CustomerDeparture`

`ServiceDesk`

representing the reference property`serviceDesk`

.

Notice that in our design we don't need the participation association between `CustomerDeparture`

and
`Customer`

since for any customer departure event the customer concerned can be retrieved by
getting the first item from the `waitingCustomers`

queue.

The object types and event types described above, together with their participation associations, are visually described in the following UML class diagram:

ON (event type) | DO (event routine) |

CustomerArrival( c, sd) @ t with c:Customer and sd:ServiceDesk |
PUSH c TO sd.waitingCustomers IF sd.waitingCustomers.length = 1 THEN SCHEDULE CustomerDeparture( sd) @ (t + ServiceDesk.serviceDuration()) |

CustomerDeparture( sd) @ t with sd:ServiceDesk |
POP c FROM sd.waitingCustomers IF sd.waitingCustomers.length > 0 THEN SCHEDULE CustomerDeparture( sd) @ (t + ServiceDesk.serviceDuration()) |

- ServiceDesk-1: A service queue model
(one service and one queue) with two statistics:
*maximum queue length*and*service utilization*. The model abstracts away from individual customers and from the composition of the queue. - ServiceDesk-3: A service queue model where the service is modeled as an activity with the service desk as its resource, for which the utilization statistics is computed automatically.
- ServiceDesk-4: A service queue model where the
service desk is modeled as a processing node of a processing network that has an entry node and
an exit node for arriving and departing customers. The model is based on the pre-defined
*Processing Network*concepts: WorkObject, Arrival, EntryNode, ProcessingNode and ExitNode, such that processing objects 'flow through the system'. - ConsecutiveServices: An activity-based service queue model of two consecutive service providers with customer waiting lines.
- ProcessingNetwork-1: A service queue model
where service providers are modeled as processing nodes (with input queues) within a processing network
that has an entry node and an exit node for arriving and departing customers. The model is based on
the pre-defined
*Processing Network*concepts: WorkObject, Arrival, EntryNode, ProcessingNode and ExitNode, such that processing objects 'flow through the system'.

- Queueing_Simulation_Discrete_Event: This NetLogo simulation uses NetLogo's tick-advance primitive to advance simulation time by non-integral amounts. However, NetLogo's standard ticks display is unable to display non-integral values, so a custom ticks display has to be programmed. Copyright 2010, Nick Bennett.