Okan Topçu

A metamodel for federation architectures

This article proposes a metamodel for describing the architecture of a High Level Architecture (HLA) compliant federation. A salient feature of the Federation Architecture Metamodel (FAMM) is the behavioral description of federates based on live sequence charts. FAMM formalizes the standard HLA Object Model and Federate Interface Specification. FAMM supports processing through automated tools, and in particular through code generation. It is formulated in metaGME, the metamodel for the Generic Modeling Environment.

Layered simulation architecture: A practical approach

Abstract This article presents a practical approach to the design of federate architectures for the simulation developers by applying a well-known architectural style, layered architecture, from a developer’s perspective. Adopting layered architecture for an HLA-based simulation (i.e. a federate) provides a clear separation to the following concerns; the user interface (where the user can be a human or an external system such as a GIS server), the simulation logic, and the HLA-specific communication. Thus, layered simulation architecture allows the simulation developers to focus on each concern separately and gives them the freedom to implement each layer in a different programming language, and to encapsulate the repetitive and low-level implementation details of the HLA federate interface specification. Moreover, the article introduces a wrapper for the current HLA runtime infrastructure, and gives an account of the suggested implementation practices through a case study.

Adaptive decision making in agent-based simulation

In the context of adaptive and autonomous decision making, a computational model is needed to formalize and implement a practical goal deliberation mechanism that determines how goals can be evaluated, adopted, or rejected. Such a model is expected to lead to self-explanatory decision making, which is essential for understanding and influencing the behavior of autonomous agents and to pave the way to generate desirable macro-level behavior in self-adaptive, self-organizing systems. This article introduces an adaptive decision making architecture for agent-based simulation by promoting deliberative coherence and its extensions for decision making under uncertainty. To this end, a deliberative coherence-driven agent model is presented, and then is extended with run-time monitoring mechanisms. The architecture enables us to evaluate goals and competing tasks to facilitate the selection of the most coherent tasks with respect to a given goal, whereas the successful completion of those tasks contributes to the achievement of mission objectives for systems in shifting, ill-defined, and uncertain environments.

Scenario development: A Model-Driven Engineering perspective

Scenario development starts with capturing scenarios from the users and leads to the design and the development of the simulation environment to execute these scenarios. This paper proposes a scenario development process adopting a Model-Driven Engineering (MDE) perspective. It takes scenario development and the use of scenarios in simulation environment development put forth in IEEE Recommended Practice for Distributed Simulation Engineering and Execution Process (DSEEP) as a starting point. It then constructs a basic vocabulary including the definitions of operational, conceptual, and executable scenarios. Following MDE principles, scenario development is viewed as a series of model transformations. Operational scenarios, mostly defined in a natural language, are first transformed into conceptual scenarios, which conform to a formal metamodel. Then conceptual scenarios can be transformed into executable scenarios specified using a specific scenario definition language. Furthermore, it is also possible to generate the constructs of simulation environment design and development using model transformations. In this regard, a conceptual scenario metamodel is proposed adopting the Base Object Model metamodel as an example. Then this metamodel is used to present the proposed process with a sample operational scenario and conceptual scenario excerpts. Samples are shown how model transformation can be employed for developing a Federation Object Model and an executable scenario file.

Modelling unmanned surface vehicle patrol mission with Coalition Battle Management Language (C-BML):

Today, many military software intensive systems such as command and control systems, military simulations and decision support systems require the same military knowledge found in the operation plans and orders, which are mostly imported to the system in an application specific form. Due to the increased need for interoperability among those systems, many domain specific languages arise in order to formalize the inputs and outputs to obtain machine processable knowledge. A major domain specific language is the Coalition Battle Management Language (C-BML), which is currently under development. In this work, a scenario is developed and a coalition combat organization that has unmanned surface vehicle (USV) units under its command is created for fighting piracy. The orders and reports related to the patrol mission for the USVs are set up and modelled using C-BML. In order to model the orders, functional and temporal analyses of the actions in the orders are performed. The representativeness of the military orders, reports and requests in the scope of the scenario domain in C-BML is examined. Discussions about the expressiveness of C-BML are offered from a C-BML adopter perspective. Furthermore, we anticipate that this study will serve as a guideline for further C-BML studies.

Metamodeling live sequence charts for code generation

This article presents a metamodeling study for Live Sequence Charts (LSCs) and Message Sequence Charts (MSCs) with an emphasis on code generation. The article discusses specifically the following points: the approach to building a metamodel for MSCs and LSCs, a metamodel extension from MSC to LSC, support for model-based code generation, and finally action model and domain-specific data model integration. The metamodel is formulated in metaGME, the metamodel language for the Generic Modeling Environment.

Guide to Distributed Simulation with HLA

The first € price and the £ and

Federate Architecture: Simulation Member Design

price are net prices, subject to local VAT. Prices indicated with * include VAT for books; the €(D) includes 7% for Germany, the €(A) includes 10% for Austria. Prices indicated with ** include VAT for electronic products; 19% for Germany, 20% for Austria. All prices exclusive of carriage charges. Prices and other details are subject to change without notice. All errors and omissions excepted. O. Topçu, H. Oğuztüzün Guide to Distributed Simulation with HLA

Federation Architecture: Simulation Environment Design

This chapter presents a practical approach to the design of federate architectures (i.e., simulation member design) for the simulation developers by applying a well-known architectural style, layered architecture. Adopting layered architecture for an HLA-based simulation provides a clear separation of the following concerns: the user interface, where the user can be a human or an external system such as a GIS server, the simulation logic, and the HLA-specific communication. Thus, the layered simulation architecture allows the simulation developers to focus on each concern separately and gives them the freedom to implement each layer in a different programming language and to encapsulate the tedious implementation details of the HLA federate interface specification. Moreover, this chapter introduces a wrapper for the current HLA run-time infrastructure and gives an account of the suggested implementation practices through a case study.

Model Driven Engineering

This chapter introduces the concept of federation (simulation environment) architecture. For rigorous federation design, we need more than lollipop diagrams. In this regard, first, we outline what federation architecture means and then show how to formalize a federation architecture using metamodeling, so that a federation architecture can be put into a machine processable form, thereby enabling tool support for the code generation and the early verification of the federation architectures. To this end, we present a realized metamodel, called Federation Architecture Metamodel (FAMM), for describing the architecture of a HLA compliant federation. We also discuss the verification techniques for federation architectures. Chapter concludes with a case study detailing the federation architecture modeling.