Model Driven Real-Time Power System Application Development ...

Model Driven Real-Time Power System Application Development Using Just-In-Time Compilation Izudin Dzafic, Priyanka Mohapatra and Nenad Lecek

Abstract This paper describes a method of developing flexible power system applications using model driven development (MDD) and Just-In-Time (JIT) compilation for usage in real-time industrial solutions. MDD is used to create and process mathematical input models for power applications and to confine application development to creation of such models only. Thus application specific programming ends with mathematical model creation. Once a component model is designed, implemented and tested, it should be possible to reuse it as many times as necessary for a variety of purposes in power system application domain. In order to obtain code reusability a non-linear equation handler and solver are implemented. Both the application-specific converter and the general purpose equation handler and solver are designed as components. A JIT compiler is used to generate native code for given models. Models are compiled at run-time. Whenever the model shall be reused, generated native code is reused. Such approach provides significantly better performance compared to solution based on model interpreter. Compared to traditional, compiled software implementations, such solver implementation provides native code execution performance without programming. This provides a possibility to field experts to develop high performance software solutions for their algorithms, also without advanced knowledge of a specific programming language.

I. Dzafic (&)  P. Mohapatra  N. Lecek Energy Sector, Power Distribution Division, Siemens AG, Humboldtstr 59, 90459 Nuremberg, Germany e-mail: [email protected] P. Mohapatra e-mail: [email protected] N. Lecek e-mail: [email protected]

James J. (Jong Hyuk) Park et al. (eds.), Computer Science and Convergence, Lecture Notes in Electrical Engineering 114, DOI: 10.1007/978-94-007-2792-2_7,  Springer Science+Business Media B.V. 2012

67

68

I. Dzafic et al.

Keywords Model driven development analysis Rapid prototyping





Just-in-time compilation



Symbolic

1 Introduction The demand for efficient and re-usable software solutions for power system algorithms has increased significantly in last years. Development of power system applications using the traditional way of programming demands very good software engineering skills and very good domain know-how. A lack of software engineering skills by domain experts should not be an obstacle in development of high performance power system applications. The developer of a software solution for power systems should be more concentrated on the power system algorithms than on software design and implementation. During solution lifetime, some modifications in code are typically requested and implemented. With time, a software solution becomes fragile, often runs into maintenance problems and cannot be re-used because it is very specific to the particular application. This paper analyzes a solution to the above mentioned problems using MDD [1–8]. MDD aims to increase productivity in software development and manage the complexity of software by utilizing modeling to shift from programming in solution-space to modeling in domain-space. As described in papers [4] and [9] the complexities in software development are of two types: Essential and Accidental. The goal of using MDD is to decrease the accidental complexity in order to be able to better deal with essential complexity. In this paper is extensively discussed how to apply MDD to develop industrial and real-time solutions for power system algorithms. The paper proposes usage of MDD just for power system algorithms. A majority of software development is still done with code-centric approach and does not use separately defined models at all. It relies almost entirely on the code written, and expresses the model of the system directly in a programming language such as Java, C++, or C#. It becomes difficult to manage the evolution of these solutions as they scale and complexity increases. Models provide abstractions of a physical system that allow engineers to reason about that system by ignoring extraneous details while focusing on relevant ones. The previous work done in this field [10–15] identifies necessity for creation of re-usable analytical models. Prior to MDD re-usable software was developed by means of defining a domain architecture [16]. A domain model formulated the network using a system of simultaneous nonlinear equations. An object-oriented framework was derived from such a domain model. The domain architecture provided adaptive usage of the framework. MDD is used to create such an analytical model at run-time directly and this model is re-usable for future calculations, unless any topological changes occur in the actual network. For the example of power flow calculation the model created is a set of equations which is later on passed to the code generator. The main aim of using MDD is to keep the application development constrained to model creation step only.

Model Driven Real-Time Power System Application Development

69

