Review of simulation software for cyber-physical production systems with intelligent distributed production control

ABSTRACT

Many intelligent distributed production control architectures have been developed for cyber-physical production systems (CPPSs), but the difficulty in predicting performance has hindered acceptance by industry. Performance predictions for systems with conventional control can be made by simulating product flow using discrete-event simulation (DES) software. However, DES is inadequate for capturing the intricacies of intelligent distributed production control architectures. Alternatively, agent-based simulation (ABS) software is more effective for capturing distributed intelligence. A hybrid discrete-event and agent-based simulation tool combines the strengths of both approaches, making it effective for capturing the intertwined physical and cyber layers of a CPPS. In this paper, a review is carried out to determine which off-the-shelf simulation tools are capable of using hybrid discrete-event and agent-based simulation for performance predictions in the conceptual design phase of a CPPS. This review is carried out using the following structured steps. First, the scope and evaluation criteria are identified. Next, a selection of simulation tools is collected. The selected tools are then evaluated and classified. Finally, the most promising simulation tool according to this evaluation – Anylogic – is subjected to a case study to assess if hybrid simulation can be used to predict the performance of a CPPS.

KEYWORDS:

• Cyber-physical production systems
• simulation software
• hybrid simulation
• discrete-event simulation
• agent-based simulation

1. Introduction

One of the main challenges for the cyber-physical production systems (CPPSs) paradigm is the ability to prove its advantages in terms of flexibility and performance (Cardin 2019). Over the years, manufacturing research has been moving away from conventional centralized production control structures towards distributed production control structures such as for example intelligent, holonic, and multi-agent manufacturing systems. These control structures all have the common feature that intelligence (decision-making) is distributed throughout the system. Even though these technologies have been active areas of research for quite some years now, they are still not yet common practice in industry (Karnouskos and Leitão 2017). One of the roadblocks for acceptance mentioned in both Thomas, Trentesaux, and Valckenaers (2012) and Leitão and Karnouskos (2015) is the difficulty in predicting the performance of the system. These technologies utilize distributed intelligence for increased flexibility and reactivity of the system, but the downside is that the system’s emergent behaviour is inherently unpredictable. Conventional production systems appeal to industry because performance measures such as throughput and makespan are predictable. For CPPSs with distributed intelligence to become common practice in industry, requires evidence of similar performance in normal operating conditions and better adaptability to disturbances. Leitão and Karnouskos (2015) advocate for using simulation to predict if such performance can be obtained when using distributed control structures. Such simulation is generally done in a ‘simulation software tool’ (for brevity this will be shortened to just ‘tool’ in the rest of the paper). The motivation for this review is to identify which tools have the capabilities for making performance predictions for CPPSs with intelligent distributed production control.

1.1. Cyber-physical production systems

Cyber-physical production systems can generally be divided into a plant layer (physical part) and a production control layer (cyber part). The plant layer consists of physical resources which process the products in the system, and between which there is a flow of products. For the production control layer, Tilbury (2019) describes two distinct types of control; (centralized) hierarchical control, and (intelligent) distributed control. Especially the latter has seen a lot of developments in recent years; holonic manufacturing systems with PROSA (Van Brussel et al. 1998), ADACOR (Leitão and Restivo 2006), and ARTI (Valckenaers 2020), Multiagent systems (MAS) with many different implementations such as Shukla et al. (2018) and Li et al. (2018). There also have been control architectures for bio-inspired manufacturing (Dias-Ferreira et al. 2018), for automated learning control (Kovalenko et al. 2022), and for digital twin integration (Latsou et al. 2021). What all of these paradigms have in common is that the control layer consists of intelligent entities (typically called agents). These entities communicate with each other and with the physical resources to control production (Karnouskos et al. 2019). A comparison of design patterns in distributed control approaches can be found in (Cruz Salazar et al. 2019).

A generic model of a CPPS with intelligent distributed production control is shown in Figure 1. Exemplified in Figure 1 is that a CPPS can be designed with various levels of integration between these two layers. For example in holonic manufacturing systems, the agents and physical resources are closely integrated, while in multi-agent manufacturing systems they are not (Leitão 2009). However, regardless of which specific architecture is used, to accurately predict the performance of the CPPS both the physical and the cyber layer must be simulated.

Figure 1. A generic model of a CPPS (based on Figure 2 in (Karnouskos et al. 2019)).

Figure 2. The review methodology.

1.2. Discrete-event simulation

One of the challenges in designing CPPSs lies in evaluating different solution concepts and optimizing these concepts in the early design phases (Hehenberger et al. 2016). In the conceptual design phase the intended flows of material and information are being established, but exact specifics on the implementation of the system are not yet formalized. A simulation tool that supports material flow simulation can be used to make predictions on the performance of a production system in the early phases of the design process (Mourtzis, Doukas, and Bernidaki 2014). Other simulation paradigms that focus on later phases of the design process, such as virtual commissioning (Lechler, Sjarov, and Franke 2020), are not in the scope of this review.

Conventionally, the go-to simulation paradigm for simulating the flow of material in production systems has been discrete-event simulation (DES) (Scheidegger et al. 2018). There is some discussion on what should be classified as DES. Its name suggests that it is simulation with discrete-states and with next-event time advancement. However, DES is generally associated with a process-oriented modelling approach, in which the flow of entities plays a key role (Siebers et al. 2010). In this paper ‘DES’ software refers to simulation software which is capable of simulation with discrete-states and next-event time advancement, with process-oriented modelling. The process-oriented modelling approach provides a natural way of modelling the flow and processing of products through the production system. However, this approach is also characterized by its models having a centralized thread of control with decision-making embedded into the process flow (Siebers et al. 2010). This makes it less suitable for capturing the behaviour of the intelligent objects utilized in distributed control structures such as for example product agents, and order holons (Cruz Salazar et al. 2019).

1.3. Agent-based simulation

A simulation paradigm that is more suitable for capturing the behaviour of an intelligent distributed production control layer is agent-based simulation (ABS). According to Siebers et al. (2010) ‘ABS is the process of designing an agent-based model of a real system and conducting experiments with this model for the purpose of understanding the behaviour of the system and/or evaluating various strategies for the operation of the system’. Agent-based modelling focuses on modelling a complex system as a collection of individual entities (the agents) and the interactions between them. This makes ABS a natural approach for modelling and simulating the agents and message-based communication in the intelligent distributed production control layer of a CPPS.

1.4. Hybrid ABS+DES simulation

As shown in Nagadi et al. (2018), the advantages of both discrete-event simulation software and agent-based simulation software can be attained by using a ‘hybrid’ simulation tool. The process-oriented modelling approach seen in DES software can be used for modelling the flow of products in the plant layer of a CPPS. The agent-based modelling seen in ABS software can be utilized for modelling the intelligent distributed production control layer of a CPPS. There are more variations of hybrid simulation (see Brailsford et al. (2019) and de Paula Ferreira, William, and de Santa-Eulalia (2020)), but this paper will only focus on a hybrid of DES and ABS, and any mention of hybrid simulation from here on forth refers to this variant.

