A composable PRS-based agent meta-model for multi-agent simulation using the DEVS framework

Discrete Event Systems Specification (DEVS) formalism supports the specification of discrete event models in a hierarchical and modular manner. Efforts have been made to develop the simulation environments for the modeling and simulation (M&S) of systems using DEVS formalism, particularly in defense M&S domains. This paper introduces the DEVSim++ toolset and its applications. The Object-Analysis Index (OAI) matrix is a tabular form of objects and analysis indices for requirements analysis. DEVSim++ is a realization of DEVS formalism in C++ for M&S. VeriTool is a DEVS model verification tool. DEVSimHLA is a library to support High-level Architecture (HLA) in DEVSim++. Other tools, including KComLib, FOM2CPPClass, and KHLAAdaptor, are used to develop a smart adaptor that allows for the interoperation of simulators of any kind. PlugSim is a distributed simulation framework using plug-in methods. These tools are utilized in every stage of the M&S development process, as well as in every application of the M&S missions to the military domain. Accordingly, the applications implemented by the toolset are used in the training, analytic, and acquisition missions of the Republic of Korea military branches. We expect the DEVS applications to become more prolific as M&S demands grow, and our toolset is already proven as complete and efficient in the domain of defense M&S.

시뮬레이션 프레임워크는 시뮬레이션 응용 프로그램의 개발을 지원하는 기반 소프트웨어이다. 본 논문은 공학용 프로그래밍 언어로 광범위하게 사용되는 매트랩을 이용하여 개발된 이산사건시뮬레이션 프레임워크의 개발 과정을 기술하고 있다. 매트랩 객체지향프로그래밍을 토대로 새롭게 개발된 프레임워크는 매트랩 언어의 편리성과 이산사건시뮬레이션 형식론(DEVS: Discrete EVent System Specification Formalism)이 가지는 뛰어난 개발 방법론을 결합시킴으로써 무기체계 교전 시뮬레이션 프로그램 개발에서 요구되는 생산성, 유연성, 확장성을 제공한다. 더불어 매트랩의 병렬컴퓨팅 기술을 적용한 배치(Batch) 시뮬레이션 기능을 제공함으로써 몬테카를로 시뮬레이션 수행시 컴퓨터 환경에서 지원되는 CPU 코어의 수에 비례하여 응용 프로그램의 연산성능을 향상시킨다. Simulation Framework is a basic software tool used to develop simulation applications. This paper describes the development of a discrete event simulation framework based on DEVS(Discrete EVent System Specification) formalism, using MATLAB language which is widely used in technical computing and engineering disciplines. The newly developed framework utilizing MATLAB object oriented programming combines the convenience of MATLAB language and the sophisticated architecture of the DEVS formalism. Hence, it supports the productivity, flexibility, extensibility that are required for the simulation application software development of the weapon systems engagement. Moreover, it promises a simulation application the increased the computation speed proportional to the number of CPU of a multi-core processor, providing the batch simulation functionality based on MATLAB parallel computing technology.

DEVS-C++, a high-performance environment for modeling large-scale systems at high resolution, uses the DEVS (Discrete-EVent system Specification) formalism to represent both continuous and discrete processes. A prototype suggests that the DEVS formalism can be combined with genetic algorithms running in parallel to serve as the basis of a very general, very fast class of simulation environments.

The Routed Discrete Event System Specification (RDEVS) is a modular and hierarchical Modeling and Simulation (M&S) formalism based on the Discrete Event System Specification (DEVS) formalism that provides a set of design models for dealing with routing problems over DEVS. At the formal level, RDEVS models (as DEVS models themselves) are defined mathematically. However, software implementations of both formalisms are based on an object-oriented paradigm. Furthermore, at the implementation design level, the RDEVS formalism is represented by a conceptual model that uses DEVS simulators as execution engines. Even when RDEVS models can be executed with DEVS simulators, the resulting data (obtained as execution outputs) remains DEVS-based, restricting the study of event flows between models influenced by routing policies. This paper shows how the RDEVS formalism design was enhanced to include event tracking in the models without altering their expected behavior during simulation. Such an improvement is based on adding new features to existing RDEVS components. These features are defined as trackers, which are responsible for getting structured data from events exchanged during RDEVS executions. The proposed solution employs the Decorator pattern as a software engineering option to achieve the required goal. It was deployed as a Java package attached to the RDEVS library, devoted to collecting structured event flow data using JavaScript Object Notation (JSON). The results highlight the modeling benefits of adding event tracking to the original capabilities of the RDEVS formalism. For the M&S community, the novel contribution is an advance in understanding how best modeling practices of software engineering can be used to enhance their software tools in general and the RDEVS formalism in particular.