In earlier works [15] machine modeling was done using declarative style of programming. The emphasis on a declarative style of programming was on the formulation of the problem and not on the solution steps of the problem. This kind of programming permits the mathematical description of a problem at the level of abstraction an expert is used to in this discipline. A completely general environment for the manipulation of mathematical models of all kinds is provided by Solver Q [10–15], including not only numeric but also symbolic computational capabilities. The Solver Q was developed as a generalized tool to solve variety of power system problems, in a way closer to human thinking [10–15]. This paper also focuses on such a solution which combines mathematical representation of power system models and symbolic computations using expression trees and developing a solver to deal with equations related to various problems in power systems. The problem of differentiation of power flow equations in order to compute Jacobian matrices is discussed in papers [17–19]. An automatic differentiation scheme is proposed which can be easily incorporated into a conventional functioncomputational code. The CPU time spent is only a function of the number of functional terms used and not the number of variables which is a major problem in case of symbolic computation. In papers [18] and [19] this method is further extended to use efficient auto-generated 3GL Jacobian, mismatch computation code and high-level symbolic equation and variable coding. The automatic solution to large systems of non-linear network equations by means of Newton– Raphson method using automatic code generation is analyzed. Over the last few years experts are analyzing the suitability of applying MDD to power system solutions. Paper [11] describes its actual application to real-time solutions, for example optimization, solving non-linear algebraic equations and time domain analysis. In previous approaches the numeric methods generated to solve the above mentioned types of equations needed a lot of programming and compilation and execution code generated later also lacked efficiency. Thus such approaches are unsuitable for usage in industrial solutions, which demand good performance and stability. In some other works, the optimization problem in power systems were solved using a combination of black-box tools for optimization and automatic code-generation for first order derivates [20]. The so-called black box tools were combination of a general-purpose optimization package (MINOS) and an automatic code differentiation tool (ADIFOR). Symbolic computational tools are basically designed to obtain explicit symbolic solutions to a variety of linear and nonlinear mathematical problems. In the area of power systems, pioneer work was performed in the late 80s at the University of Wisconsin-Madison in the development, application and use of symbolic computational tools [21] as well as symbolic-assisted numeric computational tools. The development and application of generic symbolic and numeric computational tools and graphical user interfaces for obtaining solutions of nonlinear problems and related equations are widely discussed, especially those associated with the simulation of power system transients. The use of these tools for power system modeling and simulation has yielded some interesting

70

I. Dzafic et al.

and unique results. Symbolic and symbolic-assisted numeric computational tools have now become part of the mainstream programs used for the analysis, modeling and simulation of power systems, particularly in research and education. For example, in paper [21] usage of MATLAB based programs, which are numeric computational tools that can be used to perform a variety of power system studies, has been discussed. These tools are a good example of how symbolic computation can be used in the development of commercial-grade software for power system analysis, as Jacobian and Hessians can be readily and reliably obtained symbolically for a variety of system models to then integrate them into any numeric computational tool. Another usage of such tools is cited in paper [22] where large disturbance behavior of power systems is captured in a systematic way by a model that consists of differential, switched algebraic and state-reset (DSAR) equations. The DSAR model is then differentiated symbolically. Yet another usage [23] shows modeling of a system as hybrid automation. Such models include the ‘mixed logical dynamic system’ (MLD) or a modified version the ‘dynamic mixed integer program’ (DMIP). Then a symbolic tool is used to convert the hybrid automaton model of a power system into one of these forms. Also symbolic numeric steady state power flow model can be developed for fast and comprehensive contingency analysis [24]. This paper introduces the novel approach of using JIT compiler [25, 26] instead of code interpreter [12, 13] to solve a set of numeric methods from the analytical model. The JIT compiler translates source code into native binary code. This compilation process is done only once, and a link is created between the source code and the corresponding compiled binary code. This increases the speed at which a program runs. It speeds up execution of mathematical intensive functions by up to 50 times. The main reason for using a JIT compiler is to reach the performance of static compilation, while maintaining the advantages of source code interpretation. This paper presents a new approach to power system software application development with the following goals: • • • • •