A state-of-the-art on hybrid simulation in operational research is featured in Brailsford et al. (2019). In the paper, three strategies for integration between DES and ABS are identified: manual integration, integration using intermediary tools, and automated integration. Automated integration – the most popular option, and the type that this review will focus on – is generally executed in simulation software that can handle both DES and ABS. Brailsford2019 note that Anylogic and ExtendSim are the most frequently encountered hybrid DES+ABS simulation tools in academia, with other examples of automated integration mostly comprise of custom-made solutions.

To the knowledge of the authors, there is not yet a review of hybrid DES+ABS simulation software for CPPSs, although Brailsford et al. (2019) (Anylogic, ExtendSim), Scheidegger et al. (2018)(Anylogic, AutoMod, ExtendSim), Pawlewski, Golinska, and Dossou (2012) (Anylogic, Simio and Flexsim), Pal et al. (2020) (Anylogic, MASON, Simul8, SimEvents) all mention simulation software with capabilities for hybrid simulation. Interestingly, many of these sources come to different conclusions on which tools feature hybrid simulation. This is because each has its own interpretation of what features are required for a tool to be capable of hybrid simulation. This review uses a set of criteria to evaluate if a tool should be regarded as a hybrid simulation tool.

1.5. The contribution of this paper

The contribution of this paper is that simulation tools capable of hybrid discrete-event and agent-based simulation of cyber-physical production systems are identified and evaluated. The features required of such a simulation tool are identified, as well as the tools which satisfy these requirements, and what classes can be identified among the tools encountered. A case study – based on the meat processing system with agent-based production control described in Paape, van Eekelen, and Reniers (2021) – was carried out in the most promising tool. This case study shows how hybrid simulation can be used to predict the performance of a CPPS with intelligent distributed production control.

The scope of this review is simulation tools with capabilities for hybrid simulation with the goal of predicting the performance of a CPPS with intelligent distributed production control. The scope is limited to simulation tools with built-in capabilities for hybrid simulation of CPPSs, so that the user may focus time, effort, and expertise on modelling and simulation, instead of programming custom-made solutions. This review is aimed at both academia and industry (and aims to bridge the gap between the two), and thus both open source and proprietary simulation software are considered.

The next section explains the methodology used in this review in more depth.

2. Methodology

The review methodology in this paper is loosely based on the literature review methods in Scheidegger et al. (2018) and Barbosa and Azevedo (2017), but re-purposed with the goal of reviewing hybrid simulation tools for cyber-physical production systems. The methodology used in this paper is shown in Figure 2.

This review starts with the Identification phase in Section 3, in which the scope of the review and the evaluation criteria on which simulation tools are assessed are identified. Next, is the Collection phase in Section 4, in which a list of in-scope tools is gathered. This phase starts by selecting databases and keywords used for searching. The next step is to search these databases and to document all mentioned simulation tools, and how often they are encountered. The search strategy is validated by comparing the list of encountered tools to a list of tools that are expected to be found; this list is based on pre-knowledge and literature. The next step is that the list of tools found using the validated search strategy is filtered. Tools which do not fit the scope, or which are encountered only once in all of the searched literature are filtered out.

In the Evaluation phase in Section 5, the selected tools are assessed based on the evaluation criteria using official sources. The tools are divided into classes based on their capabilities for hybrid simulation of CPPSs with intelligent distributed production control. An analysis is done to determine how tools in each class can be utilized for hybrid simulation of CPPSs. In the Case study phase (Section 6), one of the tools is selected for a case study. This case study is executed to evaluate the use of hybrid simulation for predicting the performance of a CPPS, and to reflect on the evaluation criteria. Finally, in the Conclusion phase in Section 7, some concluding remarks are made on the results of this review.

Supplementary material with details on the execution of these steps can be found at the end of this article.

3. Identification

The first step is identifying the scope of simulation tools that should be included in this review, and on what criteria these tools are to be evaluated.

3.1. Scope

The goal of this review is to determine what simulation tools are suitable for performance prediction of CPPSs. As concluded in the introduction of this paper, a (DES+ABS) hybrid simulation tool would be effective for this objective. The scope of this review is limited to tools aimed at the manufacturing domain and general-purpose tools which have been shown to work for the manufacturing domain.

3.2. Evaluation criteria

In this review, two sets of criteria are evaluated. The first set – hybrid simulation criteria – contains the features deemed necessary for hybrid simulation of CPPSs. The second set – software selection criteria – contains other features which are significant for software selection.

3.2.1. Hybrid simulation criteria

As explained in the introduction, DES and ABS software have characteristics that make them attractive for modelling and simulation of CPPSs. In this paper, a simulation tool is regarded to be effective for hybrid discrete-event and agent-based simulation of CPPSs if it satisfies all the following evaluation criteria:

• (1a) Discrete-event:is simulation discrete-state and event-driven, with next-event time advancement?

• (1b) Process-oriented modelling: does the tool support process-oriented modelling with flow of entities? This modelling approach is useful to model the product flow in the plant layer of a CPPS.

• (2a) Agent-based modelling: does the tool support agent-based modelling? This modelling approach is useful for modelling the agents in the intelligent distributed production control layer of a CPPS.

• (2b) Message-based communication: does the tool allow for message-based communication between agents? Although message-based communication is not always a component of agent-based simulation, it is necessary to model the communication between the agents in the intelligent distributed production control layer of a CPPS.

3.2.2. Software selection criteria

Not only the capabilities for hybrid simulation of CPPSs, but also criteria important for simulation software selection are evaluated in this review. A lot of prior research on the evaluation and selection of simulation tools exists. Just recently, Fumagalli et al. (2019) and Cafasso et al. (2020) presented frameworks for the selection of manufacturing system simulation software. Both included state-of-the-art analyses on evaluation criteria for such software. Similarly, Ruiz et al. (2014) discusses which evaluation criteria are important for simulation of intelligent manufacturing systems. Together, these publications cover many different evaluation criteria, such as general software development features, modelling capabilities, cost, and professional support. However, comparing some of these criteria might be difficult due to the broad spectrum of simulation tools addressed in this review. This spectrum ranges from commercial simulation environments such as FlexSim, to open-source simulation libraries in general-purpose programming languages such as SimPy.

The software selection criteria evaluated in this paper are based on Ruiz et al. (2014), Fumagalli et al. (2019) and Cafasso et al. (2020), and are only a small selection of the many criteria on which simulation software could be assessed. The focus is on modelling and simulation features, along with documentation availability and license type. Below is a description of the evaluation criteria for software selection employed in this paper. Table A2 in the appendix shows how these evaluation criteria relate to some of the criteria in the aforementioned literature.

• (3) Other simulation capabilities: does the tool support other simulation paradigms, such as for example, continuous-time simulation?

• (4a) Model programming: does it allow for the programming of code-based models, and if so, does it utilize a general-purpose programming language or a specially developed modelling/scripting language?

• (4b) Programming language:if so, what programming language is used?

