Discrete Event System Specification Models Research Articles

Enriching UML Statecharts through a Metamodel: A Model Driven Approach for the Graphical Definition of DEVS Atomic Models

The Discrete Event System Specification (DEVS) formalism provides a set of mathematical elements for modeling time-varying systems. However, when DEVS models are implemented in an executable representation (i.e., using a general-purpose programming language), some deviation from the formalism is unavoidable. One way to bridge the gap between modeling and simulation theory and practice is to define new artifacts that support both views during the specification. When the specification is supported with a graphical representation, the formalization task is less complex and can be performed by non-expert modelers. For DEVS atomic models, most common graphical representation is through UML statecharts. In this paper, we present a theoretical and practical metamodel for the definition of atomic models structured following the Classic DEVS with Ports formalization. Such a metamodel is the core of a model-driven approach used to develop a modeling software tool that employs enriched UML statecharts for the graphical representation of the DEVS behavior. In here, the traditional UML statechart representation is enriched with a set of new components with the aim to provide a broad definition of DEVS atomic models. The final software tool is deployed as a plugin for Eclipse Platform.

An Environment for Developing Simulatable AADL-DEVS Models

Reducing complexity in system architecture and design specifications, and more specifically from the software aspect, is essential. The architecture specifications focus on what the requirements and static aspects of systems are. The design specifications define dynamic aspects of computational components that sense and react to external stimuli. As the architecture and design specifications serve complementary roles in developing systems, the use of Architecture Analysis & Design Language (AADL) and Discrete Event System Specification (DEVS) is proposed for developing, in a step-wise fashion, combined architecture and design models. The proposed AADL-DEVS framework is grounded in the foundational modularity and hierarchy principles common to the AADL and DEVS modeling approaches. A realization of this framework capable of transforming and simulating the AADL-DEVS specifications is developed using the Open Source AADL Tool Environment (OSATE) and DEVS-Suite simulator. The scope of this paper is on the computational aspect of systems. The proposed AADL-DEVS framework is demonstrated using a model for the software part of an infant incubator, a time-sensitive and safety–critical system.

XDEVS: A hybrid system modeling framework

When Discrete Event System Specification (DEVS) is used as a modeling tool, there is a semantic gap between a DEVS model and the mathematical representation, which may result in understanding difficulties. To provide a more intuitive form of modeling, XDEVS expands the concept of states in DEVS. The continuous state is introduced in XDEVS, which enhances the ability to model hybrid systems. Based on the DEVS simulation framework, a simulation engine is developed to drive the XDEVS model safely and efficiently and avoid the wrong location of state events during the simulation of the continuous model. A hybrid model is constructed and simulated using XDEVS. A comparison between the XDEVS model and models described by DEV&DESS and GDEVS shows that XDEVS can clearly express the structure of the model and reduce the burden on modelers.

DEVS and MBSE: A review

We review Discrete-Event system Specification (DEVS) in the context of Model-based Systems Engineering (MBSE) and discuss an application of DEVS methodology to MBSE. We outline support for an envisioned MBSE development cycle of DEVS top-to-bottom MBSE capability and offer an example of mapping UML activity diagrams into executable activity-based DEVS models. We close with conclusions and future research directions.

Modeling and Simulation of Abnormal Behavior Detection Through History Trajectory Monitoring in Wireless Sensor Networks

Data security is becoming increasingly important with the growing popularity of smart management systems combining wireless sensor networks (WSNs) and intelligent systems in industrial, agricultural, and construction fields. Traditional security methods for WSN have focused on data integrity and the identification of outliers in sensor data and are therefore vulnerable to attacks such as false positive attacks (FPAs) and false negative attack (FNAs) using massively compromised nodes. these attacks significantly compromise the sensor nodes because the correlation between node verification behaviors is not considered in the communication process until the intercepted sensor data are used as input into the system. This study introduces an FPA and FNA detection method using a spatiotemporal historical data-based knowledge base. The main contribution of the present study is the recognition of abnormal correlations using behavior monitoring through the discrete event system specification model. By recognizing abnormal correlations, the proposed method prevents the inflow of false data generated as a result of widespread damage. Furthermore, a new strategy is proposed to maximize the lifetime of the network by blocking any compromised nodes. The proposed spatiotemporal data-based detection approach is applicable to a wide variety of fields owing to its use of a shared security model. The proposed method was shown to reduce the energy consumption by 46.737% and 41.927% in comparison to statistical en-route filtering and cluster-based false-data filtering, respectively.

