Fast Simultaneous Feasibility Test for Security Constrained Unit Commitment

We present a novel fast security analysis method to perform a simultaneous feasibility test (SFT) for security constrained unit commitment (SCUC). Given an SCUC solution, SFT computes base and contingent line flows, overloads, and sensitivities for formulating the violated constraints in the SCUC solver. We use the Sherman-Morrison-Woodbury (SMW) formula to handle topology changes across hours and contingencies. We first developed this SMW-based SFT for contingencies relative to a static network as a generalization of line outage distribution factors (LODFs) achieving the speed of LODFs and modeling complex contingencies as in commercial SFTs. Speedup of the SMW method over commercial methods comes from moving computation from the solve phase to a startup phase. We now extend the SMW technique to network changes across hours and contingencies, permitting deployment on a single compute node due to speedup of the startup phase. The fast SMW-based SFT can be used in a callback, improving over the traditional SCUC-SFT iteration due to a stronger guarantee of satisfying security constraints and to overall speedup since the SCUC solver is invoked only once. The memory required by the SMW-based SFT is large but manageable, and we formulate a technique to decrease this by 80% when implemented.

Abstract-We present a novel fast security analysis method to perform a simultaneous feasibility test (SFT) for security constrained unit commitment (SCUC).Given an SCUC solution, SFT computes base and contingent line flows, overloads, and sensitivities for formulating the violated constraints in the SCUC solver.We use the Sherman-Morrison-Woodbury (SMW) formula to handle topology changes across hours and contingencies.We first developed this SMW-based SFT for contingencies relative to a static network as a generalization of line outage distribution factors (LODFs) achieving the speed of LODFs and modeling complex contingencies as in commercial SFTs.Speedup of the SMW method over commercial methods comes from moving computation from the solve phase to a startup phase.We now extend the SMW technique to network changes across hours and contingencies, permitting deployment on a single compute node due to speedup of the startup phase.The fast SMW-based SFT can be used in a callback, improving over the traditional SCUC-SFT iteration due to a stronger guarantee of satisfying security constraints and to overall speedup since the SCUC solver is invoked only once.The memory required by the SMW-based SFT is large but manageable, and we formulate a technique to decrease this by 80% when implemented.
Index Terms-Contingency analysis, DC power flow, mixed integer programming, security constrained unit commitment, security constraints, simultaneous feasibility test.Slack variable for violation of branch i flow limit.