• (5) Graphical process flow modelling: does the tool have graphical (drag-and-drop) process-oriented modelling, with predefined building blocks such as queues and servers?

• (6) Statecharts: does it feature some sort of state diagrams? These offer an intuitive approach for modelling the states of resources and agents.

• (7) Flowcharts: does it feature a type of flow/activity diagram? These offer an intuitive approach for modelling the activities of resources and agents.

• (8a) Modularity: does it support modelling with user-defined model components?

• (8b) Hierarchy: if so, can these user-defined model components be built up hierarchically using other (sub)components?

• (9a) Experiment manager: is there an experiment manager? This would allow to easily simulate and compare multiple scenarios. Examples of applications are parameter variation, sensitivity analysis, Monte Carlo simulation, etc.

• (9b) Optimization: if so, does the experiment manager feature an optimization toolbox that can be used to optimize the design of the CPPS? This allows a simulation tool to not only describe how a system behaves, but also prescribe how it should be designed.

• (10a) Animation: does the tool support, and if so, does it use 2D or 3D animation?

• (10b) Integrated process flow animation: if there is animation, is it integrated into the tool in such a way that modelling the system also creates an animation of the process flow in the system?

• (11) Documentation: is there extensive documentation and training material?

• (12) License: does the tool have an open-source or proprietary license?

4. Collection

4.1. Database and keyword selection

The next step is to collect the list of tools that are to be evaluated. First, the database and keywords used for searching tools must be chosen. The database used for academic literature is Google Scholar, in which the search was limited to publications from after 2010. Tools that have not been mentioned since 2010 are likely no longer relevant or updated. Just as in Dagkakis and Heavey (2016), this is not a review of solely academic literature, so besides searching on Google Scholar for scientific publications, a search was also done with Google using the same search keywords. The search term used is the following combination of keywords:

(‘simulation’) AND (‘software’) AND

(‘manufacturing’ OR ‘production’) AND

(‘discrete-event’) AND (‘agent-based’)

Both the searches in Google and in Google Scholar were performed using Google Chrome in normal browsing mode on 19 February 2021. To verify the relevance of the chosen keywords, additional searches were done using similar terminology, but no significant difference in which tools were found was detected (e.g. searching with the keywords ‘manufacturing systems’ and ‘tool’ instead of ‘manufacturing’ and ‘software’ resulted in similar search results).

4.2. Database search

In both databases, the first 50 results were inspected. All mentions of simulation tools were collected, resulting in a list of 292 tools. The list of tools was then validated to examine whether any prominent tools were overlooked using this search strategy. The list was first compared with a list of tools based on the pre-knowledge of the authors of this paper and included the following simulation tools: Anylogic, Arena, Netlogo, Plant Simulation, Enterprise Dynamics, MASON, SimEvents, and SimPy. The list was then compared with a list of hybrid simulation tools mentioned in literature (Brailsford et al. (2019), Scheidegger et al. (2018), Pawlewski, Golinska, and Dossou (2012), and Pal et al. (2020)). This literature comparison list consists of Anylogic, ExtendSim, FlexSim, Simio, Simul8, Automod, MASON, and SimEvents. All tools in these two lists were encountered at least 3 times using this search strategy, with the most-encountered tool being Anylogic with 43 encounters.

4.3. Filtering

Doing an in-depth analysis of 292 tools was beyond the authors’ capacity, so the list of tools was filtered. The first step was filtering out any tool which was mentioned only once in all of the consulted sources, under the assumption that the most prominent and relevant tools would likely be encountered more than once. After this step, 67 tools remained. The risk with this strategy is that newer tools, which have not seen much use, might have been filtered out. To validate this filtering step, a sample of 50 tools was analyzed (of the 225 filtered simulation tools), to check if any of these tools should have been selected for review based on the hybrid simulation criteria. Of those 50 tools, no tools should have been included in the review.

Next, it was noticed that, despite the selection of keywords, the chosen search strategy still yielded a lot of tools that were outside the scope of this review. These tools were never applied to simulation of manufacturing systems, or only featured either one of DES or ABS, but not both. This is likely due to the broad search strategy in which all tools mentioned in the consulted sources were collected. So, the next step was to consult official and academic sources – such as the tool’s official website or scientific publications – to filter out all tools for which DES, ABS, and applications in manufacturing were not explicitly mentioned. The result was the list of 14 tools shown in Table 1.

Table 1. Tools selected for evaluation.

Anylogic	MASON	SimEvents (+Matlab)
ExtendSim	Micro Saint Sharp	Simio
FlexSim	Modelica	SimPy
GPSS	Netlogo	Simul8
HASH	Repast

There are some notable exceptions that see widespread use in manufacturing but are not included in this review, such as Arena and Plant Simulation. However, for none of these tools support for agent-based simulation was identified. Inversely, there are also some notable inclusions, that have fallen out of favor – such as GPSS and Micro Saint Sharp – or are generally known for simulation paradigms other than DES and ABS – such as Modelica. Nonetheless, these tools warranted a more thorough evaluation, as indications were found that they feature support for both DES and ABS in manufacturing applications.

5. Evaluation

The next step is to evaluate the list of selected tools shown in Table 1, and to classify these tools based on their evaluation.

5.1. Collect evaluation criteria

The selected tools are evaluated based on the evaluation criteria defined in Subsection 3.2. The tools were assessed using:

• Official tool website

• Official tool documentation

• Scientific papers discussing the tool

• A free/demo version if available

Using mostly official sources does have its limitations. It is fathomable that a tool offers undocumented functionality, although all of the selected tools were well-documented. It is also plausible that there are unofficial extensions for the tool which add additional functionality, this has been observed for some of the tools.

The results of the tool evaluation can be seen in Table 2. The same table with included sources can be found in the supplementary material.

Table 2. Evaluation of selected simulation tools.

	Discrete-event	Process-oriented mod.	Agent-based mod.	Message-based comm.	Other simulation capabilities	Model program-ming	Programming language	Graphical process mod.	State-charts	Flow-charts	Modularity	Hierarchy	Experiment manager	Optimization	Animation type	Integrated animation	Documen-tation	License
	1a	1b	2a	2b	3	4a	4b	5	6	7	8a	8b	9a	9b	10a	10b	11	12