Metamodel-based formalization of DEVS atomic models

The Discrete-Event System Specification (DEVS) formalism is a modeling formalism based on systems theory that provides a general methodology for hierarchical construction of reusable models in a modular way. When concrete DEVS models are developed using programming languages, it is difficult to ensure they conform to their formal model. Hence, building an implementation of formal models in a way that ensures DEVS formalism correctness is not easy. In this paper, we improve the interplay of abstraction (i.e., formal specification) and concreteness (i.e., programming code implementation) in advancing the theory and practice of DEVS using a specific-designed metamodel. The main contribution is a novel conceptualization of classic DEVS with ports founded on existing approaches but that also includes new improved elements related to the definition of atomic models. That is, our metamodel includes all the concepts and relationships needed to define the formal specification of DEVS atomic models. This allows us to define instances of our conceptualization that comply with the DEVS formal specification. To instantiate our metamodel, we propose a computer-aided environment that has been developed using the Eclipse Modeling Project. As an example, we show how our metamodel can be used to define the classic “switch” model. As a conclusion, we discuss how the final metamodel can be used to support interoperability with DEVS simulation tools.

Hierarchical Activity-Based Models for Control Flows in Parallel Discrete Event System Specification Simulation Models

Behavior modeling grounded in the Discrete-Event System Specification (DEVS) and Unified Modeling Language (UML) activity specifications is crucial for simulating dynamical systems. The Model-Driven Architecture (MDA) design approach provides flexible yet rigorous layered metamodels for the UML activity diagrams. Our approach for behavior modeling is focused on the action and control concepts in the UML activity metamodels and realizing them as artifacts according to the DEVS formalism. The syntax and semantics for the artifacts conform to the parallel DEVS model specification and execution protocol. We use the system-theoretic state, component, and hierarchy concepts as the foundation for formulating the DEVS Activity models and supported with a prototype graphical tool developed in Sirius. This research also proposes the Parallel DEVS as a formal approach for examining the semantics of the UML Activities. We develop, simulate, and analyze a set of prototypical multi-processor architecture systems demonstrating different synchronization and selection schemes using the DEVS-Suite and MS4 Me simulators.

Layered discrete event system specification for a ship production scheduling model

Shipbuilding is a representative engineering-to-order (ETO) industry that commences product design and manufacturing only after contract signing. It is difficult to accurately predict production schedule at the contract stage, and is this is extremely important because the design tends to be unique and the delivery date should be included in the contract given the paucity of information of the product. Although the intermediate products exhibit high similarity, design modification typically occurs even after the production has begun, and this increases the difficulty of accurate planning. Additionally, the production process incorporates labor-intensive assemblies and joining, and it inherently involves the uncertainties in process time and procedures. Thus, shipbuilding companies attempt to manage production plans via dividing them into hierarchical structures and tend to rely on empirical knowledge and data from production history. Recently, discrete event simulation (DES) is actively searched for the shipyard schedule management, which is successfully applied to mass production industries. However, it is not widely applied due to the inherent characteristics of shipbuilding industry. In order to solve the problem, we propose a layered discrete event system specification modeling method for a ship production scheduling system that provides a layer concept for mixed level of information. The aim involves integrating all production information. Each layer exhibits a level of usable information details. Furthermore, it is designed to facilitate cross-linked information between different layers. Thus, we define a mathematical formalism as an extended form of discrete event system specification and apply it to a production schedule model. The model is simpler and easier to implement because it reflects characteristics of shipbuilding production.

Machine learning-based discrete event dynamic surrogate model of communication systems for simulating the command, control, and communication system of systems