I. INTRODUCTION
S ECURITY constrained unit commitment (SCUC) is the computational engine supporting market clearing in day ahead electricity markets.SCUC is a mixed integer programming (MIP) problem, with binary decision variables for scheduling the startup and shutdown of a set of generators and continuous variables for generator power output to meet forecasted energy demand over a multi-hour time horizon.Security constraints (SCs) ensure that the flows of power across branches (e.g., transmission lines) in the network induced by the scheduled power injections by generators and withdrawals by loads do not exceed engineering limits.An SC needs to be enforced on each branch in the network, in each time interval in the model horizon, and in each of a list of credible contingencies characterized by the loss of one or more branches (sometimes combined with loss of generation or load), as well as in the base case with no lost branches.
Given a proposed SCUC solution, a simultaneous feasibility test (SFT) process computes the induced branch flows, checks for violations of branch flow limits, and returns a set of violations with sensitivity coefficients to estimate the change in branch flow that would result from a change in net power injection at buses having generators or flexible loads.All the sensitivities could be computed in advance, so that all the SCs could be formulated in the SCUC MIP model as linear constraints, but the number of SCs is so large, and the number of SCs that are influential on the optimal solution can be so small, that an iterative approach is typically used ( [1], [20]), solving SCUC on a given set of SCs, then running SFT on the solution, then adding some violated SCs returned by SFT to the SCUC MIP model and solving again, repeating until no new violations are found by SFT or a time or iteration limit is met.
This paper describes an SFT method designed and implemented for the High-Performance Power-grid Optimization (HIPPO) platform for day ahead SCUC by a team of researchers from multiple organizations, including the Pacific Northwest National Laboratory (PNNL) and Midcontinent Independent System Operator (MISO).Novel aspects of this SFT method are claimed in a US patent [31] and a further US patent application [32].In an ARPA-E-funded project ( [2], [3], [4]), we evaluated the commercial SFT solver used by MISO.The commercial SFT is based on the technique of [5], as outlined in [20] and further described in [22], employing a partial refactorization technique to handle differences in the bus admittance matrix between the base case and each contingency.We then implemented an SFT solver ( [2], [15]) based on the Sherman-Morrison-Woodbury (SMW) formula ( [6]) and the compensation method formulated at a high level of generality in [7].The SMW technique treats the differences in the bus admittance matrix between the base case and each contingency as low rank perturbations and precomputes low rank factorizations of the resulting sensitivity coefficients so that, when solving for a given power injections from SCUC, only a single solve of a linear system with the bus admittance matrix is required, with contingencies handled by fast matrix multiplications with the low rank factors.The SMW compensation methods and the partial refactorization methods are the two main methods of handling a set of network changes implemented in commercial SFT products [22].
In general, the SMW approach to electricity network changes has been widely used.For example, [23] applies this approach to AC single-branch outage contingency analysis in parallel computing environments, and [25] uses it to estimate the effects of disconnecting a single line to relieve overloads.
This paper focuses on the detailed specification and implementation of the SMW approach for an SFT consisting of multi-branch DC contingency evaluation with the aim of computational efficiency so that it can be used in an SCUC MIP algorithm either in alternation with the MIP solver or in a MIP callback.
As applied to contingency evaluation, the SMW technique is similar to the use of line outage distribution factors (LODFs), described in [16], but allows network changes consisting of outages of more than one branch, isolation of some buses having nonzero power injection, and reconnecting of some branches.[26] formulates LODFs for multi-line outages, but does not consider lines going back into service as the general approach of LODFs relies on redistributing existing flows.The SFT implemented in [19], as described in [18], uses the SMW technique but only treats contingencies comprising the outage of a single branch.The implementation in [27], as described in [28], uses LODFs and is similarly limited to single branch outages.In commercial practice, the standard (n-1)-security criterion results in contingencies consisting of outages and reconnections of more than one branch because even the outage of a single branch induces subsequent predetermined actions of closing and opening certain breakers, and this is represented by removing or adding certain branches beyond the one initially outaged.The commercial SFT products typically do treat these more complex contingencies.The commercial SFT that we compared to the HIPPO SFT uses the partial refactorization technique, and our experiments suggest that it is much slower than the HIPPO SFT.Other commercial SFT products may use the SMW technique of [7], but we are not aware of detailed public documentation of these applications.The HIPPO SMW-based SFT method goes beyond that described in [7] in that 1) it reduces computations indexed by buses and branches to much smaller computations indexed by p-nodes and monitored branches by pre-and post-multiplying the low rank factors by appropriate incidence matrices during a pre-computation phase, and 2) it applies the SMW technique to network changes over time as well as over contingencies.The dimensional reduction of the computations is directly enabled by the SMW method, and we believe it is responsible for a majority of the speedup of the HIPPO SFT relative to the commercial SFT product we tested.[29] performs a detailed analysis of the storage and arithmetic operations required by the SMW approach to network changes, but covers only single branch changes and does not consider this dimensional reduction technique but performs its calculations at the dimensionality of buses and branches.We are not aware of any published practical implementation of an SFT treating multi-branch contingencies and branches going back into service with the SMW technique.[21] treats multi-branch contingencies but not as part of an SFT.Instead, it uses an optimization problem to determine the worst case contingency with a given number of branch outages.This method may not be scalable to the ISO-size models that we are treating, and it is not able to focus on just the specific contingencies that are derived from detailed network modeling of a given set of credible (n-1)-security contingencies.
The HIPPO SFT achieved extremely high speed up over the commercial SFT in the solve phase, at the cost of more computation in a startup phase occurring only once, before any solve, and that could be performed in parallel with model generation and the root node solve of the SCUC MIP solver.The much faster solve phase permitted the use of HIPPO SFT in a callback in the SCUC MIP solver rather than in alternation with the SCUC MIP solve, leading to significant speedup in the combined SCUC-SFT solve overall.[24] categorizes SCUC solvers based on how SCs are enforced, either with shift factors computed by an SFT after an SCUC MIP solve is completed, and thereafter in iteration with complete MIP solves, or in a Benders algorithm with a linear programming subproblem to determine the most violated SCs.Invoking the SFT in a MIP solver callback, which is made possible by the speed of the HIPPO SFT, amounts to a Benders algorithm along these lines but where the linear programming subproblem is replaced by the SFT employing linear algebra computations.In addition to being much faster than the tested commercial SFT, the HIPPO SFT is faster than recently developed research codes for contingency analysis deployed to GPUs in [14].
In a subsequent MISO-funded project, the team extended the low rank perturbation idea to handle differences in the bus admittance matrix between the base case of each time interval and a static base case.In contrast, the ARPA-E-funded HIPPO SFT (referred to as SFT0) was used by instantiating a single SFT solver object for each time interval, and we needed to deploy these multiple SFT objects across several nodes of a high performance computing (HPC) cluster in order to keep the startup time from blocking the first call to the SFT solve.The new MISO-funded HIPPO SFT (referred to as SFT1) covers all time intervals in a single SFT solver object with manageable startup time, enabling SFT to be deployed on a single compute node or even on the same node as the SCUC MIP solver.We are not aware of published works applying the SMW technique to planned network changes over multiple time intervals or in combination with contingencies, though the technique is formulated in [7] with sufficient generality to cover this application.
The main contributions of this work are: 1) implementation of the SMW approach to handle network changes from contingencies including multiple outaged or reconnected branches in each contingency, 2) extension of the SMW approach to handle changes from injection buses being isolated from the main island in some contingencies, 3) extension of the SMW approach to handle changes from hourly outages as well as contingencies so that all intervals can be treated correctly by a single SFT object with a single factored admittance matrix on a single compute node, 4) implementation of an SFT in a high level coding language (Python) with open source sparse matrix library that can function in place of a commercial product, 5) demonstration of much faster solve time than the commercial product on real problems of a large ISO, 6) startup time improved by extending the SMW approach to hourly outages, 7) solution algorithm for SCUC enforcing a large set of SCs by calling SFT in the MIP solver callback rather than by starting a new SCUC solve from scratch after each call to SFT, 8) certain technical implementation details enhancing performance, including the reduction of the size of solve phase computations by an order of magnitude due to computation of certain matrix factors in the startup phase, and 9) outlining a refinement of the mathematical approach to mitigate the rather high memory use resulting from applying the SMW technique in the presence of hourly network changes.
The rest of the paper is organized as follows.Section II describes the general SMW approach the HIPPO SFT uses for changes to the network and discusses some ways in which this approach yields a speedup over the partial refactorization technique used in commercial SFT products.Section III shows how HIPPO SFT0 applies this SMW-based method to network changes under contingencies.Section IV shows how HIPPO SFT1 applies SMW to hourly outages and contingency changes and shows how this yields an improvement in the startup run time relative to SFT0 and discusses methods of mitigating the memory use of the HIPPO SFT as we have implemented it.
Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.
Section V discusses some implementation features.Section VI describes the results of some case studies comparing the commercial SFT and HIPPO SFT0 and SFT1 on MISO instances.Finally, Section VII concludes the paper.