Easier involvement of domain experts in power system application development Code reusability Speeding up programming Easier maintenance of large power system models Independence from programming languages

2 Comparison of Traditional Programming and MDD The difference in the model creation is illustrated with an example. A simple radial feeder of a power system network (Fig. 1) is considered and the input model is created both in a traditional way and by using MDD. Traditionally the initial model for power flow calculation is created by performing topological tracing over the database storing the network configuration

Model Driven Real-Time Power System Application Development Fig. 1 IEEE 4 node test feeder

2

1

71 3

Infinite Bus

4 2500 ft.

2000 ft.

[I12]

[I34]

Load

[I23]

/// Class CModel implements the general model used by PF Calculation class CModel { public: /// Map storing system buses std::map m_mCBus; /// Map storing slack buses std::map m_mCSlackBus; /// Map storing tap changers std::map m_mCTapChan; /// Map storing system transformers std::map m_mCXfmr; /// Map storing system lines std::map m_mCLine; /// Map storing system loads std::map m_mCLoad; /// Map storing system shunts std::map m_mCShunt; /// Map storing system generators std::map m_mCGen; /// Map storing system switches relevant for the current flow calculations std::map m_mCSwitch; };

Fig. 2 Power system model using traditional programming methodology

and collecting the various network equipments in C++ Standard Template Library (STL) containers. The model created for the node test feeder shown in Fig. 1 using C++ and STL containers is represented in Fig. 2. This process is very time consuming and requires extensive knowledge of C++, STL and other programming concepts to be able to write code to create such a model. Additionally it increases memory consumption of the program and is cumbersome when it comes to large power system networks. As can be seen the model thus created is only a collection of the network elements and their static properties. This way of model creation needs more programming to define the set of equations to be solved for power flow calculation. This is the traditional approach. Instead, a mathematical model of the power system network can be directly created from the information available in the input database during topological tracing and stored in an intermediate format. In case no topological changes are reported by SCADA (Supervisory Control and Data Acquisition) this mathematical model remains unchanged and can be re-used for future calculations. In the component based approach, described in this paper the model created is nothing but a set of equations directly created during topological tracing from the input database specific to the purpose of the power system application. It is then stored in an intermediate format (Expression Trees) which will be then used by the

72

I. Dzafic et al.

Fig. 3 Mathematical model representation

code generator in the next step to create auto-generated code. The mathematical model created from the network is shown in Fig. 3. It should be noticed that the equations needed to be solved for power flow calculation are created on the fly and as a part of model creation. The model creation is basically the end of the application specific development. The next steps to solve these equations are described in the following sections. These steps are independent of the physical network and are generic modules to solve any set of equations. Thus MDD is applied to auto generate executable binaries as a part of model creation procedure. For the network presented in Fig. 3, there are eight variables and eight equations to be solved for. The mathematical model consists of the following: • Model constants (admittance of the lines y) • Model parameters (Load values Sload obtained from load curves, measured, or estimated) • State variables (voltage at various nodes V)

3 Features of Power System MDD There are many advantages of MDD; as mentioned in the previous section the process of model creation is purely analytical and presentation of the physical network as a set of mathematical equations. In this section some additional features are listed which makes MDD a good choice for application to real-time

Model Driven Real-Time Power System Application Development

2

1 y 12 V1

3 y23

V2

2

1 I12

4 y 34 V4

3

4 I34

2/3 Node Reduction

4

I12 = (V1 − V2 )y12

V3

I23

1

73

V2− V3 = 0, where Z 23 = 0 I 34 = (V3 − V4 )y34

⇒ I 34 = (V2 − V4 ) y34 I12 − I 23 = 0 I 23 − I 34 = 0

Fig. 4 Difference in handling of switches