Command and control (C2) and communication are at the heart of successful military operations in network-centric warfare. Interoperable simulation of a C2 system model and a communication (C) system model may be employed to interactively analyze their detailed behaviors. However, such simulation would be inefficient in simulation time for analysis of combat effectiveness of the C2 model against possible input combinations while considering the communication effect in combat operations. This study proposes a discrete event dynamic surrogate model (DEDSM) for the C model, which would be integrated with the C2 model and simulated. The proposed integrated simulation reduces execution time markedly in analysis of combat effectiveness without sacrificing the accuracy reflecting the communication effect. We hypothesize the DEDSM as a probabilistic priority queuing model whose semantics is expressed in a discrete event systems specification model with some characteristic functions unknown. The unknown functions are identified by machine learning with a data set generated by interoperable simulation of the C2 and C models. The case study with the command, control, and communication system of systems first validates the proposed approach through an equivalence test between the interoperable simulation and the proposed one. It then compares the simulation execution times and the number of events exchanged between the two simulations.

Discrete Event System Specification-based framework for modeling and simulation of propagation phenomena in social networks: application to the information spreading in a multi-layer social network

The diffusion of information is defined as the communication process by which an idea or information spreads within a social system and impacts the behavior of social actors (individuals). The social interaction plays an important role in studying the propagation of information and how it influences people. When an informational event occurs, it can either die out quickly or have significant impact on a population. The interactions could be supported by physical proximity contact, remote collaboration, any type of social meetings, and some forms of verbal or written communication, depending on the situations. Institutions and firms search to understand and predict the impact of information propagation on individuals. Agent-based modeling is a powerful approach for studying such a collective process. However, existing models oversimplify the cultural attributes, the different types of links, and information content, despite the evidence of their central role in the diffusion process.In this context, great benefits could be derived from the exploitation of an individual’s personality and cultural values in the diffusion models. In this paper, we describe a new architecture for an agent-based model using the DEVS (Discrete Event System Specification) framework and show how this architecture is flexible and can support the simulation of the dissemination process. In more detail, we define a set of models of individuals characterized by a set of state variables to represent the behavior of an individual and the individual’s network within a multi-layer social network. Then, we start by introducing the platform architecture, specifically designed to simulate message propagation in a multi-layer network. Finally, a military scenario of message diffusion during a stabilization phase is used to test our DEVS models on the platform and the relevancy of the simulation results.

A multi-target compiler for CML-DEVS

Discrete Event System Specification (DEVS) is a modular and hierarchical formalism for system modeling and simulation. DEVS models can be mathematically described; simulation is performed by tools called concrete simulators. Concerning atomic DEVS models, each concrete simulator has its own input language which is, essentially, a general-purpose programming language (such as Java or C++). Hence, once engineers have written the mathematical model, they need to manually translate it into the input language of the concrete simulator of their choice. In this paper we present a multi-target compiler for atomic DEVS models written in CML-DEVS, a mathematics-based DEVS modeling language. This multi-target compiler is able to compile a CML-DEVS model to the input languages of the PowerDEVS and DEVS-Suite concrete simulators. In this way, the CML-DEVS compiler frees engineers from the manual translation of their mathematical models. In fact, the same mathematical model can be simulated on both simulators by simply recompiling the model. The CML-DEVS multi-target compiler can be easily extended to produce code for other concrete simulators.

Increasing the performance of a Discrete Event System Specification simulator by means of computational resource usage “activity” models

Domain-specific simulators often have an edge on general-purpose simulators in terms of performance. Their intricate knowledge of the domain allows them to aggressively optimize and take shortcuts. In contrast, simulators for more general formalisms, such as Discrete Event System Specification (DEVS), need to support a wider set of models. Their inability to use domain information prevents DEVS simulators from achieving as high performance as their domain-specific variants. To solve this problem, we introduce a way to enhance the simulation performance of DEVS models through the use of computational resource usage models, often termed “activity” models. These models augment general-purpose DEVS models with domain-specific information, which can be used by the simulator. We apply this information in the context of data structure optimization, load balancing, and model allocation. Activity-awareness is a non-invasive extension to the DEVS formalism, meaning that activity-augmented models remain perfectly valid for use in activity-unaware simulators. Similarly, models without activity can still be simulated by an activity-aware simulator. Our approach is validated by making PythonPDEVS, a Parallel DEVS simulator, activity-aware and evaluating the performance impact on a set of benchmark models.