In this chapter, we formalize the multi-perspective architecture framework using the system-theoretic paradigm provided by the discrete event system specification (DEVS) formalism. The developed integration approach that allows linking up the isolated perspectives has been formalized through a concept based upon DEVS formalism called parameterized DEVS, whereby concurrent simulation processes cause live update through output-to-parameter integration. This sets up the basis for development of DEVS-based holistic models for efficient management of healthcare systems. Results of real case-based simulations are presented to show how holistic models provide new insights not heretofore attainable with unit and facility specific models.

DISCRETE EVENT BASED APPROACH TO THE SIMULATION OF A CONTINUOUS NAVAL SYSTEM

Employing Modeling and Simulation (M&S) extensively to analyze and develop complex systems is the norm today. The use of robust M&S formalisms and rigorous methodologies is essential to deal with complexity. Among them, the Discrete Event System Specification (DEVS) provides a solid framework for modeling structural, behavior and information aspects of any complex system. This gives several advantages to analyze and design complex systems: completeness, verifiability, extensibility, and maintainability. DEVS formalism has been implemented in many programming languages and executable on multiple platforms. In this paper, we describe the features of an M&S framework called xDEVS that builds upon the prevalent DEVS Application Programming Interface (API) for both modeling and simulation layers, promoting interoperability between the existing platform‐specific (C++, Java, Python) DEVS implementations. Additionally, the framework can simulate the same model using sequential, parallel, or distributed architectures. The M&S engine has been reinforced with several strategies to improve performance, as well as tools to perform model analysis and verification. Finally, xDEVS also facilitates systems engineers to apply the vision of model‐based systems engineering (MBSE), model‐driven engineering (MDE), and model‐driven systems engineering (MDSE) paradigms. We highlight the features of the proposed xDEVS framework with multiple examples and case studies illustrating the rigor and diversity of application domains it can support.

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.

The objective of the paper is to present a methodology that can be used to translate a model from one formalism to another allowing model reuse and cross‐verification. With the use of formal languages, the model specifications can be expressed in a rigorous and univocal way, and the model can be validated against the specifications or conceptual model. Expressing the same model in different formal languages opens the conceptual model validation to a varied number of specialists. Also, in the context of modeling a new system, where there is no data to perform validation against a real system, having pairs of models can be used to perform cross‐model verification to ensure that the model specifications or conceptual models are correctly implemented by comparing the results produced by both models. Specifically, a method is presented to translate a model conceptualized on specification and description language (SDL) to discrete event system specification (DEVS). The transformation mechanism between SDL and DEVS formalisms is described. The methodology is exemplified with a disease spread model for COVID‐19, and it is shown how the results obtained by the two models can be used for cross‐verification.

Real-time systems modeling and verification is a complex task. In many cases, formal methods have been employed to deal with the complexity of these systems, but checking those models is usually unfeasible. Modeling and simulation methods introduce a means of validating these model’s specifications. In particular, Discrete Event System Specification (DEVS) models can be used for this purpose. Here, we introduce a new extension to the DEVS formalism, called the Rational Time-Advance DEVS (RTA-DEVS), which permits modeling the behavior of real-time systems that can be modeled by the classical DEVS; however, RTA-DEVS models can be formally checked with standard model-checking algorithms and tools. In order to do so, we introduce a procedure to create timed automata (TA) models that are behaviorally equivalent to the original RTA-DEVS models. This enables the use of the available TA tools and theories for formal model checking. Further, we introduce a methodology to transform classic DEVS models to RTA-DEVS models, thus enabling formal verification of classic DEVS with an acceptable accuracy.

System models are constructed to design, study, and understand complex systems. According to the systems modeling language (SysML) that is a standard for model-based system engineering, all engineering activities should be performed using a common model. To validate complex system models defined in SysML, simulation is usually employed. There are numerous efforts to simulate SysML models using different simulation methods and tools. However, the efficient support of automated generation of executable simulation code is still an issue tangled by the research community. This paper introduces DEVSys, an integrated framework for utilizing existing SysML models and automatically producing executable discrete event simulation code, according to model driven architecture (MDA) concepts. Although this approach is not simulation-specific, discrete event system specification (DEVS) was employed, due to the similarities between SysML and DEVS, mainly in system structure description, and the mature, yet ongoing research on expressing executable DEVS models in a simulator-neutral manner. DEVSys framework elements include (a) a SysML profile for DEVS, enabling integration of simulation capabilities into SysML models, (b) a meta-model for DEVS, allowing the utilization of MDA concepts and tools, (c) a transformation of SysML models to DEVS models, using a standard model transformation language as query/view/transform (QVT), and (d) the generation of DEVS executable code for a DEVS simulation environment with an extensible markup language (XML) interface. The definition and implementation of DEVSys elements, as well as the process for its application are demonstrated and discussed, with the aid of a simple working example.