II. GENERAL HIPPO SFT METHOD: DC POWER FLOW WITH SMW FORMULA FOR LOW RANK NETWORK CHANGES
This section explains the general SFT method developed by HIPPO.This method is a specific implementation of DC power flow, using the Sherman-Morrison-Woodbury (SMW) formula to handle low rank network changes.The use of SMW for low rank network changes in DC power flow was proposed in [7].HIPPO SFT applied this method to low rank network changes resulting from contingencies.This mathematical method is substantially different from the way that the traditional commercial SFT handles contingency changes with multiple outaged branches, which is by partial refactorization.These differences in the fundamental mathematical methods are the main reason for performance differences between the HIPPO SFT and the commercial SFT.A main task of the MISO-funded HIPPO project was to extend the mathematical method of the HIPPO SFT from contingency changes to hourly outages.

A. DC Power Flow
We begin with a set of buses indexed by j and a set of branches indexed by i.Let M be the bus-branch incidence matrix, with M ji = 1 if j is the to bus of branch i, M ji = −1 if j is the from bus of branch i, and M ji = 0 otherwise.Let B be the diagonal branch admittance matrix with B ii equal to the DC admittance (e.g., the imaginary part of the complex admittance, or the negative reciprocal of the reactance) of branch i.Then the (unmodified) bus admittance matrix A is constructed as Then, given a vector P of bus real power injections satisfying the system power balance constraint where 1 T is a row vector with entries all equal to 1, the vector R of branch real power flows can be determined by solving for the bus angles θ and then computing We modify A to the bus admittance A by choosing a reference bus j0 and setting Alternately, any nonzero value can be used for A j0,j0 , or the row and column of A corresponding to j0 can simply be eliminated.Assuming the network contains only a single connected component, the bus angles are determined uniquely once any one bus angle is fixed.That is, A is singular, but A is nonsingular.So we can determine branch flows by solving for θ, then setting θ j0 = 0, then computing the branch flows R as above.Introducing a matrix Z to zero out θ j0 , we have Then we can eliminate θ by writing Introducing a matrix E to convert p-node injections Q to bus injections P , we have and thus Introducing a matrix H to zero out flows on branches going out of service and to discard flows of non-monitored branches, the vector R of monitored branch flows is given by R = HBM T ZA −1 EQ (11)