applications. One feature of auto-generating mathematical models for power flow calculations is illustrated in Fig. 4. In the 1st approach in traditional methods of programming the switches in the model are eliminated, by means of node reduction. Since switches have no impedance the two nodes of the switches are reduced to single node. In order to achieve such a node reduction, special handling has to be done in the code and extra lines of code have to be implemented. The same problem is solved in MDD approach by writing mathematical equations applicable to switches in the network. The voltages at both nodes of the switch are equal. This implies no special handling is required and model is created by simply writing the correct set of equations. The model thus generated can be used for further calculations with only a minor change of parameters, unless the topology of the network changes. A topological update implies a change in the number of network elements in a subsystem and thus the mathematical model for this subsystem has to be re-generated. But as such topological changes do not occur very often, re-using the model for calculations is possible and it improves efficiency and performance of the application. Another very important feature of MDD is the possibility to create a new model using composition of models. This implies the output after solving one model can be used as an input for another one. This provides the flexibility of creating smaller models and enables multiple usages of the same model. A combination of two or more models is also possible during run-time. In case a particular topology in the network can be easily solved by simply combining two or more existing models; the models are just combined with each other with minor changes and thus the new model created is only partially re-generated and the previously existing models are re-used. The analytical model created may consist of three kinds of equations to solve for. • Nonlinear optimization • Nonlinear algebraic equations • Time domain analysis

74

I. Dzafic et al. Model Creation Input Model (Set of Equations) Code Generator Expression Tree Syntax Validation

Simplification of Equations

Symbolic Computation Lagrange,Jacobian

Initial Guesses

Numeric Methods

RPN Converter

Solver Model Parameters C/C++ Code

OR

Interpreter

OR

JIT Compiler

Calculation Parameters

Output

Fig. 5 Workflow MDD for power systems

Depending on the type of problem to be solved, the code generator goes through different steps to create numeric methods to be passed on to the Reverse Polish Notation (RPN) converter. The code generator is the module which converts the mathematical model described in the section above into a set of tokens in RPN to be solved by the solver in the next step. The following steps are then executed in the code generator in order to generate tokens. The complete workflow is represented in Workflow MDD for Power Systems (Fig. 5). In the first step, the syntax of set of equations generated as a part of model creation is validated. This step makes sure that the equations are meaningful and no errors were made during the process of model creation. It is a very important step in order to avoid problems due to obvious errors, in creation of numeric methods and parsing in later steps. The checks are made for syntax errors like opening and closing of parenthesis, proper end of lines. In following steps, expression trees are used as model holders. The further simplification of the equations is done in this step, to reduce the number of steps required to process the equations in next steps. Depending on the type of the mathematical model created and the type of power systems problem to be solved different kinds of symbolic computations are carried out for generation of numeric methods. The goal of optimization analysis is to find optimal solution for the given criterion. The following paragraphs give a brief review of mathematical formulation needed for automatic code generation for solving the optimization problem in power systems. This mathematical model is going to be used in explaining the proposed approach. The general optimization problem is described as follows:

Model Driven Real-Time Power System Application Development

75

Minimize : min f ðx1 ; x2 . . .xn Þ Subject to : Gðx1 ; x2 . . .xn Þ ¼ 0;

ð1Þ

Applying Lagrange Multipliers the Lagrange functions are constructed as shown in Eq. (2). LðX; kÞ ¼ f ðXÞ  kGðXÞ

ð2Þ

where X ¼ ½x1 ; x2 ; . . .xn  k ¼ ½k1 ; k2 ; . . .kk  Applying Karush–Kuhn–Tucker conditions, the equations can be re-written as, rL ¼ 0 i:e; k of X oGm  km ¼ 0; i ¼ 1. . .n oxi m¼1 oxi

ð3Þ