Anylogic	✓	✓	✓	✓	SD	G	Java	✓	✓	✓	✓	✓	✓	✓	2D/3D	✓	✓	P
Netlogo	✘^†	✘	✓	✓	SD	S	Dialect of Logo	✘	✘	✘	✓	✘	✓	✘	2D/3D	✘	✓	OS (GPL)
Repast	✓	✘	✓	✘	SD	G	Java/Logo/Groovy	✘	✓	✓	✓	✘	✓	✘	2D/3D	✘	✓	OS (LGPL)
MASON	✓	✘	✓	✘	✘	G	Java	✘	✘	✘	✓	✘	✓	✘	2D/3D	✘	✓	OS (LGPL)
HASH	✘^†	✓	✓	✓	SD	G	Python/Javascript	✓	✘**	✘	✓	✓	✓	✓	2D/3D	✘	✓	OS (SSPL)
ExtendSim	✓	✓	✘^1	✓	CS/DR	S	ModL	✓	✘	✘	✓	✓	✓	✓	2D	✓	✓	P
FlexSim	✓	✓	✘^1,2	✓	✘	S	Flexscript	✓	✘	✓	✓	✓	✓	✓	3D	✓	✓	P
Simio	✓	✓	✘^1,2	✘	CS	✘	-	✓	✘	✓	✓	✓	✓	✓	2D/3D	✓	✓	P
Simul8	✓	✓	✘^1	✘	SD	S	Visual logic	✓	✘	✘	✓	✓	✓	✓	3D	✓	✓	P
Micro Saint	✓	✓	✘^1	✘	✘	G	C#	✓	✘	✘	✓	✓	✓	✓	2D/3D	✓	✓	P
SimEvents	✓	✓	✘^1	✓	DS	S	M-code	✓	✓	✓	✓	✓	✓	✓	2D/3D	✘	✓	P
SimPy	✓	✘*	✘	✘	✘	G	Python	✘*	✘	✘	✓	✓	✘	✘	2D*	✘*	✓	OS (MIT)
GPSS	✓	✓	✘	✘	✘	S	GPSS	✘*	✘	✘	✘	✘	✘	✘	✘	✘*	✓	OS/P
Modelica	✓	✘*	✘*	✘	DS	S	Modelica	✘*	✘	✘	✓	✓	✓	✓	2D/3D	✘	✓	OS (GPL)

Note: ^† = Fixed-increment time advancement (instead of next-event time advancement).

  * = Possible in some plugins or implementations of the tool (e.g. ManPy for SimPy)

  ** = To be added in a future release according to the product roadmap of HASH

  1 = No explicit agents, but components can have some level of intelligent decision making

  2 = Agents represent physical objects moving through the plant (e.g. humans and AGVs)

  CS = Continuous Simulation

  SD = System Dynamics

  DS = Dynamic Systems

  DR = Discrete Rate

  S = Scripting or modelling language

  G = General-purpose programming language

 OS = Open-source

  P = Proprietary

5.2. Classification and analysis

When looking at Table 2, the first point of interest is that Anylogic is the only tool that fulfils all the requirements needed for hybrid simulation of CPPSs that were described in Subsection 3.2.1. That does not mean the other evaluated tools are not capable of hybrid simulation at all. However, these tools do not meet the specific set of requirements to be effective for hybrid simulation of CPPSs with intelligent distributed production control, for which particular DES and ABS capabilities are required.

Although Anylogic comes out as the most promising tool in this evaluation, it will not be a suitable tool for every project, nor will it be a viable option for all users due to it being a commercial tool with a proprietary license. To give an overview of what the alternatives to Anylogic are, the tools are classified based on how they score on the hybrid simulation evaluation criteria (shown in Table A3). This resulted in the five classes shown in Table 3. Figure 3 shows the degree of support for DES and ABS for each of the classes of tools. The rest of this subsection describes which tools belong to these classes and what features the tools in each class generally have. This includes proposals on how tools in these classes can be utilized or extended for hybrid simulation of CPPSs even if they do not meet the specified requirements.

Figure 3. This graph shows the degree of support for discrete-event simulation (DES) and agent-based simulation (ABS) for each of the identified simulation tool classes in Table 3.

Table 3. Tool classes.

Hybrid simulation tools

Anylogic

ABS tools without process-oriented modelling (POM)

Netlogo

Repast

MASON

ABS tools with process-oriented modelling (POM)

HASH

DES tools with intelligent objects

ExtendSim

FlexSim

Simio

Simul8

Micro Saint Sharp

SimEvents

General-purpose simulation tools

SimPy

GPSS

Modelica

Table 3. Tool classes.

5.2.1. Hybrid simulation tools

The first class of simulation software consists of all tools which have the required features for hybrid simulation of CPPSs with intelligent distributed production control. Currently, the only tool in this class is Anylogic. Anylogic is a commercial simulation tool that combines three different simulation paradigms: DES, ABS, and system dynamics (SD), although this review only focuses on the former two. In Anylogic all model components are agents, which in turn can be built up using (sub)agents, providing a modular and hierarchical modelling architecture.

In Anylogic, modelling is primarily done graphically using a combination of statecharts, actioncharts, and/or preset library components. Besides graphical modelling, any part of the model can be customized and extended using Java code. Anylogic features both 2D and 3D animation, and animation is integrated into the graphical modelling interface in such a way that creating the model also builds a process flow animation.

In Anylogic the plant layer of a CPPS can be modelled using the process modelling library which features process-oriented modelling. The intelligent distributed production control layer can be modelled using statecharts, with message-based communication between the agents.

5.2.2. ABS tools without process-oriented modelling

One class of tools, among which are Netlogo, Repast Simphony, and MASON, are agent-based simulation tools. All of these tools have simulation with discrete-states, and with either next-event or fixed-increment time advancement.

However, these tools lack an intuitive method for modelling product flow. These tool also lack a library of building blocks such as servers and queues, which are generally used for modelling the behaviour of the plant layer of a production system. Any process-oriented modelling in these tools is only for modelling the internal behaviour of agents, and not for macroscopic system behaviour. These tools are aimed at simulating the emergent behaviour of interacting agents and are often used to simulate social and natural phenomena.

As seen in Table 2, this class of tools has some common characteristics. These tools generally feature 2D and/or 3D animation, but without any preset functionality for animating a production system. The agents in these systems are modelled through (a combination of) programming, flowcharts and/or statecharts. All of the reviewed tools are open-source and written in Java. However, these tools are not the only agent-based simulation tools; a comprehensive review of similar tools can be found in Abar et al. (2017).

As seen in Barbosa and Leitão (2011), ABS tools can be used for simulation of CPPSs. However, in the study the simulated agents are abstractions which represent a combination of both the physical and cyber parts of a system component. For example, a simulated product agent represents both the physical product and the virtual product agent. This approach only works under the assumption that the cyber layer has all information on the plant layer necessary for its decision making.

Another approach would be to model separate agents representing the physical components. However, this would need to be done without the intuitive, top-down approach of process-oriented modelling. In ABS models, it is unclear what the macroscopic system behaviour will be prior to simulation, as this macroscopic behaviour emerges from the behaviour of the agents.

5.2.3. ABS tools with process-oriented modelling

Another agent-based simulation tool is HASH, which is in a class of its own. HASH is a newcomer to the field of simulation tools, and it might be more aptly described as a simulation platform. The platform consists of a browser-based tool for developing and executing simulations, an agent-based simulation engine, a community for sharing models and model components, and a cloud computing constituent for running simulations.