B. Static Admittance Matrix Plus Low Rank Update
Now suppose that the (modified) bus admittance matrix A is obtained from a static bus admittance matrix A 0 by applying a low rank update of the form Here M d has 1 column for each branch that is being removed or added to the network, relative to A 0 , with entries of 1 and -1 in the rows corresponding to the to and from buses of the branch, and A d has a single diagonal entry for each such branch.The number of columns in M d and the number of rows and columns in A d is thus equal to the number of branch changes to the network.This number is also the rank of the change to the admittance matrix and is thus referred to as the rank of the change.Then the SMW formula states that where Then we can compute R with one solve using A 0 and some low rank matrix multiplications: (16) In practice we do not compute the inverse admittance matrix but instead compute a Cholesky factorization.Therefore, in a startup phase, before obtaining Q, we compute a lower triangular matrix F such that And, still in the startup phase: Then we compute in a solve phase, once Q is available and R is needed: This SMW approach to low rank network changes is illustrated in Fig. 1(a).Note that in (23), the numbers of rows in the factors X and Y are the numbers of monitored branches and of p-nodes, which are generally much less than the numbers of branches and of buses in the network.The computation of these factors in the startup phase and their use in the solve phase increases the needed computation in the solve phase but decreases it in the startup phase, which is advantageous since the solve phase will be invoked many times while the startup phase only runs once for a given SCUC case.A similar reduction of dimension due to startup computations applies to many of the formulas of the HIPPO SFT, and we believe that this reduction is responsible for a large part of the performance gain of the HIPPO SFT relative to typical commercial SFT software.This dimension reduction is illustrated in Fig. 1(e).
Then, still in the solve phase, given the vector R max of branch flow limits, a branch i is violating the upper limit if Similarly, branch i is violating the lower limit if For any branch i violating its upper or lower limit we can obtain the sensitivity S i• of flow with respect to p-node injections by Then we can add to the SCUC MIP model a variable U i ≥ 0 with a penalty to incentivize solutions with U i = 0 and a constraint if the upper limit is violated or if the lower limit is violated.

III. HIPPO SFT0 WITH 36 INTERVAL ADMITTANCE MATRICES AND CONTINGENCY CHANGES
HIPPO SFT0 applies the SMW technique to network changes resulting from contingencies.Since the network topology may change from one hour to the next, we build a separate SFT solver instance for each time interval, for a total of 36 SFT instances.Since the process is applied to each interval separately from all the others, we drop the time indices.

A. Contingency Outages Represented as Low Rank Changes to a Base Case Admittance Matrix
The post-contingency admittance matrix A c c in contingency c is a low-rank perturbation of the base case admittance matrix A: In the startup phase, we compute the Cholesky factorization Then, still in the startup phase: Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.
Then, in the solve phase, given the p-node injections Q, we compute the base case branch flows R by: R = S 0 Q (36) And we compute the contingency branch flows R c c by: R c And the sensitivities of violating branches i for contingency c are computed as The SFT0 approach is illustrated in Fig. 1(b).

IV. HIPPO SFT1 WITH INCREMENTAL TOPOLOGY CHANGES ACROSS BOTH INTERVALS AND CONTINGENCIES
HIPPO SFT1 applies the SMW technique to network changes resulting from both hourly outages and contingencies, so there is a single SFT solver instance for all intervals, with a single static base case admittance matrix.The node-breaker model is used to represent network changes when implementing the scheduled breaker switching.The hourly topology processing deals with complex scenarios including split-bus, merged-bus, and newisland.The output is the low rank perturbation matrices M dt t and A dt t relative to the base admittance matrix.Contingencies are applied on top of the hourly perturbations.For each hour, more than 750 contingencies are analyzed through this topology processing.

A. Hourly Outages and Contingencies Represented as Low Rank Changes to a Static Admittance Matrix
The base case (pre-contingency) admittance matrix A t t in interval t is a low-rank perturbation of the static admittance matrix A 0 : The post-contingency admittance matrix A tc tc in interval t and contingency c is a low-rank perturbation of the pre-contingency admittance matrix A t t :

