Processing Network Models

In a Processing Network (PN) model, processing objects (representing, e.g., customers or raw materials) enter a system via arrival events at an entry node and then flow through one or more processing nodes (representing, e.g., sevice desks or manufacturing machines) where they are subject to processing activities before they leave the system at an exit node via a departure event.

The concepts of PN modeling in OEM&S are based on the fundamental DES modeling concepts of objects, events and activities. The nodes of a PN model represent modeling elements that are overloaded with two meanings. Both entry and exit nodes combine a (possibly spatial) node object and an associated implicit (arrival or departure) event type, while processing nodes combine a (possibly spatial) node object and an associated implicit activity type. This semantic overloading makes PN models more concise and easier to read and understand.

Due to its intuitive building blocks and its applicability to problems in the manufacturing and service industries, PN modeling is the most widely used DES modeling paradigm. It is supported by many simulation tools, such as Arena, Simio, ExtendSim, Simul8, and AnyLogic, each of them using their own proprietary terminology and diagram language for the same concepts.

The OEM&S concepts for PN modeling are an open source alternative to the proprietary PN modeling techniques of these commercial tools, and can be used as a reference conceptual framework for understanding and comparing them.

Comparison of different terminologies used for the same PN modeling concepts.
OES-PN Arena Simul8 Simio AnyLogic

Processing Object

Entity

Work Item

Token

Agent

Entry Node

Create

Start Point

Source

Source

Processing Node

Process

Queue + Activity

Server

Service

Exit Node

Dispose

End Point

Sink

Sink

Entry Nodes

The definition of an entry node combines defining both a (possibly spatial) entrance object and an associated implicit arrival event type. Real world arrival events have at least two participants: the entrance (or arrival point) object and one or more arriving processing objects. Simulated arrival events may have only one participant (the entrance object) in an approach where OOP objects that represent arriving processing objects are created and later (after their departure) destroyed. In any case, the arrived processing objects are either routed to a successor node or placed into an output buffer. Examples of objects that can be modeled as entry nodes are: office or building entrances and mail reception offices.

Basic Features

An entry node object definition may include

  1. either
    1. an arrivalRate attribute slot for defining the event rate parameter of an exponential probability distribution function used for computing the time between two consecutive arrival events, or
    2. an arrivalRecurrence function for computing the recurrence of arrival events (typically, a random variable).
  2. an objectsPerArrival attribute slot for defining the number of objects arriving with each arrival event (either a fixed number or a random variable);
  3. a maxNmrOfArrivals attribute slot for defining a maximum number of arrival events after which no more arrival events will be created (and, consequently, the simulation may run out of future events and, as a consequence, end);
  4. either
    1. a successorNode attribute for assigning a fixed successor processing node to which processing objects are routed, or
    2. a chooseSuccessorNode function for modeling routing decision logic, or
    3. an outputBufferCapacity attribute slot for setting the maximum number of processing objects that may be placed in the output buffer of the node.
four-consecutive-machines
A PN model of four consecutive machines.

Entry nodes have a built-in (read-only) statistics attribute nmrOfArrivedObjects counting the number of objects that have arrived at the given entry node.

Advanced Features

An entry node definition may include

  1. an outputType slot for defining a custom output object type (instead of the default pROCESSINGoBJECT type);
  2. an onArrival event rule method for defining specific state changes or scheduling specific follow-up events.

Processing Nodes

The definition of a processing node combines defining both a node object and an associated implicit type of processing activity. A processing node object normally has an input buffer and may also have an output buffer, when its processing objects are not pushed to, but pulled from, a successor node. Examples of processing node objects are: service desks, automated teller machines and manufacturing machines. A processing activity performed at a processing node object has at least two participants: the node object and one or more processing objects.

In addition to the node object, a processing activity may require further resources, such that at least one of them plays an actor role. For instance, when modeling a hospital, an operating room may be modeled as a processing node object and the medical staff members needed for performing the operation are modeled as further resources (in terms of required actor roles). When modeling a manufacturing plant, a workstation may be modeled as a processing node object that plays the role of an actor (possibly jointly with human operators modeled in terms of additional resource roles).

Basic Features

A definition of a processing node may include

  1. an inputBufferCapacity attribute slot for setting the maximum number of processing objects that may be placed in the input buffer of the node (may be set to infinity, by default).
  2. a processingCapacity attribute slot for setting the number of processing objects that are processed at a time to a number greater than 1, which is the default;
  3. either
    1. a fixedDuration attribute for setting the duration of the node's processing activities to a fixed value, or
    2. a randomDuration function for modeling the durations of the node's processing activities as a random variable.
  4. either
    1. a successorNode attribute for assigning a fixed successor processing node to which processing objects are routed, or
    2. a chooseSuccessorNode function for modeling routing decision logic, or
    3. an outputBufferCapacity attribute slot for setting the maximum number of processing objects that may be placed in the output buffer of the node.

Utilization statistics may be computed automatically for all processing node objects and other resource objects that participate in the processing activity performed at the node.

Advanced Features

A processing node definition may include

  1. an inputType slot for defining a custom input type instead of the default pROCESSINGoBJECT input type;
  2. an inputTypes collection slot for defining the types of input objects whenever a processing node processes objects of several types;
  3. an outputTypes collection slot for defining the types of output objects whenever a processing node transforms input objects of certain types to output objects of certain other types;
  4. an onActivityStart event rule method for defining specific state changes or scheduling follow-up events when a processing activity is started;
  5. an onActivityEnd event rule method for defining specific state changes or scheduling follow-up events when a processing activity ends.

Exit Nodes

The definition of an exit node combines defining both a (possibly spatial) exit object and an associated implicit departure event type. Departure events have at least two participants: the exit object and one or more departing processing objects, which may be removed from the simulation after their departure.

Basic Features

Exit nodes have two built-in statistics attributes:

  1. nmrOfDepartedObjects counting the number of objects that have departed at the given exit node, and
  2. cumulativeTimeInSystem for adding up the times in system (also called cycle times) of all departed objects, such that the average time in system (average cycle time) can be computed at the end of a simulation run.

Advanced Features

An exit node definition may include an onDeparture event rule method for defining specific state changes or scheduling follow-up events when a processing object departs.