and; Gðx1 ; x2 . . .xn Þ ¼ 0 (3) is a set of N nonlinear equations with the same number of unknowns. This is later solved using a Newton–Raphson method. It is important to notice that ‘‘developer’’ writes only equations in the first step (1). A process of automatic code generation transforms mathematical optimization model described with (1) into (2) and (3). An additional step is then required to generate the symbolical Jacobian, needed to solve for Eq. (3). This is, however, part of symbolical Jacobian computation. x1 x2 f1 2 of1 ox

f2

.. . fn

6 of 1 6 2 6 ox1 6 6 6 6 6 . 6 .. 6 6 6 4 ofn ox1

of1 ox2 of2 ox2



x3 of1 ox3

..

 





. ..





. 

   xm 3 of1 oxm of2 oxm

7 7 7 7 7 7 7 .. 7 . 7 7 7 7 5

ð4Þ

ofn oxm

In the case where the symbolic computation is being done only for a set of nonlinear algebraic equations, after model creation the symbolic computation begins directly with generation of Jacobian. The Jacobian is generated for any set of functions f with any set of variables x as represented in Eq. (4).

76 Table 1 Stack contents evaluating expression in RPN Execution step 1 2 3 4 5 Stack Contents 1 1,2 3 3,4 12

I. Dzafic et al.

6 12,5

7 12

8 17,3

9 14

After the creation of the numerical methods, they are passed on to the RPN converter for generation of tokens in RPN in order to be passed on to the solver for final calculation. After the numerical methods are determined and before the first iteration the initial guesses are put into the equations in order to reduce the number of variables and set the boundary conditions. The generation of the numerical methods is an iterative procedure, after each calculation the calculated values are replaced in the Jacobian and the function f in order to determine the next set of equations. This procedure is repeated till the convergence criterion is achieved.

4 RPN Converter A stack machine is a computational model where operands to instructions are always placed in a LIFO data structure, or a stack. The biggest advantage of stack machines is the high density of the code, as operands selection is not encoded in the instructions stream, but they are implicitly gathered from the top of the stack. The taxonomy of these kinds of machines is defined by the number of stacks and the purposes of each of them. The expressions in RPN are evaluated from left to right with the following rules: • Numeric values are pushed on the stack • Operators pop the arguments from the stack and push the result back. The above approach is for binary operators, but the same is extensible to unary functions. Although the features of such architecture were deeply investigated in the late eighties, and several physical platforms were implemented for this model, current mainstream CPUs are register based, with stack support. In RPN calculations occur as soon as an operator is specified. Thus, expressions are not entered wholesale from right to left but calculated one piece at a time, most efficiently from the center outwards. The automatic stack permits the automatic storage of intermediate results for use later: this key feature is what permits RPN interpreters to easily evaluate expressions of arbitrary complexity: they do not have limits on the complexity of expression they can calculate, unlike algebraic interpreters. Table 1 shows the stack contents during evaluation of expression 5-((1 ? 2)4) +3; written in RPN 1; 2; +; 4; -; 5;*; 3; +, [24]. Figure 6 represents the stack status during the execution of the example. The RPN converter is a part of the code generator and it converts the numeric methods from expression trees into RPN to be solved by the solver as the next step.

Model Driven Real-Time Power System Application Development Fig. 6 Stack status during execution of the example

Fig. 7 Automatic code generation

77 push 2

RPN Converter

Fig. 8 Native code generation using JIT compiler

push 1

2

add

1

1

3

Automatic Code Generator

C/C++ Code

RPN Converter

C++ Compiler&Linker

Executable

JIT compiler

Native Code