The HASH simulation engine is similar to other ABS tools in the sense that it uses agents to simulate emergent behaviour. Like Netlogo, HASH features fixed-increment time advancement instead of next-event time advancement. HASH does feature a preset DES library, which allows for events to be triggered at specific time steps, but does not allow for the scheduling of events. Unlike other ABS tools, HASH features process-oriented modelling in its process modelling library, which even features a graphical interface for building these models. So although it is not a DES tool in the strict sense, it does include the features which make the DES paradigm attractive for modelling manufacturing systems. However, the preset building blocks of this library seem quite limited, and it does not seem flexible enough to handle complex CPPSs. For example, it is missing preset blocks for production steps such as batching, unbatching, transportation by conveyor, and more.

Another drawback of HASH is that it uses fixed-increment time advancement. The modeller is forced to sacrifice either accuracy or execution time depending on the chosen step size, making it less effective than a simulation tool with next-event time advancement.

5.2.4. DES Tools with intelligent objects

Another class of tools is that of discrete-event simulation tools. This class covers some of the most-used simulation tools in the manufacturing industry. The tools in this class are ExtendSim, FlexSim, Simio, Simul8, Micro Saint Sharp, and SimEvents. All tools in this class feature conventional discrete-event simulation with discrete-state, event-driven simulation, process-oriented modelling, and entity flow.

All of these tools make claims to feature agent-based simulation, but only FlexSim and Simio feature agents explicitly. However, these two tools consider agents as physical objects such as humans and AGVs moving through and interacting with a production facility. These type of agents are not useful for simulating the virtual decisional entities in the production control layer of a CPPS.

The reason that all of the tools in this class claim to be capable of ABS – even though some do not explicitly feature agents – is that they allow for objects in the system to have a level of intelligence. Examples of this are adding dynamic product routings to products and intelligent decision making to resources. When using these intelligent objects, the production control layer of the CPPS is not actually modelled, but an abstraction of its decision making is added to the physical plant components. This approach has its limitations, as decision making is generally local to the intelligent component, and often without communication with other production control components. For example, an agent-based production control layer cannot be modelled as intelligence can only be added to physical components; virtual decisional components without a physical counterpart cannot be modelled. Intelligence is added to components either visually (e.g. Process flow in FlexSim and Stateflow in SimEvents) or by programming (e.g. Visual Logic in Simul8 and ModL in ExtendSim). Of the tools in this class, only ExtendSim, FlexSim, and SimEvents feature message-based communication, which is required for modelling the cooperation between these components.

Finally, all of the six simulation tools can be extended with custom code. So if the above approach using intelligent objects is insufficient, then it is possible to model the plant layer in one of these tools, and then add the intelligent distributed production control layer through custom code. However, this approach can be complex and time-consuming, as everything must be programmed from scratch.

All of the tools in this class are (commercial) proprietary tools that are focused on use in industry. This requires these tools to be intuitive and easy to use. For this reason, all of the mentioned tools feature a graphical interface for modelling process flow and an extensive library of preset building blocks. All tools also feature 2D and/or 3D animation, and except for SimEvents, all tools have process flow animation integrated into the model-building process. As a final note, there are many other DES tools with similar features which did not meet the selection criteria of this review, such as Arena and Witness.

5.2.5. General-purpose simulation tools

The class of general-purpose simulation tool consists of SimPy, GPSS, and Modelica. These three tools do not have much in common, except that all three are very flexible and customizable. They miss the preset features required for hybrid simulation of CPPSs, but given enough effort, these features could be added due to the flexibility of these tools. All three tools are free and open-source, and could be attractive options for academic research for which a commercial tool is not always an option.

SimPy is a discrete-event simulation library based on Python. Being based on a general-purpose programming language allows it to be extremely flexible and allows it to be extended by other Python libraries. The downside is that SimPy does not provide many features out of the box for simulation of production systems. SimPy has a type of process-oriented modelling, but without flow of entities, and neither does it have preset building blocks, or a graphical modelling interface. There are however two extensions to SimPy which add these features, namely Casymda and ManPy (Dagkakis et al. 2013). The SimPy library could be extended to support agent-based simulation, but there is no built-in support. Finally, SimPy is missing other features important for simulation such as animation, or an experiment manager. To summarize, an open-source DES library such as SimPy is a good candidate for simulating CPPSs, but only if the user is willing to implement all the missing features. Although SimPy is the only such tool that was brought forward during the collection phase, there are many similar tools as seen in Dagkakis and Heavey (2016) and Lang et al. (2021), such as Salabim and JaamSim.

General Purpose Simulation System (GPSS) is a discrete-event simulation language and was the first general-purpose simulator to be utilized for manufacturing applications back in the 60s. Since its conception, it has seen many different versions, such as GPSS/H, GPSS World, aGPSS, JGPSS, and GPSS360, some of which are still used today. Of these three general-purpose tools, GPSS seems to be least suitable for hybrid simulation of CPPSs and most versions are outdated and no longer supported.

Modelica is a multi-domain modelling language in which both discrete and continuous behaviour can be described through sets of equations. Out of the box, Modelica supports neither process-oriented modelling, nor agent-based modelling. Instead, Modelica is intended for describing complex systems containing a combination of electrical, mechanical, hydraulic, thermal, etc. components. However, external Modelica libraries can be found for both DES (Sanz, Urquia, and Dormido 2008) and ABS (Sanz, Bergero, and Urquia 2018). Although both are developed by the same author, it is unclear if these libraries could be combined for hybrid simulation of CPPSs.

6. Case study

A case study is carried out in the most promising tool. The first goal of the case study is to show how a hybrid simulation tool can be used to predict the performance of a CPPS with intelligent distributed production control. The second goal is to assess how effective the tool is for this purpose. The third goal is to identify the impact of the evaluation criteria on the modelling and simulation process.

The case study which was carried out is inspired by the poultry fillet processing line example and corresponding agent-based system architecture described in Paape, van Eekelen, and Reniers (2021) and shown in Figure 4. To evaluate whether this is an effective case study, requires identification of how these systems are typically structured and which aspects are relevant for hybrid simulation of a CPPSs with intelligent distributed production control. When looking at the generic model in Figure 1 three aspects can be identified that must be included in the case study:

Figure 4. The poultry fillet processing line. It uses the architecture for meat processing systems with agent-based production control as proposed in Paape, van Eekelen, and Reniers (2021).

• A plant layer with flow of products.

• An intelligent distributed production control layer with agents and inter-agent communication.

• Interaction between the two layers, with the production control layer controlling the resources of the plant layer to execute the required production steps, and the resources giving feedback to the production control layer.

The chosen case study includes all three of these aspects. In the agent-based production control layer, the agents and the communication between them are shown, with product agents potentially communicating with all resource agents. In the plant layer, the resources are shown with the flow of products between them. The connections between the resources and their resource agents have been omitted from the figure for brevity. The results of this case study should translate well to other CPPS architectures with similar design patterns as discussed in Subsection 1.1.

6.1. Case study tool selection

The tool selected for this case study is Anylogic, as it is the only tool that satisfies all hybrid simulation criteria. As mentioned in Section 5, other tools can potentially be extended upon to make them suitable for hybrid simulation of CPPSs, but for this case study the one tool is chosen which has the required capabilities ‘out-of-the-box’.

