Selim Ciraci

Communication simulations for power system applications

New smart grid technologies and concepts, such as dynamic pricing, demand response, dynamic state estimation, and wide area monitoring, protection, and control, are expected to require considerable communication resources. As the cost of retrofit can be high, future power grids will require the integration of high-speed, secure connections with legacy communication systems, while still providing adequate system control and security. The co-simulation of communication and power systems will become more important as the two systems become more interrelated. This paper will discuss ongoing work at Pacific Northwest National Laboratory to create a flexible, high-speed power and communication system co-simulator for smart grid applications. The framework for the software will be described, including architecture considerations for modular, high performance computing and large-scale scalability (serialization, load balancing, partitioning, cross-platform support, etc.). The current simulator supports the ns-3 (telecommunications) and GridLAB-D (distribution systems) simulators. A test case using the co-simulator, utilizing a transactive demand response system created for the Olympic Peninsula and AEP gridSMART demonstrations, requiring two-way communication between distributed and centralized market devices, will be used to demonstrate the value and intended purpose of the co-simulation environment.

Synchronization Algorithms for Co-simulation of Power Grid and Communication Networks

The ongoing modernization of power grids consists of integrating them with communication networks in order to achieve robust and resilient control of grid operations. To understand the operation of the new smart grid, one approach is to use simulation software. Unfortunately, current power grid simulators at best utilize inadequate approximations to simulate communication networks, if at all. Cooperative simulation of specialized power grid and communication network simulators promises to more accurately reproduce the interactions of real smart grid deployments. However, co-simulation is a challenging problem. A co-simulation must manage the exchange of information, including the synchronization of simulator clocks, between all simulators while maintaining adequate computational performance. This paper describes two new conservative algorithms for reducing the overhead of time synchronization, namely Active Set Conservative and Reactive Conservative. We provide a detailed analysis of their performance characteristics with respect to the current state of the art including both conservative and optimistic synchronization algorithms. In addition, we provide guidelines for selecting the appropriate synchronization algorithm based on the requirements of the co-simulation. The newly proposed algorithms are shown to achieve as much as 14% and 63% improvement in performance, respectively, over the existing conservative algorithm.

GridOPTICS(TM) A Novel Software Framework for Integrating Power Grid Data Storage, Management and Analysis

This paper describes the architecture and design of GridOPTICSTM, a novel software framework for integrating a collection of software tools developed by NPNNLs Future Power Grid Initiative (FPGI) into a coherent, powerful operations and planning tool for the power grid of the future. GridOPTICSTM enables plug-and-play of various analysis, modeling and visualization software tools to improve the efficiency and reliability of power grid. To bridge the data access for different control purposes, GridOPTICSTM provides a scalable, lightweight event processing layer that hides the complexity of data collection, storage, delivery and management. A significant challenge is the requirement to access large amount of data in real time. We address this challenge though a scalable system architecture that balances system performance and ease of integration. The initial prototype of GridOPTICSTM was demonstrated with several use cases from PNNLs FPGI and show that our system can provide real time data access to a diverse set of applications with easy to use APIs.

An Approach for Detecting Inconsistencies between Behavioral Models of the Software Architecture and the Code

In practice, inconsistencies between architectural documentation and the code might arise due to improper implementation of the architecture or the separate, uncontrolled evolution of the code. Several approaches have been proposed to detect inconsistencies between the architecture and the code but these tend to be limited for capturing inconsistencies that might occur at runtime. We present a runtime verification approach for detecting inconsistencies between the dynamic behavior of the documented architecture and the actual runtime behavior of the system. The approach is supported by a set of tools that implement the architecture and the code patterns in Prolog, and automatically generate runtime monitors for detecting inconsistencies. We illustrate the approach and the toolset for a Crisis Management System case study.

Guiding architects in selecting architectural evolution alternatives

Although there exist methods and tools to support architecture evolution, the derivation and evaluation of alternative evolution paths are realized manually. In this paper, we introduce an approach, where architecture specification is converted to a graph representation. Based on this representation, we automatically generate possible evolution paths, evaluate quality attributes for different architectural configurations, and optimize the selection of a particular path accordingly. We illustrate our approach by modeling the software architecture evolution of a crisis management system.

An evaluation of the network simulators in large-scale distributed simulations