5 JIT Compiler (Solver) The code generated from the code generator can be passed on to an interpreter, JIT Compiler or converted to C/C++ code to be executed as shown in Fig. 7. The fastest way to solving the equations in case of power system applications is to use the JIT Compiler. C/C++ code is higher level programming language and needs extra compilation and interpretation of the compiled code. This slows down the execution. Interpreted code is translated from a high-level language to a machine code continuously during every execution, whereas statically compiled code is translated into machine code before execution, and only requires this translation once. A common goal of using JIT techniques is to reach the performance of static compilation, while maintaining the advantages of source code interpretation. JIT compilers generally offer far better performance than interpreters. In addition, they can in some cases offer better performance than static compilation, as many optimizations are only feasible at run-time. Automatic code generation is the generation of source code at runtime (Fig. 8). The numeric methods in RPN are converted to C/C++ code at runtime and then compiled to generate an executable. This process though popular is time consuming and slow. The job of the JIT compiler is to convert intermediate code into the machine code or the native code for execution (Fig. 8). With the JIT code the code can be optimized to a particular operating system. The advantage of converting the source code to the intermediate code is that it can run on any operating system provided JIT for that operating system is available. The basic workflow of the solver is shown in Fig. 9. The tokens generated by the RPN converter are passed on to an interface function in the solver as the calculation parameters. Equation (4) represents the Jacobian created during

78

I. Dzafic et al.

Fig. 9 Workflow JIT compiler

∂f1 ∂xn

JIT compiler

f(x)

Table 2 Comparison of performance of power flow calculation Traditional MDD using programming (ms) interpreter (ms) Creation of power system model Power flow calculation Total

Pointer to function f(x)

MDD using JIT compiler (ms)

444

492

511

605 1049

1814 2306

542 1053

Table 3 Comparison of performance of optimal power flow calculation Traditional MDD using MDD using JIT programming (ms) interpreter (ms) compiler (ms) Creation of power system model Optimal Power flow calculation Total

704

784

807

2238

7243

2186

2942

8027

2993

symbolic computation; given the elements Jacobian are not constant but functions as represented in Fig. 9, this function is passed on to the JIT compiler as a set of tokens and after compilation a pointer to the compiled function is returned to the code generator. In contrast to solvers implemented as interpreted code, solvers based on JIT compilation have much smaller memory consumption. This is a big advantage for such solvers to be used in real time applications.

6 Results In order to test the performance of MDD with JIT compiler, tests were carried out on a power systems network with 6108 nodes, 1896 lines, 1212 busbars, 120 transformers and 864 loads. Results are compared with hand made code. The tests were conducted on x86 as well as SPARC processors, on Windows, SUN Solaris, and LINUX platforms. There are two sets of tests conducted for two different power system problems. The performances of power flow calculation using traditional programming methodology and MDD with interpreter and JIT compiler are displayed in Table 2. The second test was carried out for comparing the performances for solving optimization problems. The results obtained are displayed in Table 3.

Model Driven Real-Time Power System Application Development

79

As it can be observed from the test results, the creation of power system model is marginally faster using traditional method of programming in all test cases. The solution based on MDD and JIT compiler provides comparable run-time performance as traditionally developed solution and significantly better performance than MDD using interpreter.

7 Conclusion As explained in this paper, MDD has several advantages over traditional ways of programming. It guarantees stability, efficiency and re-usability. MDD, however, cannot completely replace traditional programming. It provides the possibility to the field experts to develop high performance algorithms and analytical models, without wasting much time on traditional ways of programming. The tests results confirm that the performance of the power system applications developed with MDD and JIT compiler is comparable to those developed using traditional methods of programming. As expected, the test results show that MDD solution using JIT compiler has significantly better performance than solution based on MDD with interpreter. These results show a way to relieve power engineers from time consuming and demanding software development for some power applications. At the same time, the power system applications developed with MDD and JIT compiler are simpler and easier to maintain than traditional software implementations. It can be concluded that MDD in future can be used on large scale in industry applications, in order to avail of its advantages. There is also a lot of scope in future to use MDD in power systems real-time applications.