6.2. Case study description

The purpose of the poultry fillet processing line is to fill trays with batches of fillets. These trays are filled to a target weight, and anything put in the tray above the target weight is essentially given away for free. This is known as the bin covering problem (Peeters et al. 2017). To reduce this ‘giveaway’, fillets can be trimmed down before they are batched. The trimmed off piece is then used for nuggets.

The poultry fillet processing line consists of seven resources: fillet source, weigher, diverter, batcher, trimmer, batch sink and nugget sink. The plant layer of this system is shown in the bottom half of Figure 4, and it operates as follows:

1. Fillets enter the filleting line at the fillet source.

2. The fillets are then weighed at the weigher.

3. Next, the fillets are diverted to either:

   1. A batcher, where the fillets are batched in trays.

   2. A trimmer, where the fillet is cut up into trimmed fillet and nugget.

• •The trimmed fillets are sent back to be weighed and are then batched. They cannot be trimmed twice.

• •The trimmed off pieces are used for nuggets.

Conventional poultry fillet processing lines are controlled by a centralized controller that calculates the optimal production strategy. However, the downsides of using a centralized controller is that the systems are slow to react to change, and have a single point of failure (Leitão 2009). When there is a disturbance or failure, the system will either operate with sub-optimal performance while the controller is recalculating the optimal production strategy, or worst-case, the entire system needs to shut down.

Instead of a centralized controller an agent-based production control layer is proposed. A simplified architecture of the agent-based production control layer is shown in the upper half of Figure 4. In this agent-based production control layer, each of the seven resources is represented by a resource agent (RA). These RAs create, and update the product agents so that they reflect the products that are processed in the system. A product agent (PA) tracks the properties of the product, the product history for traceability, and requests RAs to carry out the required operations in its production plan.

Finally, this system contains one production control agent (PCA), which supervises production by instructing the PAs and RAs. In more complex systems multiple PCAs could be present. In this case study the PAs request instructions from the PCA on if the product it represents should be trimmed or not. While the system is stable, the PCA provides instructions to the PAs in order to achieve optimal production. However, in case of disturbances or failure the PAs can make their own decisions, which improves the adaptability of the system. The objective of the case study is to predict the performance of the processing line with an agent-based production control layer.

6.3. Case study in anylogic

This is not the first case study for hybrid simulation of CPPSs using Anylogic. In respectively Khedri Liraviasl et al. (2015), Nagadi et al. (2018), Rolo et al. (2021), and de Paula Ferreira et al. (2022), hybrid simulation using Anylogic is applied in frameworks for reconfigurable manufacturing systems, for smart manufacturing systems, for digital twins, and for value stream mapping in Industry 4.0. In these studies, the focus of the case studies is to provide a proof-of-concept for the frameworks developed in the respective papers. In this paper, the focus of the case study is to show how a hybrid simulation tool can be used to predict the performance of a CPPS with intelligent distributed production control, to analyze how effective Anylogic is as a tool for this goal, and to assess the importance of the selected evaluation criteria for modelling and simulation of CPPSs. The Anylogic model of the poultry fillet processing line with agent-based production control is shown in Figure 5.

Figure 5. The model of the poultry fillet processing line with agent-based production control in anylogic, built using custom model components.

6.3.1. Resources and resource agents

To show how the plant and cyber layers interact, a more detailed explanation of the Batcher Resource and Batcher Resource Agent models is given. The models for these two components are shown in Figure 6. The Batcher Resource is modelled using the Anylogic process modelling library; fillets enter the Batcher Resource at (i), and trays with batches of fillet exit at (vi). The Batcher RA is modelled using a statechart. The Batcher RA is responsible for controlling the Batcher Resource, and for updating the Fillet and Batch Product Agents to reflect the current state of the products. In between the two models, the interactions between the components is shown. Not depicted in the figure is the communication between the Batcher RA and the various PAs.

Figure 6. The models of the batcher resource and batcher resource agent, and the interaction between the two. Some modelling details have been omitted for brevity.

6.3.2. Product agent and production control agent

The models and interactions of the Fillet Product Agent and the Production Control Agent are shown in Figure 7. The model of the Fillet Product Agent contains the production plan, the measured weight of the product, and the product history. The production plan is represented by the statechart; the states describe the next operation which needs to be carried out, which is communicated to the RA processing the product. The Fillet Product Agent receives a message from the RA when the operation is completed, after which the Fillet Product Agent advances to next step of the processing plan. The product history contains snapshots of the product properties before and after each operation.

Figure 7. The models of the fillet product agent and production control agent, and the interaction between the two. Some modelling details have been omitted for brevity.

After the fillet has been weighed, the Fillet Product Agent requests instructions from the PCA. The PCA then determines if the fillet should be trimmed before being batched or not. The PCA is responsible for this decision because it has more information available on the state of the system, leading to more optimal system behaviour. However, as noted before, it is possible that the PCA has to deal with a disturbance or a failure. This can render the PCA (temporarily) unavailable while it is recalculating the production plan, or recovering from the failure. To improve adaptability of the system, the Fillet Product Agent makes its own decision if instructions are not received in time, using local information.

6.4. Case study results

The case study was executed successfully. During the case study, no inconsistencies with the tool evaluation shown in Table 2 were found. In this subsection, the experiences of the authors with modelling and simulating using Anylogic are described. The first segment describes how a hybrid simulation tool can be used to predict the performance of a CPPS with intelligent distributed production control. The last two segments reflect back on the evaluation criteria for hybrid simulation and software selection and how they affect the modelling and simulation process in Anylogic.

6.4.1. Using hybrid simulation for performance prediction

Judging from the case study a hybrid simulation tool such as Anylogic is effective in predicting the performance of a CPPS with intelligent distributed production control.

The model of the processing line with agent-based production control was simulated to obtain predictions on operational performance, adaptability and traceability. The model was first used to predict the performance of the system while stable, which is the same as for a system with a centralized controller, as the PCA runs the same production control algorithm.

Next, the adaptability of the system to disturbances and failure was analyzed. The adaptability of the system can be quantified by comparing the performance of the system under disturbances, to the performance of the system while stable. A comparison of the average giveaway with various target batch weights is shown in Figure 8. The system can be regarded as more ‘adaptable’ if the difference in average giveaway between the stable and disturbed system is relatively small. The result shows that the level of adaptability greatly depends on the batch target weight. This is because the PCA can make decisions with the global state of the system in mind, while the decision-making of a PA is more localised. However, one of the main advantages is that the model can be used to optimize the adaptability of the design by improving the decision-making of PAs.

Figure 8. The adaptability of the system to disturbances is quantified by comparing the performance of the system while stable, to the performance of the system under disturbances. A comparison of the average giveaway for various batch weights is shown.

Finally, the system was tested with regards to traceability; it is important that the production process of every product can be tracked, even after cutting-up and/or batching of products. This a vital aspect in the poultry processing industry, e.g. to identify which products can have cross contamination. It was verified that every product can be traced back to its origins and that the system was working as intended. A reconstruction of the processing of a fillet is shown in Figure 9, it is made using the logging data in the product history of the Fillet PA. This shows that all the processing steps that a fillet undergoes can be traced back.