Networks for the smart grids are characterized by millions of sensor nodes exchanging information about the status of the grid. This information exchange must be realized reliably and efficiently due to the mission critical nature of the power grid. Hence, the applications and the network protocols developed for the smart grid need go through rigorous testing and analysis before deployment. Developers usually do not have access to such a large-scale network that can be used as a controlled test-bed; therefore, network simulation becomes an essential tool for testing. Network simulation is a well studied problem in the literature and there are various widely used network simulators. These simulators can be adopted for testing applications and protocols of the smart grid. Due to the scale of these networks, parallel/distributed simulations need to be conducted. Even though most network simulators support distributed simulations, generating a large-scale network model to simulate can still be a cumbersome task. In this survey, we describe a selection of commonly used network simulators and evaluate them with respect to the following features that can aid users in distributed simulations of large-scale networks: transparency of setting up distributed simulation, automated topology generation, information hiding, lightweight routing protocols, network error simulation, evaluation of the network model during simulation and trace analysis tools. As a complementary result, we identify two issues with network simulators that can be addressed with runtime steering methods.

Exploiting points-to maps for de-/serialization code generation

Serialization code generators for C++ have restrictions on the implementation of dynamic arrays and void/function pointers. If the target program is not implemented with these restrictions, developers have to manually change the source code to facilitate serialization code generation. Unfortunately, such changes hamper the benefits of code generation, and they are not localized. This paper presents the de-/serialization code generator Ser++ that does not restrict the implementation of these pointer types and, hence, eliminates the need to adapt the source code for serialization code generation. Ser++ can be considered an aspect weaver that i) traces the pointers, ii) identifies the statements in which properties regarding the serialization of pointer attributes can be extracted and, finally, iii) weaves the code to store these properties at runtime. It generates the de-/serialization functions in such a way that they serialize the pointer attributes according to the stored values of the properties. We have successfully used Ser++ to generate de-/serialization methods for a computer architecture and a power-flow simulator, without any modifications to the existing source code.

An Integrated Security Framework for GOSS Power Grid Analytics Platform

In power grid operations, security is an essential component for any middleware platform. Security protects data against unwanted access as well as cyber attacks. GridOpticsTM Software System (GOSS) is an open source power grid analytics platform that facilitates ease of access between applications and data sources and promotes development of advanced analytical applications. GOSS contains an API that abstracts many of the difficulties in connecting to various heterogeneous data sources. A number of applications and data sources have already been implemented to demonstrate functionality and ease of use. A security framework has been implemented which leverages widely accepted, robust Java TM security tools in a way such that they can be interchanged as needed. This framework supports the complex fine-grained, access control rules identified for the diverse data sources already in GOSS. Performance and reliability are also important considerations in any power grid architecture. An evaluation is done to determine the overhead cost caused by security within GOSS and ensure minimal impact to performance.

A Runtime Verification Framework for Control System Simulation

In a standard workflow for the validation of a control system, the control system is implemented as an extension to a simulator. Such simulators are complex software systems, and engineers may unknowingly violate constraints a simulator places on extensions. As such, errors may be introduced in the implementation of either the control system or the simulator leading to invalid simulation results. This paper presents a novel runtime verification approach for verifying control system implementations within simulators. The major contribution of the approach is the two-tier specification process. In the first tier, engineers model constraints using a domain-specific language tailored to modeling a controllers response to changes in its input. The language is high-level and effectively hides the implementation details of the simulator, allowing engineers to specify design-level constraints independent of low-level simulator interfaces. In the second tier, simulator developers provide mapping rules for mapping design-level constraints to the implementation of the simulator. Using the rules, an automated tool transforms the design-level specifications into simulator-specific runtime verification specifications and generates monitoring code which is injected into the implementation of the simulator. During simulation, these monitors observe the input and output variables of the control system and report changes to the verifier. The verifier checks whether these changes follow the constraints of the control system. We describe application of this approach to the verification of the constraints of an HVAC control system implemented with the power grid simulator Grid LAB-D.

A run-time verification framework for smart grid applications implemented on simulation frameworks

Smart grid applications are implemented and tested with simulation frameworks as the developers usually do not have access to large sensor networks to be used as a test bed. The developers are forced to map the implementation onto these frameworks which results in a deviation between the architecture and the code. On its turn this deviation makes it hard to verify behavioral constraints that are described at the architectural level. We have developed the ConArch toolset to support the automated verification of architecture-level behavioral constraints. A key feature of ConArch is programmable mapping for architecture to the implementation. Here, developers implement queries to identify the points in the target program that correspond to architectural interactions. ConArch generates runtime observers that monitor the flow of execution between these points and verifies whether this flow conforms to the behavioral constraints. We illustrate how the programmable mappings can be exploited for verifying behavioral constraints of a smart grid application that is implemented with two simulation frameworks.