B. Decomposition of Post-Contingency Admittance Changes
The post-contingency admittance changes represented by M dtc tc and A dtc tc can be decomposed into a t-independent part and a t-dependent part: If this decomposition can be arranged so that the number of columns in M dtc is very small, then the (tc)-indexed computations, which are otherwise the majority of the startup computation time, can be greatly reduced.
This decomposition can be employed in two ways: 1) for creation and processing of data for SFT, and 2) for efficient computation within SFT.For creation and processing of data for SFT, the data is created in decomposed form, then this decomposed data is passed to SFT, then the SFT startup phase computes the full data matrices M dtc and A dtc and then proceeds.The alternative is to create the full data of M dtc and A dtc and pass that data into SFT.As currently configured, SFT expects data in decomposed form and it then forms the full data and matrices.
For efficient computation within SFT, this decomposition into t-independent and t-dependent parts can be used to decrease the dimensions of the dense linear algebra computations performed by SFT, and the decomposition may be either provided to SFT or computed within SFT from the full data matrices.The opportunity for computational savings comes from the fact that SFT must compute and store (in the startup phase) and multiply (in the solve phase) certain dense matrices of the same dimensions as the sparse matrices M dtc .If the computations associated with M dtc can be replaced by similar computations on M dc and M dtc and the decomposition can be arranged so that M dtc has very few columns, then a majority of the computation time in the SFT startup phase can be eliminated.We have been able to arrange the decomposition in this way, and this decomposition is responsible for the run time advantage of SFT1 relative to SFT0 and is also important for methods that we have derived to mitigate the significant memory requirement of SFT1, as we explain in Section IV-E.

C. Applying the Sherman-Morrison-Woodbury Formula to Hourly Outages
First, in the startup phase, we compute the Cholesky factorization Then, still in the startup phase: Then, in the solve phase, given the p-node injections Q t t for each interval t, we compute the base case branch flows R t t by: Note that R 0 can be (and is) overwritten when iterating over t.
And the sensitivities of violating branches i for interval t are computed as Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.

D. Applying the Sherman-Morrison-Woodbury Formula to Contingency Changes
For contingencies we apply SMW twice, first from A t t to A tc tc , then from A 0 to A t t .We have (51) So in the startup phase, we compute: Therefore, for p-node injections Q t t in interval t, the branch flows R tc tc in interval t and contingency c are So, still in the startup phase, we compute: And, in the solve phase, given Q t t , we compute R tc tc by: And the sensitivities of violating branches i for interval t and contingency c are computed as The SFT1 approach is illustrated in Fig. 1(c).