Discrete event system specification (DEVS), a formalism for modeling and simulation, has been recently applied to the engineering of CPS, which also makes the necessity of model checking for DEVS arisen. Model-transformation-based approaches were first proposed; timed or linear hybrid automata are obtained from DEVS models, and then verified using model checkers. But, due to the different semantics in state transitions, the transformation often involves manual tasks, such as abstraction and approximation. To eliminate such manual tasks, we have proposed a DEVS subclass that is less expressive, but verifiable. For reachability analysis, its models can be interpreted as transition systems and region automata (RA). Although our DEVS subclass and RA have different semantics with respect to model execution, they are equivalent in terms of reachability analysis. Thus, the reachability could be analyzed based on model checking techniques of timed automata. In many DEVS-based environments, models should be developed by programming languages. To enables the modelers to specify CPS in a visual way, we have proposed a visual modeling language based on our subclass. In our language, the behavior and structure of CPS are graphically specified by basic model diagrams and coupled model diagrams, respectively. Based on our subclass and languages, we have implemented a proof-of-concept environment that supports visual modeling of CPS as well as simulation and reachability analysis of the models. To enable the consideration of the hybrid nature and heterogeneity in CPS, DEVS subclasses, languages, verification techniques and environments will be further investigated.

Discrete Event System Specification (DEVS) is a popular formalism for modeling complex dynamic systems using a discrete-event abstraction. At this abstraction level, a timed sequence of pertinent "events" input to a system (or internal timeouts) cause instantaneous changes to the state of the system. Main advantages of DEVS are its rigorous formal definition and its support for modular composition. This tutorial introduces the Classic DEVS formalism in a bottom-up fashion, using a simple traffic light example. The syntax and operational semantics of atomic (i.e., non-hierarchical) models are introduced first. Coupled (i.e., hierarchical) models are introduced to structure and couple Atomic models. We continue to actual applications of DEVS, for example in performance analysis of queueing systems. All examples are presented with the tool PythonPDEVS, though this introduction is equally applicable to other DEVS tools. We conclude with further reading on DEVS theory, DEVS variants, and DEVS tools.

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).

Embedded real-time software construction has usually posed interesting challenges due to the complexity of the tasks these systems have to execute. Most methods for developing these systems are either hard to scale up for large systems, or require a difficult testing effort with no guarantee for bug-free software products. Although formal methods have showed promising results, they are difficult to apply when the complexity of the system under development scales up. Instead, systems engineers have often relied on the use of modeling and simulation (M&S) techniques in order to make system development tasks manageable. Construction of system models and their analysis through simulation reduces both end costs and risks, while enhancing system capabilities and improving the quality of the final products. M&S let users experiment with “virtual’ systems, allowing them to explore changes, and test dynamic conditions in a risk-free environment. This is a useful approach, moreover considering that testing under actual operating conditions may be impractical and in some cases impossible. In this talk, we will present a Modeling and Simulation-based framework to develop embedded systems based on the DEVS (Discrete Event systems Specification) formalism. DEVS provides a formal foundation to M&S that proved to be successful for different complex systems. This approach combines the advantages of a simulationbased approach with the rigor of a formal methodology. We will discuss how to use this framework to incrementally develop embedded applications, and to integrate simulation models with hardware components seamlessly. One of the main aspects of the methodology is that it can be integrated with models of the environment in which the embedded controller will act. We will show how the Cell-DEVS and the QSS methods can be used for this task. We will introduce the main characteristics of the Cell-DEVS and QSS methods, and will show how to model physical systems. We will introduce an integrated environment that deals with these issues, orchestrating a cellular-based simulator (CD++), a GIS (GRASS) and data visualization (Google Earth), to simulate behavior and analyze results supporting the decision making for varied environmental scenarios. Our approach does not impose any order in the deployment of the actual hardware components, providing flexibility to the overall process. The use of DEVS improves reliability (in terms of logical correctness and timing), enables model reuse, and permits reducing development and testing times for the overall process. Consequently, the development cycle is shortened, its cost reduced, and quality and reliability of the final product is improved.