References 1. MDA resources. Object Management Group. [Online]. Available:http://www.omg.org/mda/ index.htm 2. Selic B (2003) The pragmatics of model-driven development. IEEE Software 20(5):19–25 3. The Middleware Company (2003) Model driven development for J2EE utilizing a model driven architecture (MDA) approach. Productivity Analysis, June 2003 4. Selic B (2006) Model-driven development: its essence and opportunities. In: Proceedings of the ninth IEEE international symposium on object and component-oriented real-time distributed computing 5. Gao J, Li D, Zheng S (2006) Model-driven development of real-time software based on OMG standards. In: Proceedings of the first international conference on innovative computing, information and control 6. Ma Z, He X, Kang L (2009) A model driven development platform for service-oriented applications. World conference on services-II 7. Aho P, Merilinna J, Ovaska E (2009) Model-driven open source software development—the open models approach. In: Fourth international conference on software engineering advances

80

I. Dzafic et al.

8. Heijstek W, Chaudron MRV (2009) The impact of model driven development on the software architecture process. In: 36th EUROMICRO conference on software engineering and advanced applications 9. Brooks F (1986) No silver bullet—essence and accident in software engineering. In: Proceedings of the IFIP tenth world computing conference, pp 1069–1076 10. Dzafic I, Tesnjak S, Glavic M (2002) Automatic object oriented code generation to power system on-line optimization and analysis. 21st IASTED international conference on modeling, identification, and control (MIC 2002), Innsbruck, Austria, February 18–21, 2002 11. Dzafic I, Glavic M, Tesnjak S (2004) A component-based power system model-driven architecture. IEEE Trans Power Syst 19(4):2109–2110 12. Glavic M, Dzafic I, Tesnjak S (2005) A general-purpose symbolically assisted numeric computation environment as a support in power engineering education. IEEE Trans Power Syst 19(1):3–12 13. Dzafic I, Alvarado FL, Glavic M, Tesnjak S (2002) A component based approach to power system applications development. In: 14th power systems computation conference, Sevilla, Spain, June 24–28, 2002 14. Alvarado FL, Liu Y (1988) General purpose symbolic simulation tools for electric networks. IEEE Trans Power Syst 3(2):689–697 15. Alvarado FL, Canizares CA, Keyhani A, Coates B (1991) Instructional use of declarative languages for the study of machine transients. IEEE Trans Power Syst 6(1):407–413 16. Bosshart P, Bacher R (1998) A domain architecture for solving simultaneous nonlinear network equations. IEEE Trans Power Syst 13(3):1006–1012 17. Jerosolimski M, Levacher L (1994) A new method for fast calculation of Jacobian Matrices automatic differentiation for power system simulation. IEEE Trans Power Syst 9(2):700–706 18. Bacher R (1996) Computer aided power flow software engineering and code generation. IEEE Trans Power Syst 11(1):490–496 19. Orfanogianni T, Bacher R (1999) Using automatic code differentiation in power flow algorithms. IEEE Trans Power Syst 14(1):138–144 20. Orfanogianni Yy T, Bacher R (2000) Increased OPF Code development efficiency by integration of general purpose optimization and derivative computation tools. IEEE Trans Power Syst 15(3):987–993 21. Canizares CA (2005) Applications of Symbolic computation to power system analysis and teaching. In: IEEE-PES general meeting, San Francisco, CA, June 2005 22. Hiskens IA, Sokolowski PJ (2001) Systematic modeling and symbolically assisted simulation of power systems. IEEE Trans Power Syst 16(2):229–234 23. Kwatny HG, Mensah EF, Niebur D, Teolis C (2006) Symbolic construction of dynamic mixed integer programs for power system management. IEEE PSCE 24. Liao H, Niebur D (2005) Symbolic/numeric steady-state contingency analysis of electric power systems. IEEE 25. The SPARC architecture manual, version 8, 1991, 1992 SPARC International Inc. 26. Intel 64 and 32 Architectures software developer’s manual, volume 2A, Instruction Set Reference, A-M, 1997–2010 Intel Corporation 27. Intel 64 and 32 Architectures software developer’s manual, volume 2B, Instruction Set Reference, N-Z, 1997–2010 Intel Corporation