E. Derivation of Run Time Advantage of SFT1 vs. SFT0 and of Memory Mitigation Methods for SFT1
The startup time of SFT0 is rather long, as demonstrated in Section VI, thought this can be mitigated by deploying the 36 separate instances of SFT0 to multiple compute nodes.Compared to SFT0, SFT1 has a much lower startup time, while the solve time is approximately equal, and this is a principal advantage of SFT1.As we have implemented them, both SFT0 and SFT1 have large but manageable memory use.We have derived several methods for reducing the memory use and will pursue this in future work.In this section we show where the startup run time improvement of SFT1 relative to SFT0 comes from, and we explain the mathematical techniques that can reduce the memory use.For this, we consider a case with typical dimensions of 36 time intervals, 1e3 contingencies, 5e4 buses, 1e4 monitored branches, 5e3 p-nodes, average contingency rank of 3, and average hourly change rank of 1e2.
For the startup run time advantage of SFT1 relative to SFT0, consider the solves of large triangular linear systems using Cholesky factors in (32) and (52).These linear solves are the most time-consuming steps in the startup phase of SFT0 and SFT1, respectively.In (32) for SFT0, with typical dimensions, there are 2 * 3 * 1e3 = 6e3 such solves, but this is repeated 36 times for 36 time intervals, for a total of 2.1e5 solves.In (52) as written for SFT1, the number is the same, but using the decomposition (41) we can reduce to a total of about 6e3 solves.Specifically, we have , and M dtc tc is 0 for most (tc) and has only a few columns generally.Therefore, most columns of W tc tc can be computed by , which requires only 6e3 solves with F .This reduction in startup run time relative to SFT0 due to fewer large linear solves resulting from decomposition was one of our principal motivations for developing SFT1 and is illustrated in Fig. 1(d).
For memory reduction 1, first note that most of the memory requirement in SFT1 arises from the dense low rank matrices W tc tc .With typical dimensions, the W tc tc matrices contain 36 * 3 * 1e3 * 5e4 = 5.4e9 numbers, each stored as a double float using 8 bytes, which comes to about 40 GB, or 80% of the typical memory use we observed in the case study.SFT0 needs to store 36 instances of matrices W c c of the same dimensions as SFT1, so it should have similar memory use, but we did not monitor this in computational testing.
To reduce this memory use, first, instead of computing all the matrices W tc tc , then all V tc tc , and so on, with a loop over (tc) for each step, use a single loop over (tc) and overwrite the storage for W tc tc each time through the loop.That is, all V tc tc , X tc tc , and Y tc tc are computed and stored, but each W tc tc is only computed as an intermediate step.Then the matrices V tc tc , X tc tc , and Y tc tc contain about 1.6e9 numbers and use about 12 GB, essentially all in X tc tc and Y tc tc .This can be implemented in both SFT0 and SFT1.Next, the decomposition (41) allows further memory reduction in SFT1.Typically, for most contingencies c (say 80%), the changes to the network related to the contingency and those related to hourly operating conditions are nonoverlapping, so we actually have Then, for these nonoverlapping contingencies c, the startup computation of W tc tc in (52) can be replaced by Then, we have We can compute and store the factors , and E T W t t in the startup, in addition to others already being Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.
computed, and use these factors instead of X tc tc and Y tc tc in the solve phase.These factors are much smaller, and this replacement decreases the memory requirement of X tc tc and Y tc tc by nearly 80% to 3.6e8 numbers or about 2.8 GB.Note that decomposing X tc tc and Y tc tc into a few factors in this way will somewhat increase the run time of the solve phase since more multiplication steps will be needed.
Finally, note that the loop over (tc) is implemented in Python, and this can be accelerated by compilation to lower level code, and the dense matrix multiplication operations can be accelerated by deployment to a GPU.These techniques are explored in [17].
V. IMPLEMENTATION OF HIPPO SFT HIPPO is coded in Python, and the SFT codes use certain Python packages, including Numpy ( [8]) for dense arrays, Scipy-sparse ( [9]) for sparse matrices and the sparse LU solver SuperLU ( [10]), Scikit-sparse ( [11]) for the Cholmod ( [12]) sparse Cholesky factorization routines included in SuiteSparse ( [13]).A significant contribution of the HIPPO SFT is that it uses open source codes in a high level language for relatively easy customization and further research.We have decreased the solve time by several technical methods, including: 1) precomputing as much as possible in the startup phase to leave short computations for the solve phase, 2) optimizing the order of matrix multiplications using the associative property when there is a choice, 3) collecting all contingency delta terms of a given rank into 3 dimensional arrays and using an array product instead of a time consuming Python loop over contingencies, 4) reduction of solve phase computations on the order of buses and branches (dimension about 5e4) to computations on the order of p-nodes and monitored branches (dimensions about 5e3 and 1e4 respectively), and 5) skipping solve phase computations for branches where the worst contingency can be shown to be within the limits based on the largest XY-terms, to avoid a relatively expensive addition of the XY-terms for the contingencies.Additional detail on these computational enhancements is given in [15] and [2].

A. Case Study General Description
To assess the performance of HIPPO SFT0 relative to the commercial SFT and of HIPPO SFT1 relative to SFT0, several tests were run on SCUC cases from historical MISO day ahead market production runs from various days in 2019 and 2021.The cases all have 36 hourly time intervals, and about 2.8e5 nodes, 2.5e5 breakers, 5e4 buses, 1e4 monitored branches, 5e3 p-nodes, 1e3 contingencies, 1.2e3 generators, 3.7e5 virtual bids, and 2e3 dispatchable demand bids.Several compute nodes in a cluster were used, each consisting of a 2.6 GHz 24 Socket Intel Xeon Processor CPU with 125GB of memory.
We also validated the computations of SFT0 and SFT1 against the commercial SFT on these cases.We compared the computed flows and sensitivities on reported violated SCs and observed agreement to acceptable numerical tolerances.There were minor differences with respect to which SCs were reported.This was traced to ties since each of these SFTs reports only the contingency attaining the largest violation for each branch with a violated limit, and there are sometimes multiple such worst case contingencies.Furthermore, we implemented ex posteriori checks to compute the bus voltage angles and resulting branch power flows for a given time interval and contingency or the base case by explicitly forming and factoring the relevant bus admittance matrix A tc tc or A t t and solving.These checks are much more time consuming than the main SFT0 and SFT1 solve methods and were thus configured for use only in offline study or for debugging.From these checks we concluded that the SFT0 and SFT1 procedures correctly computed the branch flows and sensitivities for violated SCs in our test cases.

