Patricia Glaab

USING ABSTRATION TO ISOLATE HARDWARE IN AN OBJECT-ORIENTED SIMULATION

A common problem faced in the design of an objectoriented simulation is how a complex simulation model should interface with the simulator hardware. This paper describes a design that isolates the hardware interface from the complex models of a simulation environment. A detailed description of the design is provided and the advantages and disadvantages of the design are discussed. A working example of the

MANAGING SHARED MEMORY SPACES IN AN OBJECT-ORIENTED REAL-TIME SIMULATION

Sharing memory spaces between parallel processes is a common practice in a real-time simulation environment. In an environment where parallel processes can exist on the same machine or on different machines, it is a challenge to develop and maintain reusable software that interfaces with shared memory spaces. The two main problems involved in dealing with shared memory spaces are: 1) providing platform independent access to the memory space, and 2) providing to all processes a consistent view of the structure and content of the memory space. Object-oriented techniques were used to create a software architecture designed to manage shared memory spaces. Object-oriented design patterns were used to present client code with a conceptual model of shared memory spaces while concealing the underlying implementation details. The resulting architecture is largely computing platform independent, with platform specific code being isolated to a few selected classes. The design was implemented in C++ for the NASA Langley Standard Real-Time Simulation (LaSRS++) Application Framework. This paper provides an overview of the design and implementation of the LaSRS++ shared memory management software.

CONSTRUCTING A MULTIPLE-VEHICLE, MULTIPLE-CPU SIMULATION USING OBJECT-ORIENTED C++

The object-oriented features of C++ simplify the design of multi-CPU, multi-vehicle simulations. Classes package data and the methods that act on the data. This packaging enables easy multiplication of objects. C++ supports inheritance and polymorphism. Polymorphism allows derived classes to redefine the methods that they inherit from their base class. Thus, client code can act on a collection of heterogeneous objects as a collection of their common base class; yet the behavior that each object exhibits is defined by its derived class type. These object features directly support the creation of heterogeneous , multi-vehicle simulations. To extend this design to multiple CPUs, developers must enable object sharing among processes or threads. Without guards, concurrent object access can lead to data corruption or program failure. This paper introduces several techniques for handling concurrent object access. Also discussed are the unique challenges to using multiple processes versus using multiple threads for multi-CPU operation. This paper uses the Langley Standard Real-Time Simulation in C++ (LaSRS++) as a successful example of applying these design techniques. LaSRS++ is an object-oriented framework for creating simulations that support multiple, heterogeneous vehicles on multiple CPUs.

A validation study of merging and spacing techniques in a NAS-wide simulation

In November 2010, Intelligent Automation, Inc. (IAI) delivered a software tool to NASA Langley that models Merging and Spacing (M&S) for arrivals and departures in the Airspace Concepts Evaluation System (ACES) NAS-wide simulation. This delivery allows researchers to use ACES for system-level studies of the complex terminal airspace. As a precursor to use of the tool for research, the software was evaluated against current day arrivals in the Atlanta TRACON using Atlantas Hartsfield-Jackson International Airport (KATL) arrival schedules, Standard Terminal Arrival Routes (STARs), and traffic flow management (TFM) techniques typical for Atlanta. Results of this validation effort are presented describing data sets, traffic flow assumptions and techniques, and arrival rate comparisons between reported landings at Atlanta versus simulated arrivals using the same traffic sets in ACES equipped with M&S. Since emphasis for intended research is on arrival capacity, this was also the focus of the validation. Before testing began, the simulated system was expected to demonstrate superior capacity over current day Atlanta by managing spacing intervals efficiently and exactly. Initial results, instead, showed the simulations modeled capacity to be far short of what human controllers currently achieve, despite the efficiently managed spacing. Investigation into the cause of the shortfall revealed aspects of systems-level flow and control techniques that are critical to achieving sustained high capacity in the face of varying traffic loads and type mixes. This new understanding, once applied to the current day validation model, allowed a match of Atlantas arrival capacity as well as a better understanding of how modern airports are limited by current day route models. Following this validation effort, a sensitivity study was conducted to measure the impact of variations in system parameters on the Atlanta airport arrival capacity.

SIMULATION OF A F/A-18 E/F DROP MODEL USING THE LaSRS++ FRAMEWORK

A simulation of a 22% dynamically scaled F/A18 E/F Drop Model was successfully developed within the Langley Standard Real-Time Simulation in C++ (LaSRS++) framework. Development in the LaSRS++ framework is done using object-oriented analysis, design and programming techniques. Common software design patterns are also used. Development using the LaSRS++ framework promotes the development of a simulation which is inherently maintainable, extensible, reliable and computationally efficient.

Benefits of a Unified LaSRS++ Simulation for NAS-Wide and High-Fidelity Modeling

The LaSRS++ high-fidelity vehicle simulation was extended in 2012 to support a NAS-wide simulation mode. Since the initial proof-of-concept, the LaSRS++ NAS-wide simulation is maturing into a research-ready tool. A primary benefit of this new capability is the consolidation of the two modeling paradigms under a single framework to save cost, facilitate iterative concept testing between the two tools, and to promote communication and model sharing between user communities at Langley. Specific benefits of each type of modeling are discussed along with the expected benefits of the unified framework. Current capability details of the LaSRS++ NAS-wide simulations are provided, including the visualization tool, live data interface, trajectory generators, terminal routing for arrivals and departures, maneuvering, re-routing, navigation, winds, and turbulence. The plan for future development is also described.

Improved throughput with cooperating futuristic airspace management components

An experiment was conducted to integrate airspace management tools that would typically be confined to either the en route or the terminal airspace to explore the potential benefits of their communication to improve arrival capacity. A NAS-wide simulation was configured with a new concept component that used the information to reconfigure the terminal airspace to the capacity benefit of the airport. Reconfiguration included a dynamically expanding and contracting TRACON area and a varying number of active arrival runways, both automatically selected to accommodate predicted volume of traffic. ATL and DFW were selected for the study. Results showed significant throughput increase for scenarios that are considered to be over-capacity for current day airport configurations. During periods of sustained demand for ATL 2018, throughput increased by 26 operations per hour (30%) and average delay was reduced from 18 minutes to 8 minutes per flight when using the dynamic TRACON. Similar results were obtained for DFW with 2018 traffic levels and for ATL with 2006 traffic levels, but with lower benefits due to lower demand.

A generic object-oriented implementation for flight control systems

This paper presents a design for a generic flight control system (FCS) architecture that breaks the control system into a coupled interaction of laws and devices with a standardized method for execution. Laws generally are computational components that generate commands as outputs, and any number of laws can be isolated and registered on a list in any order for execution. Control devices are code components that receive the command inputs and use additional computations to generate device outputs, such as the servoactuator positions for the control of surfaces. Any number of devices are allowable for a given flight control system and are registered in list format for execution. This method allows for both simplistic FCS implementations and highly complex control systems without changing the architectural requirements of the high level executive. By separating the laws from the devices, special case handling required for control law bypassing (such as that required for direct-drive surface testing and linear analysis) is easily handled at the execution level. No special code support is required internal to the laws.

A METHOD TO INTERFACE AUTO-GENERATED CODE INTO AN OBJECT-ORIENTED SIMULATION FRAMEWORK

Sophisticated computer-based tool packages allow control system researchers to develop and analyze complex control systems from their desktops. Tools such as Matrix X and Matlab are capable of producing autogenerated code of control system diagrams as an output option. Validation requirements are greatly reduced when the auto-generated code can be directly installed into an engineering simulation program.