Figure 9. A reconstruction of the processing of a fillet, made using the logging data in the product history of the fillet PA.

6.4.2. Reflecting on hybrid simulation criteria

The case study shows that hybrid discrete-event and agent-based simulation software is effective for modelling and simulating CPPSs. The combination of process-oriented and agent-based modelling allows a modeller to combine a top-down with a bottom-up modelling approach. Reflections on the individual hybrid simulation criteria are:

(1a) Discrete-event: Anylogic uses discrete-state simulation with next-event time progressions. Anylogic also allows for continuous-time simulation, but only when using the system dynamics library. It is difficult to judge what effect this evaluation criterion had on the case study. However, as shown in Buss and Al Rowaei (2010), next-event time advancement has significant advantages over fixed-increment time advancement; it is more accurate, and simulation takes less time to execute.

(1b) Process-oriented modelling: when looking at the Anylogic model in Figure 5, the intended product flow as shown in Figure 5 can clearly be seen. Without process-oriented modelling, it becomes difficult to model the production steps that a product undergoes. For example, it is difficult to visualise what the model of a batcher would or should look like without process-oriented modelling, and there would likely be no good way to verify that it is modelled correctly without executing the model. This deficiency might be acceptable for academic research, but it likely is not enough if acceptance by industry is a must. In Anylogic the plant layer is modelled (graphically) using the Process Modelling library, which provides a large collection of preset building blocks such as queues and servers to model the plant layer of a CPPS.

(2a) Agent-based modelling: in Anylogic all model components are agents. These agents can represent both the physical plant components of a CPPS such as products and resources, as well as the agents in the production control layer of a CPPS. Consequently, every model component can have its own decision-making. The behaviour of these agents is defined using a combination of programming, statecharts, actioncharts, and the Process Modelling Library. In a simulation tool without agent-based modelling, modelling the decision-making in the intelligent distributed production control layer would have been difficult. It might even be infeasible for more complex systems.

(2b) Message-based communication: in Anylogic, messages can be sent using the ‘send’ function. This can be used to model the communication between the agents, and the interface between the resources and agents. The biggest difficulty in this case study was validating if communication by the agents was modelled correctly. One feature that Anylogic lacks in this regard is creating sequence diagrams of the communication between the model components. For example, the sequence diagram in Figure 9 had to be made manually.

6.4.3. Reflecting on software selection criteria

Anylogic scores well on the evaluation criteria for the simulation software selection process, as shown in Table 2. The next segment reflects on how these evaluation criteria affect the modelling and simulation of CPPSs.

(3) Other simulation capabilities: Anylogic features simulation of system dynamics, but this aspect of Anylogic was not utilized in the case study.

(4a) Model programming: the complex behaviour of a CPPS requires the flexibility that model programming offers. Without model programming, modelling is limited to the library of building blocks that came with the simulation software. The fillet processing line of the case study could not have been modelled without model programming; the preset building blocks only describe the flow of products, but not how the fillets are altered, or the decision-making in the system. In Anylogic, model programming can be done in two ways. The first is that many of the graphical building blocks, allow for ‘actions’, which are snippets of code that execute under certain conditions (e.g. when a product enters a queue). The second is that in Anylogic, any model object can be opened with a Java editor, in which the object can be customized.

(4b) Programming language: a simulation tool with model programming can use either a general-purpose programming language, or a custom built scripting or modelling language. Both have their advantages: a general-purpose programming language is more flexible, and its use is not limited to the simulation tool. A scripting or modelling language is generally more limited, but has a simple (and often language-based) syntax, which is easier to use for non-programmers. Anylogic uses Java, a general-purpose programming language.

(5) Graphical process flow modelling: process-oriented modelling is most effective combined with graphical modelling. Although model programming offers more flexibility, graphical modelling is generally a more intuitive way of modelling. This is essential because domain experts with expertise on the functioning of a production system, are not always proficient programmers.

(6 & 7) Statecharts & flowcharts: statecharts and flowcharts are the agent-based modelling counterpart of graphical process flow modelling. They can be used to model the behaviour of agents (but also the behaviour of physical resources). Without statecharts or flowcharts, agent-based modelling relies solely on model programming, which significantly raises the difficulty level of model development. Anylogic utilizes statecharts and actioncharts (a type of flowcharts) to model the behaviour of the agents.

(8a & b) Modularity & hierarchy: modular and hierarchical modelling is essential for model reusability. Anylogic models have high reusability as the tool allows for modular modelling through custom ‘agent types’. These custom agent types can have a hierarchical decomposition, meaning that these agents can be built up using other agents. These custom ‘agent types’ can be used for the agents of the production control layer, but also for user-defined resources and products which can be used in combination with the Process Modelling Library. For the latter, a group of connected building blocks can be converted to a user-defined subcomponent with the click of a button, which can be very useful for creating a library of modular resource components. This was done for the Batcher Resource model in Figure 6. Anylogic also supports class inheritance, which means that it is possible to model base agent types, in which common behaviour is defined for all agents which inherit this base agent type. For example, a base resource agent type can be created, and the specific resource agents inherit the common behaviour of this base resource agent.

(9a & b) Experiment manager & optimization: Anylogic features an experiment manager with many experiment types, among which: parameter variation, optimization, run comparison, Monte Carlo simulation, sensitivity analysis, calibration, and reinforcement learning. The experiments can automatically be generated (including a GUI), are fully customizable, and can be reproduced. In this case study the parameter variation experiment was utilized to compare the performance of the system while stable to its performance under disturbances.

(10a & b) Animation and integrated process flow animation: animation is an important feature validation of the created model(s). In Anylogic animation is well integrated into the tool. For example, building a model with the Process Modelling Library automatically creates a simple process flow visualisation which helps in validating the model. An example of this is shown for the Batcher in Figure 10, in which the integrated visualisation shows how many products have entered/exited/are currently being processed at each production step of the Batcher. Anylogic also allows every object to be clicked during simulation for further inspection, and allows parameters and variables to be changed during simulation. More advanced 2D and 3D animation options are also well supported, but these were not used in the case study.

Figure 10. The integrated animation shows how many products have entered, exited, or are currently being processed by a model component.

(11) Documentation: extensive documentation is vital for a tool to obtain widespread use, because the learning curve of a simulation tool can be steep. The learning curve for Anylogic depends on how accustomed the user is with simulation tools in general, and with Java. Fortunately, Anylogic has extensive documentation, tutorials and other learning resources. For assistance with using Anylogic, there are professional support and communities on Stack Overflow and LinkedIn.

(12) License: Anylogic uses a proprietary license. Proprietary simulation tools are generally better supported and are easier to use. However, open-source simulation tools could be a cheaper (and often more flexible) alternative.

7. Concluding remarks