Using the Parallel DEVS Protocol for General Robust Simulation with Near Optimal Performance

The Discrete Event Systems Specification (DEVS) formalism has been widely disseminated in this magazine and elsewhere for its applicability to computational science and engineering. While research in parallel and distributed simulation has been active in the past several decades, the utility of many techniques for high-performance DEVS simulation has been limited. Recent research has shown that that a reconstruction of Amdahl's and Gustafson's laws for parallelizing sequential code can afford a better understanding of the underlying principles and their application to simulation of DEVS models. In this article, the author shows, in comparison to the ideal case, that a relatively simple protocol based on the DEVS abstract simulator is both generally applicable and able to achieve significant speedup in parallel distributed simulation.

System entity structure extension to integrate abstraction hierarchies and time granularity into DEVS modeling and simulation

The modeling and simulation (M&S) of complex systems often requires models described at different levels of detail characterized by differences in abstraction hierarchies and/or time granularity. The discrete-event system specification (DEVS) is a framework based on mathematical systems theory that offers a computational basis for application of M&S to systems engineering and that has become widely adopted for its support of discrete-event, continuous, and hybrid applications. A fundamental representation of DEVS hierarchical modular model structures is the system entity structure (SES), which represents a design space via the elements of a system and their relationships in a hierarchical and axiomatic manner. As has been described in a number of publications, the SES supports development, pruning, and generation of DEVS simulation models. The goal of this paper is to propose an extension of SES in order to integrate both the concepts of abstraction hierarchies and time granularity into DEVS. This paper explains in detail: (i) the concepts of abstraction hierarchies and time granularity; (ii) the extension of SES in order to take into account these concepts; (iii) DEVS M&S of complex systems according to different levels of detail (abstraction hierarchies and time granularity); (iv) the use of a Python DEVS simulator (DEVSimPy) to implement the management of abstraction hierarchies and time granularity. A real case study is given to illustrate the proposed approach, and follow-on research needed to implement the concepts is discussed.

Enhancing the reusability and interoperability of artificial neural networks with DEVS modeling and simulation

Artificial neural networks (ANNs), a branch of artificial intelligence, has become a very interesting domain since the eighties when back-propagation (BP) learning algorithm for multilayer feed-forward architecture was introduced to solve nonlinear problems. It is used extensively to solve complex nonalgorithmic problems such as prediction, pattern recognition and clustering. However, in the context of a holistic study, there may be a need to integrate ANN with other models developed in various paradigms to solve a problem. In this paper, we suggest discrete event system specification (DEVS) be used as a model of computation (MoC) to make ANN models interoperable with other models (since all discrete event models can be expressed in DEVS, and continuous models can be approximated by DEVS). By combining ANN and DEVS, we can model the complex configuration of ANNs and express its internal workings. Therefore, we are extending the DEVS-based ANN proposed by Toma et al. [A new DEVS-based generic artficial neural network modeling approach, The 23rd European Modeling and Simulation Symp. (Simulation in Industry), Rome, Italy, 2011] for comparing multiple configuration parameters and learning algorithms and also to do prediction. The DEVS models are described using the high level language for system specification (HiLLS), [Maïga et al., A new approach to modeling dynamic structure systems, The 29th European Modeling and Simulation Symp. (Simulation in Industry), Leicester, United Kingdom, 2015] a graphical modeling language for clarity. The developed platform is a tool to transform ANN models into DEVS computational models, making them more reusable and more interoperable in the context of larger multi-perspective modeling and simulation (MAS).

Efficient Flattening Algorithm for Hierarchical and Dynamic Structure Discrete Event Models