B. Performance of HIPPO SFT0 and Comparison to Commercial SFT
Table I shows the HIPPO SCUC MIP solver with SFT0 invoked in a callback for one case under different configurations of number of nodes and processes per node.With six SFT nodes and six parallel processes per node, each node handles six time intervals and thus forms and factors six admittance matrices in the startup phase, finishing before the first incumbent solution from the MIP solver.It takes 18.88s to solve SFT for the first incumbent solution, which includes: 1) solving DC power flow and contingency analysis for 36 intervals, 2) computing sensitivities for 261 violated SCs, and 3) adding 261 SCs to the MIP solver through the callback.The MIP solver continues and SFT is checked whenever there is a new incumbent solution.After the first iteration, there are usually very few further violated SCs returned by SFT.MIP with SFT finishes in 798 s, when a new incumbent solution is found that meets the termination criterion of 0.1% MIP gap and no new violated SCs are found by SFT.However, if we configure HIPPO with only one SFT node, then that one node handles all 36 time intervals and forms and factors 36 admittance matrices, significantly increasing the SFT startup time.With one node and 36 parallel processes per node, after the MIP solver calls SFT for the first incumbent solution, it takes 441 s to get the SFT solution back, mainly waiting for SFT startup to finish.Afterwards, solving 36 interval SFT on one node is only about 5 s.The total time is 1111 s.With three SFT nodes and 12 parallel processes per node, the time for the first SFT is reduced to 49.83 s.The total time is 879 s.For the same case, current production software takes 5185 s, as shown in Table II.The production software runs a MIP SCUC solver in alternation with the commercial SFT, adding violated SCs found by the SFT to the MIP model and then resolving the MIP model, repeating until a termination condition is met.For this test, 3 MIP-SFT iterations were performed, and the final SFT call still found violated SCs, as is common in practice, whereas the callback invocation of SFT ensures that the algorithm terminates only when SFT finds no new SCs.Each call to the production SFT takes between 10 and 20 minutes, so even without considering the MIP solver time, the HIPPO SFT0 is much faster than the commercial SFT.Without this extreme speedup of the HIPPO SFT (both SFT0 and SFT1) relative to the commercial SFT, it would be practically impossible to invoke SFT in a callback, since the callback invocation uses a rather large number of calls to SFT, specifically 7 to 9 calls in this test case.
The total run time of the MIP solver with SFT0 in a callback is not much greater than that of the MIP solve in each of the final iterations of the commercial algorithm, so callback invocation of SFT does not overly degrade the efficiency of the MIP solver.Though lazy constraint callback approaches to MIP problems may be susceptible to long run times, we have not seen this in solving SCUC with SFT in a callback, for two reasons.First, MISO day ahead cases apply "watchlist" constraints in the initial SCUC MIP model.These are routinely binding day ahead and real time transmission constraints.Including them in the initial model can greatly reduce the violations from SFT.Second, if a constraint is added to an SCUC MIP model to prevent overload on one line, then the modified dispatch has decreased flow on many other lines.Thus, only a few SCs need to be enforced, and after the first few callbacks, further MIP solutions are not rejected by the callback, so the MIP solver then converges rapidly.This is same property contributes to the success of the MIP-SFT iterative algorithm for SCUC in commercial practice (see, e.g., [30]).