A review was carried out for hybrid discrete-event simulation (DES) and agent-based simulation (ABS) software for CPPSs with intelligent distributed production control. To the knowledge of the authors, this is the only such review. The review followed these structured steps: (1) identification of software requirements, (2) collection and selection of relevant simulation tools, (3) evaluating and classifying the tools, and (4) a case study on the most promising simulation tool.

In this review, a simulation tool is regarded as an effective hybrid DES+ABS simulation tool if it has discrete-state event-driven simulation with process-oriented and agent-based modelling, and message-based communication. Only one tool – Anylogic — was identified which satisfies all of these criteria. Other classes of simulation tools that were identified are “ABS with process-oriented modelling “, “ABS without process-oriented modelling “, ‘DES tools with intelligent objects’, and ‘general-purpose simulation tools’.

A case study was carried out in which Anylogic was used to analyze the operational performance, adaptability, and traceability in a meat processing system with agent-based production control. This case study confirmed that a hybrid DES+ABS simulation tool such as Anylogic is effective for making predictions on how a CPPS with intelligent distributed production control will perform. Besides the aforementioned modelling and simulation capabilities, some of the most important features of such a tool are: the capability for extending the models through model programming using a scripting language or a general-purpose programming language, the option to create the models graphically and to animate them for validation, and the possibility for modular and hierarchical modelling so that model components can be reused.

7.1. Outlook

At present, intelligent distributed production control paradigms have not yet seen widespread use in industry. For industry to adopt these techniques requires assurances that they are worth the initial investment cost. Simulation can be used to quantify the advantages these paradigms have over conventional approaches in, for example, operational performance, adaptability, and traceability. A hybrid DES+ABS simulation tool is effective for this purpose, as demonstrated not only in this paper, but also in Khedri Liraviasl et al. (2015), Nagadi et al. (2018), Rolo et al. (2021), and de Paula Ferreira et al. (2022).

Regrettably, no tools besides Anylogic were identified supporting hybrid DES+ABS simulation. Although it is not the only simulation tool that can be used to model and simulate CPPSs, it is the only one encountered that fully utilizes the advantages of discrete-event and agent-based simulation. This is especially problematic for the scientific community, as no free and open-source alternatives are capable of hybrid DES+ABS simulation ‘out-of-the-box’. For each class of tools, potential solutions were identified to make hybrid simulation of CPPSs feasible. However, the downside of such a bespoke solution is that it requires extra time and effort to develop.

Disclosure statement

No potential conflict of interest was reported by the author(s).

Supplementary material

Supplemental data for this article can be accessed online at https://doi.org/10.1080/0951192X.2023.2228270.

Appendix A

Table A1. Hyperlinks to all simulation software tools mentioned in this paper. The tools depicted in bold were evaluated in this review.

Anylogic	https://www.anylogic.com/
Arena	https://www.arenasimulation.com/
Automod	https://www.appliedmaterials.com/automation-software/automod
Casymda	https://github.com/fladdimir/casymda
Enterprise Dynamics	https://www.incontrolsim.com/software/enterprise-dynamics
ExtendSim	https://extendsim.com
FlexSim	https://www.flexsim.com
GPSS	http://www.minutemansoftware.com/features.htm
HASH	https://hash.ai/
JaamSim	https://jaamsim.com/
ManPy	https://www.manpy-simulation.org/
MASON	https://cs.gmu.edu/~eclab/projects/mason/
Matlab (& SimEvents)	https://nl.mathworks.com/products/simevents.html
Micro Saint Sharp	http://www.microsaintsharp.com/
Modelica	https://modelica.org/index.html
Netlogo	https://ccl.northwestern.edu/netlogo/
Plant Simulation	https://www.plm.automation.siemens.com/global/en/products/manufacturing-planning/plant-simulation-throughput-optimization.html
Repast	https://repast.github.io/
Salabim	https://www.salabim.org/
Simio	https://www.simio.com
SimPy	https://simpy.readthedocs.io/en/latest/
Simul8	https://www.simul8.com/
Witness	https://www.lanner.com/en-us/technology/witness-simulation-software.html

Table A2. The evaluation criteria used in this paper, and how they correlate to evaluation criteria mentioned in literature.

	Evaluation	Correlate to
	criteria	Ruiz et al. (2014)	Fumagalli et al. (2019)	Cafasso et al. (2020)
1a, 1b	Discrete-event & process-oriented modelling	Modeling world	Simulation type, Hybrid Modelling
2a, 2b	Agent-based modelling & message-based communication	Modeling world	Simulation type, Hybrid Modelling
3	Other simulation capabilities	Modeling world	Simulation type, Hybrid Modelling
4a, 4b	Model programming & programming language	Programming of simulation, Syntaxis	Code Manipulation	Coding, Supported languages,
5, 6, 7	Graphical modelling, Statecharts, Flowcharts	Constructing of graphic model		Graphical model construction
8a, 8b	Modularity & hierarchy)	Customized objects build by user	Hierarchical Model, User-defined Functions, Modularity, Union of Different Models, Model Reusability	Incorporate-merge models
9a, 9b	Experiment manager & optimization	Scenario manager, execution manager, optimization	Re-Starting, Automatic Multi-Run
10a, 10b	Animation (2D/3D) & integrated process flow animation	Animation type, Dimension (2D/3D), Predefined graphics		3D objects, 3D animation
11	Documentation		Documentation, tutorial	Manual, Tutorial
12	License			Costs, Online support, Specialized training, Vendor

Table A3. The evaluated tools are classified based on the DES and ABS evaluation criteria.

	Discrete-event	Process-oriented modelling	Agent-based modelling	Message-based communication
	1a	1b	2a	2b
HYBRID SIMULATION TOOLS	✓	✓	✓	✓
Anylogic	✓	✓	✓	✓
ABS WITHOUT PROCESS-ORIENTED MOD.	–	✘	✓	–
Netlogo	✘^†	✘	✓	✓
Repast	✓	✘	✓	✘
MASON	✓	✘	✓	✘
ABS WITH PROCESS-ORIENTED MOD.	✘	✓	✓	✓
HASH	✘^†	✓	✓	✓
DES TOOLS WITH INTELLIGENT OBJECTS	✓	✓	✘^1	–
ExtendSim	✓	✓	✘^1	✓
FlexSim	✓	✓	✘^1,2	✓
Simio	✓	✓	✘^1,2	✘
Simul8	✓	✓	✘^1	✘
Micro Saint Sharp	✓	✓	✘^1	✘
SimEvents	✓	✓	✘^1	✓
GENERAL PURPOSE SIMULATION TOOLS	✓	–	✘	✘
SimPy	✓	✘*	✘	✘
GPSS	✓	✓	✘	✘
Modelica	✓	✘*	✘*	✘

Note: ^† = Fixed-increment time advancement (instead of next-event time advancement).

* = Possible in some plugins or implementations of the tool (e.g. ManPy for SimPy).

1 = No agent-based modelling, but components can have some level of intelligent decision making.

2 = Agents can only represent physical objects moving through the plant (e.g. humans and AGVs).