Discrete event models are widely used to replicate, analyze, and understand complex systems. DEVS (Discrete Event System Specification) formalism enables hierarchical modeling, so it provides an efficiency in the model development of complex models. However, the hierarchical modeling incurs prolonged simulation executions due to indirect event exchanges through the model hierarchy. Although direct event paths are applied to mitigate this overhead, the situation becomes even worse when a model changes its structures during simulation execution, called a dynamic structure model. This article suggests Coupling Relation Graph (CRG) and Strongly Coupled Component (SCC) concepts to improve hierarchical and dynamic structure DEVS simulation execution. CRG is a directed graph representing DEVS model structure, and SCC is a group of connected components in a CRG. Using CRG and SCC, this article presents (1) how to develop CRG from a DEVS model and (2) how to construct and update direct event paths with respect to dynamic structural changes. In particular, compared to the previous works, the proposed method focuses on the reduction of the updating costs for the direct event paths. Through theoretical and empirical analyses, this article shows that the proposed method significantly reduces the simulation execution time, especially when a simulation model contains lots of components and changes its model structures frequently. We expect that the proposed method would support the faster simulation executions of complex hierarchical and dynamic structure models.

Construction of Concurrent Programs Based on a Modeling and Simulation Formalism

This paper proposes a framework for developing a concurrent program using the discrete event system specification (DEVS) formalism. Within the proposed framework, a concurrent program is modeled by the DEVS formalism, and the modeling result is validated through simulation in a DEVS abstract simulator environment, called DEVSim++. Then, the validated modeling results are translated to multi-threaded program codes written in a conventional programming language. For that, each DEVS model which specifies behavior of a component is converted to a single thread, called an atomic thread, and every connection information between the components are clustered together and converted to a data structure, called a port mapping table. This paper also proposes an efficient solution which combines several atomic threads into a new thread, called a combined thread.

Action-level real-time DEVS modeling and simulation

For some classes of systems, it is advantageous to develop real-time models instead of step-wise or logical-time models. Toward this goal, the action-level real-time (ALRT) discrete-event system specification (DEVS) modeling and simulation approach is proposed. Modeling of actions is introduced into the parallel DEVS formalism using time invariants defined for real-time statecharts. Actions are specified in terms of time-windows that are to be executed in real-time. An abstract simulator protocol is devised for executing the ALRT-DEVS models under constrained computational resources. The approach is implemented in the parallel DEVS-Suite simulator. These models can be simulated on unitary computing platforms. A simple example switch model is detailed and tested to show the kinds of real-time modeling and simulation studies that can be supported.

An architecture to facilitate interoperability of Discrete Event System Specification and Coalition Battle Management Language simulation models

The Joint Command, Control and Communications Information Exchange Data Model, Coalition Battle Management Language and Military Scenario Definition Language define formatted schemas that have been developed for use in military simulations. The Discrete Event System Specification (DEVS) is used to create models whose behavior is defined in response to events in the simulated environment. The RESTful Interoperability Simulation Environment (RISE) provides a web-based interface for executing DEVS models. DEVS models can be used to simulate systems as diverse as natural disasters and traffic patterns. We present an application that uses formatted messaging to interact with a DEVS model running on the RISE server. The purpose of this is to demonstrate that a DEVS model can be executed as part of a larger, web-enabled synthetic environment, such as a military planning exercise.

Modeling and simulation method of the emergency response systems based on OODA

It is necessary to provide a set of scientific foundations to support the emergency response management. The emergency response process are described based on the ideas from OODA (Observe, Orient, Decide, Act) loop theory. Pointing at the difficulty in the described the cooperation in the emergency response process, the coupled OODA framework is built to analyze the interaction between the emergency response units. In order to demonstrate the emergency response mechanism in theoretic way, the simulation theory of DEVS (Discrete Event System Specification) is adopted to build up the simulator model of the basic OODA process framework. Utilize the coupled DEVS model to build the simulation coordinator of the coupled OODA process framework. The earthquake disaster response scenario in STAGE is built on the emergency response mechanism, and the emergency collaborative rescue process based on coupled OODA frameworks is adopted to build up the emergency response system, and the simulation results show reasonable.