C. Comparison of HIPPO SFT1 and SFT0
SFT1 was tested against SFT0 on a MISO day ahead SCUC case (called case 0) in a HIPPO run with an SCUC MIP solver, SFT in a MIP callback, and a concurrent optimizer (CO) process managing the overall algorithm and communication between SFT and MIP.HIPPO was configured in two ways: 1) with a single compute node for the entire algorithm, and 2) with 1 node for CO, 1 node for MIP, and 1, 2, or 3 nodes for SFT.For SFT0, to handle network differences from one hour to the next, 36 SFT instances were created, 1 for each hour, in equal numbers on each of the nodes allocated to SFT.Deployment of SFT on 2 or 3 nodes was done only for SFT0.Thus a total of 6 MIP-SFT-CO configurations were tested.All 6 configurations were tested on case 0, and the results are shown in Table III.
Restricting SFT to one node shows a clear advantage to SFT1 in total run time, in configurations using either a single node for all processes or 3 nodes with one for each of CO, SFT, and MIP.With 1 node, the total run time is 767 s for SFT1 and 1363 s for SFT0.With 3 nodes, the total run time is 652 s for SFT1 and 962 s for SFT0.This improvement in run time comes mostly from an improvement in startup time.With 1 node, the startup time is 412 s for SFT1, compared to 904 s for SFT0, and with 3 nodes, it is 341 s, compared to 635 s for SFT0.Considering the solve time for the SFT calls after the first one, all are less than 10 s, while all configurations have much longer run time for the first SFT call.This indicates that in all configurations, the startup is blocking the first call to SFT.The run time of this first call to SFT, and therefore the startup run time, accounts for most of the variation in total run time across the configurations.SFT0 can be accelerated by deploying to multiple nodes in parallel.SFT1 can be accelerated in the same way, though we have not attempted this.For example, one could use 2 or 3 nodes, each treating 18 or 12 hours, as we have done with SFT0, or one could partition the contingencies across nodes.
The maximum memory use of SFT1 in these tests was 55 GB, and SFT0 has similarly large memory use if run on a single node.This large memory requirement is manageable, but we anticipate that it can be decreased substantially by the techniques laid out in Section IV-E, and specifically we estimate approximately 80% reduction is achievable, particularly for SFT1 where decomposition allows further memory reduction.
SFT1 and SFT0 were also compared on 3 additional MISO cases (cases 1, 2, and 3), as shown in Table IV, in each run using Authorized licensed use limited to the terms of the applicable license agreement with IEEE.Restrictions apply.
a single compute node for the entire algorithm.The numbers of violations in the two methods are similar, and the differences are explained by the fact that SFT0 was set up to use the same base case admittance matrix across all time intervals, ignoring the differences from one interval to the next.The optimal objective values are also quite close, and the differences are not greater than would be expected when solving a MIP instance to a given MIP gap with variables and constraints written in two different orders.The total solve times with SFT1 are 20% to 40% less than with SFT0, mainly because of the lower startup time required by SFT1, which results from the decomposition outlined in Section IV-E.Overall, SFT1 has several advantages over SFT0: 1) multiple compute nodes are not needed, 2) significant speedup in startup time leads to significant speedup in first call to SFT solve and in total run time, and 3) though the memory requirement of ∼50 GB is large, it is manageable, and there is a promising path for reduction of memory use.

VII. CONCLUSION
This paper presents a very fast simultaneous feasibility test algorithm for security analysis under hourly and contingency changes to a static network.We show how the method has been extended from initial development on contingency changes only to cover hourly changes.We show performance results demonstrating the extreme speedup of this method over a typical commercial solver.We show that this speedup enables the use of the SFT in a callback instead of in the traditional MIP-SFT iteration, and that this callback invocation yields further speedup in the overall SCUC-SFT algorithm.We intend to continue improving this SFT method, particularly by parallelizing with respect to time and contingencies and by implementing techniques aimed at reducing the memory use.

Fig. 1 .
Fig. 1.Selected main ideas of the HIPPO SMW-based SFT.Dense matrices are filled with solid color, sparse matrices with a hatched pattern.Low rank matrices are drawn as rectangles, lower triangular factors as triangles.(a) Main idea of SMW for low rank network changes.(b) SFT0 approach to network changes over time, 36 instances, 1 for each interval t, using SMW for contingency changes.(c) SFT1 approach applying SMW to changes over t and c.(d) Run time improvement and possible memory improvement due to decomposition in SFT1.Most contingencies do not overlap with hourly network changes.(e) Run time improvement of HIPPO SMW-based SFT relative to partial refactorization approach may derive largely from reduction of dimensions of solve phase computations from the order of buses to the order of p-nodes.
Fast Simultaneous Feasibility Test for Security Constrained Unit Commitment Jesse T. Holzer , Member, IEEE, Yonghong Chen , Fellow, IEEE, Zhongyu Wu, Member, IEEE, Feng Pan, and Arun Veeramany Bus-branch incidence changes, t-dependent part of decomposition of changes for interval t, contingency c.A dtc tc Branch admittance changes, t-dependent part of decomposition of changes for interval t, contingency c.
itcPower flow on branch i in interval t, contingency c.U i

TABLE I HIPPO
SFT0 IN A CALLBACK IN HIPPO SCUC MIP SOLVER

TABLE II COMMERCIAL
SFT IN ITERATION WITH SCUC MIP SOLVER

TABLE III DETAILED
RESULTS OF HIPPO SFT1 AND SFT0 IN A CALLBACK IN HIPPO SCUC MIP SOLVER ON CASE 0