A method and system for solving low-rank updated power system network equations

Abstract

The present invention discloses a method and system for solving the low-rank update of the power system network equation, which relates to the technical field of power systems. By obtaining the node operation data of the power system, the node operation data is used to construct the power system network equation to generate the power system network equation; the nodal admittance matrix in the power system network equation is subjected to hierarchical non-diagonal block low-rank decomposition to construct a left low-rank basis large matrix; based on the left low-rank basis large matrix, the nodal admittance matrix is decomposed to construct a target nodal admittance large matrix; based on the target nodal admittance large matrix, the low-rank solution of the power system network equation is performed to generate the solution data of the power system. The present invention performs low-rank update and solution on the power system network equation based on the hierarchical non-diagonal low-rank structure, and can only update the changed part instead of recalculating the entire system when the parameters or structure of the power system change, and can quickly adapt and reduce the consumption of computing resources, thereby significantly improving the computing efficiency.

Description

Technical Field

[0001] The present invention relates to the technical field of power systems, and in particular to a method and system for solving power system network equations with low rank updates. Background Art

[0002] Solving the power system network equations plays a vital role in power system analysis and optimization. These equations describe the relationship between voltage, current and power between nodes in the power system and are the basis for power system analysis, planning and optimization. By solving these equations, key tasks such as power system state estimation, power flow calculation, power load forecasting, and fault analysis can be achieved.

[0003] At present, the traditional methods for solving power system network equations mainly include direct methods and iterative methods. Direct methods such as Gaussian elimination directly decompose the system of equations into upper triangular matrices and obtain solutions through back substitution. In order to improve the efficiency of solution, a factor table is used to record the decomposition process so that when the coefficient matrix on the left side remains unchanged and the constant term to be solved on the right side changes, there is no need to repeat the decomposition process. Only one back substitution is needed to solve the result. In addition, researchers use sparse technology to first find the factorization path to avoid zero element operations, thereby improving the solution speed. The iterative rule continuously updates the solution vector until it converges to a certain accuracy. Preprocessing technology is an important part of the iterative method. By transforming the system of equations, the iterative convergence speed and stability are improved. In recent years, researchers have proposed many new preprocessing techniques, such as incomplete factor decomposition preprocessing and multi-grid preprocessing. These techniques can more effectively accelerate the iterative process and have achieved significant performance improvements in practical applications.

[0004] The above-mentioned solution methods have achieved good results in the practical application of solving power system network equations, but there are still some shortcomings. Due to the large order of power system network equations, the direct method and iterative method need to consume a lot of computing resources and time in the solution process. Secondly, the iterative method is prone to convergence difficulties or even divergence when solving network equations with high impedance or low impedance paths. Thirdly, changes in system structure and parameters often occur during the operation of power systems. Traditional methods are inefficient in adapting to these changes and need to re-perform matrix decomposition or iterative processes, which greatly affects the computational efficiency. Finally, none of the above-mentioned methods have been improved for the regionality, network sparsity and low connectivity of power systems. Summary of the invention

[0005] The present invention provides a low-rank update solution method and system for power system network equations, which solves the technical problems that the existing power system network equation solution methods need to consume a large amount of computing resources and time, have poor adaptability, and lead to low solution efficiency.

[0006] A method for solving a low-rank update of a power system network equation provided by the present invention includes:

[0007] Obtain the node operation data of the power system, and use the node operation data to construct a power system network equation to generate a power system network equation;

[0008] Perform a hierarchical non-diagonal block low-rank decomposition on the node admittance matrix in the power system network equation to construct a left low-rank basis large matrix;

[0009] Based on the left low-rank basis large matrix, decompose the node admittance matrix to construct a target node admittance large matrix;

[0010] Based on the target node admittance large matrix, perform a low-rank solution on the power system network equation to generate the solution data corresponding to the power system.

[0011] Optionally, the step of performing a hierarchical non-diagonal block low-rank decomposition on the node admittance matrix in the power system network equation to construct a left low-rank basis large matrix includes:

[0012] Perform a non-diagonal block partition on the coefficient matrix corresponding to the node admittance matrix in the power system network equation to generate a first initial coefficient block matrix;

[0013] Multiply both sides of the first initial coefficient block matrix by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix to generate an initial update matrix;

[0014] Use the Woodbury matrix identity to update the initial update matrix to generate a target update matrix;

[0015] Perform a subscript conversion on the target update matrix to generate a first target coefficient block matrix;

[0016] Perform a non-diagonal block partition on the first target coefficient block matrix to generate a second coefficient block matrix;

[0017] Use the first target coefficient block matrix to correct the parameters of the equations corresponding to the second coefficient block matrix to generate a low-rank basis equation set;

[0018] Construct a large matrix of all left low-rank bases in the low-rank basis equation set to generate a left low-rank basis large matrix.

[0019] Optionally, the step of decomposing the node admittance matrix based on the left low-rank basis large matrix to construct a target node admittance large matrix includes:

[0020] Use the left low-rank basis large matrix to initialize the node admittance matrix to generate an initial node admittance large matrix;

[0021] Number the leaf nodes and non - leaf nodes of the tree structure corresponding to the initial nodal admittance matrix in ascending order from bottom to top to generate a leaf node sequence and a non - leaf node sequence;

[0022] Take the first leaf node in the leaf node sequence as the initial leaf node;

[0023] Perform LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and count the number of leaf node decompositions;

[0024] Use the leaf node decomposition data to solve the in - place diagonal block decomposition equation corresponding to the initial nodal admittance matrix to generate diagonal block solution data;

[0025] When the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, take the next leaf node corresponding to the initial leaf node as the new initial leaf node, increment the number of leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the initial leaf node and storing it in - place to generate leaf node decomposition data and count the number of leaf node decompositions;

[0026] When the number of leaf node decompositions is equal to the number of leaf nodes, update the initial nodal admittance matrix with the diagonal block solution data at the current moment to obtain an intermediate nodal admittance matrix;

[0027] Perform non - leaf node decomposition on the intermediate nodal admittance matrix based on the non - leaf node sequence to obtain a target nodal admittance matrix.

[0028] Optionally, the step of performing non - leaf node decomposition on the intermediate nodal admittance matrix based on the non - leaf node sequence to obtain a target nodal admittance matrix includes:

[0029] Take the first non - leaf node in the non - leaf node sequence as the initial non - leaf node;

[0030] Perform LU decomposition on the correction matrix corresponding to the initial non - leaf node to generate non - leaf node decomposition data and count the number of non - leaf node decompositions;

[0031] Use the non - leaf node decomposition data to solve the first preset correction equation corresponding to the intermediate nodal admittance matrix in - place to generate a first intermediate variable;

[0032] Calculate the product of the first initial intermediate variable and the sub - node matrix corresponding to the intermediate nodal admittance matrix to generate a first variable matrix;

[0033] Subtract the first variable matrix from the intermediate nodal admittance matrix to generate a non - leaf nodal admittance matrix;

[0034] When the decomposition times of the non-leaf node are less than the number of non-leaf nodes in the non-leaf node sequence, take the next non-leaf node corresponding to the initial non-leaf node as the new initial non-leaf node, increment the non-leaf node decomposition times by 1, and jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node, generating non-leaf node decomposition data and counting the non-leaf node decomposition times;

[0035] When the decomposition times of the non-leaf node are equal to the number of non-leaf nodes, use the non-leaf node admittance matrix at the current moment as the target node admittance matrix.

[0036] Optionally, the step of performing low-rank solution on the power system network equation based on the target node admittance matrix and generating the solution data corresponding to the power system includes:

[0037] Perform low-rank solution on the power system network equation based on the target node admittance matrix to generate the solution data corresponding to the power system;

[0038] When the node admittance matrix undergoes low-rank update, use multiple nodes corresponding to the updated regional data to construct an update path;

[0039] Perform leaf node decomposition on the diagonal block matrix corresponding to the update path based on the leaf node admittance matrix data corresponding to the target node admittance matrix to generate a leaf node admittance matrix;

[0040] Perform non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain a target path node admittance matrix;

[0041] Use the target path node admittance matrix as the new target node admittance matrix, and jump to execute the step of performing low-rank solution on the power system network equation based on the target node admittance matrix to generate the solution data corresponding to the power system.

[0042] Optionally, the step of performing low-rank solution on the power system network equation based on the target node admittance matrix and generating the solution data corresponding to the power system includes:

[0043] Initialize the constant term of the linear equation corresponding to the power system network equation for the parameters to be solved in the linear equation to generate initial parameters to be solved;

[0044] Traverse and solve in-place the diagonal block solution equations of each leaf node to be solved corresponding to the initial parameters to be solved by using the leaf node decomposition data set corresponding to the target node admittance matrix to generate leaf node solution data;

[0045] Sort each unsolved non-leaf node corresponding to the initial parameter to be solved in ascending order to generate an unsolved non-node sequence;

[0046] Take the first unsolved non-leaf node in the initial unsolved non-node sequence as the initial unsolved non-leaf node;

[0047] Solve the second preset correction equation corresponding to the initial unsolved non-leaf node by using the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data, generate a second intermediate variable and count the number of solution times;

[0048] Calculate the product between the second intermediate variable and the sub-node matrix corresponding to the target node admittance matrix to generate a second variable matrix;

[0049] Calculate the difference between the leaf node solution data and the second variable matrix to generate the node solution data corresponding to the initial unsolved non-leaf node;

[0050] When the number of solution times is less than the number of unsolved non-leaf nodes in the initial unsolved non-node sequence, perform the step of solving the second preset correction equation corresponding to the initial unsolved non-leaf node by using the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data, generate a second intermediate variable and count the number of solution times;

[0051] When the number of solution times is equal to the number of unsolved non-leaf nodes, use all the node solution data at the current moment to construct the solution data corresponding to the power system.

[0052] Optionally, the step of performing leaf node decomposition on the diagonal block matrix corresponding to the updated path based on the leaf node admittance matrix data corresponding to the target node admittance matrix to generate a leaf node admittance matrix includes:

[0053] Number the leaf nodes and non-leaf nodes of the updated path in ascending order to generate a path leaf node sequence and a path non-leaf node sequence;

[0054] Take the first path leaf node in the path leaf node sequence as the initial path leaf node;

[0055] Perform LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and store it in-place, generate path leaf node decomposition data and count the number of path leaf node decomposition times;

[0056] Solve the diagonal block decomposition equation corresponding to the leaf node admittance matrix data corresponding to the target node admittance matrix in-place by using the path leaf node decomposition data to generate path diagonal block solution data;

[0057] When the number of decomposition times of the path leaf node is less than the number of path leaf nodes in the path leaf node sequence, the next path leaf node corresponding to the initial path leaf node is used as the new initial path leaf node, the number of decomposition times of the path leaf node is incremented by 1, and the step of performing LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and storing it in-place, generating path leaf node decomposition data and counting the number of decomposition times of the path leaf node is executed by jumping;

[0058] When the number of decomposition times of the path leaf node is equal to the number of path leaf nodes, the leaf node admittance matrix in the leaf node admittance matrix data is updated using the path diagonal block solution data at the current moment to obtain the leaf node admittance matrix.

[0059] Optionally, the step of performing non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain the target path node admittance matrix includes:

[0060] Taking the first path non-leaf node in the path non-leaf node sequence as the initial path non-leaf node;

[0061] Performing LU decomposition on the correction matrix corresponding to the initial path non-leaf node, generating path non-leaf node decomposition data and counting the number of decomposition times of the path non-leaf node;

[0062] Using the path non-leaf node decomposition data to solve the first preset correction equation corresponding to the leaf node admittance matrix in-place to generate initial path variables;

[0063] Calculating the product between the initial path variables and the sub-node matrix corresponding to the leaf node admittance matrix to generate a path variable matrix;

[0064] Subtracting the path variable matrix from the leaf node admittance matrix to generate a path non-leaf node admittance matrix;

[0065] When the number of decomposition times of the path non-leaf node is less than the number of path non-leaf nodes in the path non-leaf node sequence, the next path non-leaf node corresponding to the initial path non-leaf node is used as the new initial path non-leaf node, the number of decomposition times of the path non-leaf node is incremented by 1, and the step of performing LU decomposition on the correction matrix corresponding to the initial path non-leaf node, generating path non-leaf node decomposition data and counting the number of decomposition times of the path non-leaf node is executed by jumping;

[0066] When the number of decomposition times of the path non-leaf node is equal to the number of path non-leaf nodes, the path non-leaf node admittance matrix at the current moment is used as the target path node admittance matrix.

[0067] The present invention also provides a low-rank update solution system for power system network equations, including:

[0068] A power system network equation generation module, configured to obtain the node operation data of a power system, construct a power system network equation by using the node operation data, and generate a power system network equation;

[0069] A left low-rank basis large matrix construction module, configured to perform hierarchical non-diagonal block low-rank decomposition on the node admittance matrix in the power system network equation, and construct a left low-rank basis large matrix;

[0070] A target node admittance large matrix construction module, configured to decompose the node admittance matrix based on the left low-rank basis large matrix, and construct a target node admittance large matrix;

[0071] A solution data generation module, configured to perform low-rank solution on the power system network equation based on the target node admittance large matrix, and generate solution data corresponding to the power system.

[0072] The present invention also provides an electronic device, including a memory and a processor. A computer program is stored in the memory. When the computer program is executed by the processor, the processor is caused to execute the steps of implementing the low-rank update solution method of the power system network equation as described in any one of the above.

[0073] As can be seen from the above technical solutions, the present invention has the following advantages:

[0074] By performing low-rank update solution on the power system network equation based on a hierarchical non-diagonal low-rank structure, the present invention can update only the changed part instead of recalculating the entire system when the parameters or structure of the power system changes, thereby significantly improving the calculation efficiency. The present invention is specifically optimized for the regionality and low connectivity of the power system network, and significantly improves the solution efficiency through a strategy of trading space for time. Especially when the system structure or parameters change, it can quickly adapt and reduce the consumption of computing resources. Through actual tests, the present invention shows a faster solution speed than the prior art on a large-scale system, while optimizing the memory usage, and has strong adaptability, parallel computing ability and broad application prospects. It solves the technical problems that the existing power system network equation solution methods require a large amount of computing resources and time, have poor adaptability, and result in low solution efficiency. Description of the Drawings

[0075] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required for the description of the embodiments or the prior art. Obviously, the following drawings are only some embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative efforts.

[0076] Figure 1 The flowchart of steps of a method for solving low-rank updates of power system network equations provided in Embodiment 1 of the present invention;

[0077] Figure 2 The structural schematic diagram of the coefficient matrix block division provided in Embodiment 1 of the present invention;

[0078] Figure 3 The hierarchical structural schematic diagram corresponding to the coefficient matrix division provided in Embodiment 1 of the present invention;

[0079] Figure 4 The low-rank update calculation task graph provided in Embodiment 1 of the present invention;

[0080] Figure 5 The schematic diagram of the comparison of the low-rank update decomposition speed and the math kernel library decomposition speed provided in Embodiment 1 of the present invention;

[0081] Figure 6 The structural block diagram of a system for solving low-rank updates of power system network equations provided in Embodiment 2 of the present invention;

[0082] Figure 7 The structural block diagram of an electronic device provided in Embodiment 3 of the present invention. Detailed implementation manners

[0083] Embodiments of the present invention provide a method and a system for solving low-rank updates of power system network equations, which are used to solve the technical problems that the existing methods for solving power system network equations consume a large amount of computing resources and time, have poor adaptability, and result in low solving efficiency.

[0084] To make the objectives, features, and advantages of the present invention more obvious and understandable, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the embodiments described below are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0085] Embodiment 1

[0086] Please refer to Figure 1 , Figure 1 which is the flowchart of steps of a method for solving low-rank updates of power system network equations provided in Embodiment 1 of the present invention.

[0087] A method for solving low-rank updates of power system network equations provided in the first instance of the present invention includes:

[0088] Step 101: Obtain the node operation data of the power system, and use the node operation data to construct the power system network equation to generate the power system network equation.

[0089] In the embodiment of the present invention, the node operation data of the power system is obtained, and then the power system network equation is constructed by using the node operation data. The power system network equation refers to the equation that can reflect the mutual relationship between the current and voltage in the power grid, which is abbreviated as the network equation. For a determined power system network, the node voltage equation or loop current equation of the power grid can be written. However, in the actual power grid, due to many grounding branches, the number of loop current equations is more than that of the node voltage equations. In addition, it is difficult to find the independent loops of a large and complex power grid, while the node voltage equation is easy to form and can be conveniently modified when the network structure changes. Therefore, the node voltage equation is generally used in the power grid.

[0090] The node voltage equation describes the mathematical relationship between the injected current of each node in the power grid and the voltage of each node. For a -order power grid, when the ground (the th node) is used as the reference node, the -order node voltage equation, that is, the power system network equation, can be written as:

[0091] ;

[0092] In the formula, is the vector composed of the injected current of each node, ; is the vector composed of the voltage of each node, ; is the node admittance matrix of the network; n is the number of nodes in the power system.

[0093] The node admittance matrix The expression is:

[0094] ;

[0095] In the formula: is the self-admittance of node , and its value is equal to the sum of the admittances of the branches connected to this node; is the mutual admittance between node and node , and its value is equal to the negative value of the admittance of the connected branch.

[0096] It can also be written as:

[0097] ;

[0098] In the formula, Denote the set of all nodes directly connected to the node through branches.

[0099] The nodal admittance matrix has the following characteristics:

[0100] (1) The nodal admittance matrix is a complex matrix, which is usually a non-singular matrix when the power grid has at least one grounding branch.

[0101] (2) The nodal admittance matrix is a symmetric matrix, that is, , so when storing in a computer, usually only the elements of the corresponding upper triangular (or lower triangular) part are stored, thus saving computer memory;

[0102] (3) When there is no directly connected branch between node and node , , so the topological relationship of the power grid can be obtained from the admittance matrix. In addition, each busbar in an actual power system is on average connected to lines or transformers. Therefore, there are a large number of non-diagonal elements in the admittance matrix being 0, that is, the admittance matrix is a sparse matrix;

[0103] (4) In an actual power grid, regions are often connected by only a few lines. Therefore, after dividing the admittance matrix into diagonal blocks and non-diagonal blocks, the non-diagonal blocks correspond to the interconnection lines between regions and can be represented by the product of low-rank bases.

[0104] Step 102: Perform hierarchical non-diagonal block low-rank decomposition on the nodal admittance matrix in the power system network equation, and construct a left low-rank basis large matrix.

[0105] Furthermore, step 102 may include the following sub-steps S11 - S17:

[0106] S11: Divide the coefficient matrix corresponding to the nodal admittance matrix in the power system network equation into non-diagonal blocks to generate a first initial coefficient block matrix.

[0107] S12: Multiply both sides of the first initial coefficient block matrix by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix to generate an initial updated matrix.

[0108] S13: Update the initial updated matrix using the Woodbury matrix identity to generate a target updated matrix.

[0109] S14: Perform subscript conversion on the target updated matrix to generate a first target coefficient block matrix.

[0110] S15. Partition the first target coefficient block matrix into non - diagonal blocks to generate a second coefficient block matrix.

[0111] S16. Use the first target coefficient block matrix to correct the parameters of the equations corresponding to the second coefficient block matrix to generate a low - rank basis system of equations.

[0112] S17. Construct a large matrix from all the left low - rank bases in the low - rank basis system of equations to generate a left low - rank basis large matrix.

[0113] In the embodiments of the present invention, for the linear system of equations corresponding to the power system network equations, it is necessary to solve:

[0114] ;

[0115] Among them, is the coefficient matrix; is the parameter to be solved; is the constant term.

[0116] The coefficient matrix in the equation corresponds to the nodal admittance matrix in the power system network equation. The coefficient matrix of the equation is partitioned twice successively. The first partition divides the matrix into two diagonal blocks and two non - diagonal blocks. The second partition divides the diagonal blocks obtained from the first partition into two diagonal blocks and two non - diagonal blocks again. The two partitions can divide the coefficient matrix corresponding to the linear system into the structure shown. Taking this structure as an example to introduce the algorithm. In the figure, represents the diagonal block in the original matrix, and the corresponding non - diagonal blocks are of low - rank and sparse characteristics.

[0117] Figure 2 The partition shown actually performs a hierarchical processing on the matrix and can be described by a tree structure, as shown in Figure 3 shown.

[0118] Due to the sparse low - rank structure of the non - diagonal blocks, the non - diagonal blocks can be decomposed into the form of the product of two low - rank bases, that is, for , if , then there exists such that , where represents that the matrix is rows columns; is the left low - rank basis; is the right low - rank; is the transpose of the right low - rank. For the convenience of describing the algorithm, assume that the maximum rank of all non - diagonal blocks formed by the two partitions is , and call the rank of the hierarchical non - diagonal low - rank matrix.

[0119] From the tree structure in, for the first partition, the partition coefficient matrix , the corresponding parameter to be solved is , and the corresponding constant term is . The first initial coefficient block matrix is obtained, that is, the coefficient matrix corresponding to the node admittance matrix in the power system network equation is non-diagonally blocked to generate the first initial coefficient block matrix:

[0120] ;

[0121] wherein, is the second coefficient matrix; is the third coefficient matrix; is the second left low-rank basis; is the third left low-rank basis; is the transpose of the second right low-rank; is the transpose of the third right low-rank; is the second parameter to be solved; is the third parameter to be solved; is the second constant term; is the third constant term.

[0122] Multiply both sides by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix, then there is an initial update matrix:

[0123] ;

[0124] wherein, is the identity matrix; is the second node solution to be corrected; is the third node solution to be corrected; is the second node admittance matrix; is the third node admittance matrix; is the transpose of the second right low-rank; is the transpose of the third right low-rank; is the second parameter to be solved; is the third parameter to be solved.

[0125] where , , and from the Woodbury identity, that is, the Woodbury matrix identity, it can be known that:

[0126] ;

[0127] Then there is:

[0128] ;

[0129] Among them, the calculation can be regarded as solving the system of equations , that is, solving:

[0130] ;

[0131] Rewriting the above formula gives , where is the intermediate variable of the second node; is the intermediate variable of the third node. Therefore, it can be equivalently regarded as solving . Then the solution of the original equation can be simplified to the target update matrix, that is, using the Woodbury matrix identity to update the initial update matrix to generate the target update matrix:

[0132] ;

[0133] To unify the subscripts, let , where is the correction sum of the second node and is the correction of the third node. Then there is the first target coefficient block matrix, that is, performing subscript conversion on the target update matrix to generate the first target coefficient block matrix:

[0134] ;

[0135] Solving the equation , then the solution can be transformed into solving the following two sub-problems:

[0136] ;

[0137] Then the solution of the original equation is calculated through the following formula:

[0138] ;

[0139] For and Dividing again gives the second coefficient block matrix, that is, performing non-diagonal block division on the first target coefficient block matrix to generate the second coefficient block matrix:

[0140] ;

[0141] Among them, is the fourth diagonal block; is the fifth diagonal block; is the sixth diagonal block; is the seventh diagonal block; is the fourth left low-rank basis; is the fifth left low-rank basis; is the sixth left low-rank basis; is the seventh left low-rank basis; is the transpose of the fourth right low-rank; is the transpose of the fifth right low-rank; is the transpose of the sixth right low-rank; is the transpose of the seventh right low-rank; is the fourth constant term; is the fifth constant term; is the sixth constant term; is the seventh constant term; is the solution to be corrected for the fourth node; is the solution to be corrected for the fifth node; is the solution to be corrected for the sixth node; is the solution to be corrected for the seventh node; is the upper half of the second left low-rank basis; is the lower half of the second left low-rank basis; is the upper half of the third left low-rank basis; is the lower half of the third left low-rank basis. Transform the problem in the above formula into solving the following system of equations:

[0142] ;

[0143] Then substitute into , and correct and to obtain and . Among them , , , , among which, is the upper half of the decomposition matrix of the second node; is the lower half of the decomposition matrix of the second node; is the upper half of the decomposition matrix of the third node; is the lower half of the decomposition matrix of the third node; is the upper half of the decomposition matrix of the fourth node; is the intermediate variable for solving the fourth node; is the intermediate variable for solving the fifth node; is the intermediate variable for solving the sixth node; is the intermediate variable for solving the seventh node; is the intermediate variable for decomposing the fourth node; is the intermediate variable for decomposing the fifth node; is the intermediate variable for decomposing the sixth node; is the intermediate variable for decomposing the seventh node; is the decomposition matrix of the fourth node; is the decomposition matrix of the fifth node; is the sixth node decomposition matrix; is the seventh node decomposition matrix. The above equations are updated using the corrected data to obtain a low-rank basis equation system, that is, the parameter correction is performed on the equation system corresponding to the second coefficient block matrix using the first target coefficient block matrix to generate a low-rank basis equation system.

[0144] Notice the right sides of the above four sub-problems, the matrices are partitioned and then connected together. This structure inspires the idea of connecting all the left low-rank bases together to form a large matrix. Traverse the tree structure from the root node downwards to create a large left low-rank basis matrix , for each non-leaf node there are two child nodes and , place and vertically. If the number of columns is different, it is stipulated to align to the left and place on the left. Traverse the clustering tree to form a large left low-rank basis matrix. The large left low-rank basis matrix is expressed as:

[0145] ;

[0146] For the sake of easy representation, and the right low-rank basis are also represented by this data structure, denoted as the node admittance large matrix and the right low-rank basis large matrix respectively. For each node in the tree, only the indices of the corresponding low-rank bases in , and need to be stored, rather than storing the specific values. That is, and are also recursively combined according to this rule to correspond to the following two matrices respectively:

[0147] ;

[0148] The , and obtained by this combination method satisfy:

[0149] , , ;

[0150] where, is the dimension of the original matrix, is the maximum rank of all non-diagonal blocks, is the total number of layers of the tree structure.

[0151] For the already partitioned matrix and , a non-recursive algorithm based on a for loop can be written. This algorithm consists of a decomposition stage and a solution stage, This data structure enables the algorithm to calculate multiple left low-rank bases at different levels in the tree structure with only one BLAS or LAPACK call, and no unnecessary data movement is generated.

[0152] Step 103: Decompose the nodal admittance matrix based on the left low-rank basis large matrix to construct the target nodal admittance large matrix.

[0153] Furthermore, step 103 may include the following sub-steps S21 - S28:

[0154] S21: Initialize the nodal admittance matrix using the left low-rank basis large matrix to generate an initial nodal admittance large matrix.

[0155] S22: Number the leaf nodes and non-leaf nodes of the tree structure corresponding to the initial nodal admittance large matrix in ascending order from bottom to top to generate a leaf node sequence and a non-leaf node sequence.

[0156] S23: Take the first leaf node in the leaf node sequence as the initial leaf node.

[0157] S24: Perform LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and count the number of leaf node decompositions.

[0158] S25: Solve the in-place diagonal block decomposition equation of the initial nodal admittance large matrix using the leaf node decomposition data to generate diagonal block solution data.

[0159] S26: When the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, take the next leaf node corresponding to the initial leaf node as the new initial leaf node, increment the number of leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the initial leaf node and storing it in-place to generate leaf node decomposition data and count the number of leaf node decompositions.

[0160] S27: When the number of leaf node decompositions is equal to the number of leaf nodes, update the initial nodal admittance large matrix using the diagonal block solution data at the current moment to obtain an intermediate nodal admittance large matrix.

[0161] S28: Perform non-leaf node decomposition on the intermediate nodal admittance large matrix based on the non-leaf node sequence to obtain the target nodal admittance large matrix.

[0162] Furthermore, step S28 may include the following sub-steps S281 - S287:

[0163] S281. Take the first non-leaf node in the non-leaf node sequence as the initial non-leaf node.

[0164] S282. Perform LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and count the number of non-leaf node decompositions.

[0165] S283. Use the non-leaf node decomposition data to solve the first preset correction equation corresponding to the intermediate node admittance matrix in-situ to generate the first intermediate variable.

[0166] S284. Calculate the product between the first initial intermediate variable and the sub-node matrix corresponding to the intermediate node admittance matrix to generate the first variable matrix.

[0167] S285. Subtract the first variable matrix from the intermediate node admittance matrix to generate the non-leaf node admittance matrix.

[0168] S286. When the number of non-leaf node decompositions is less than the number of non-leaf nodes in the non-leaf node sequence, take the next non-leaf node corresponding to the initial non-leaf node as the new initial non-leaf node, increment the number of non-leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and count the number of non-leaf node decompositions.

[0169] S287. When the number of non-leaf node decompositions is equal to the number of non-leaf nodes, use the non-leaf node admittance matrix at the current moment as the target node admittance matrix.

[0170] In the embodiments of the present invention, the leaf nodes and non-leaf nodes of the tree structure corresponding to the initial node admittance matrix are numbered in the order from bottom to top respectively to generate a leaf node sequence and a non-leaf node sequence, where the non-leaf nodes are sorted in the order from left to right or from right to left for each layer. For the convenience of description, the following symbols are defined represent the index range corresponding to the node in the matrix. Assume represents the index , represents the index Then represents taking the sub-matrix corresponding to the th row and th column of the matrix .

[0171] The specific decomposition process in the decomposition stage is as follows:

[0172] 1. Take and use Initialization, that is, the node admittance matrix is initialized using a left low-rank basis large matrix to generate an initial node admittance large matrix. Subsequent solutions are performed in-place, so all subsequent operations are carried out on the data updated previously;

[0173] 2. Traverse the leaf nodes of the tree and execute:

[0174] (1) Perform LU decomposition on the diagonal block matrix corresponding to the leaf node and store the decomposition result in-place. Specifically: Take the first leaf node in the leaf node sequence as the initial leaf node, then perform LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and count the number of leaf node decompositions;

[0175] (2) Solve multiple columns of data in the left low-rank basis large matrix in-place to obtain the that is, the obtained by solving in the diagonal block decomposition equation. The diagonal block decomposition equation is , where is the node matrix; is the node corresponding index set; is the decomposition matrix after the leaf node decomposition is completed . Use the result of LU decomposition and to solve. represents the first several rows corresponding to the index in . The specific solution process is: Use the leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the initial node admittance large matrix in-place to generate diagonal block solution data; When the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, take the next leaf node corresponding to the initial leaf node as the new initial leaf node, increment the number of leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the initial leaf node and storing it in-place to generate leaf node decomposition data and count the number of leaf node decompositions; When the number of leaf node decompositions is equal to the number of leaf nodes, update the initial node admittance large matrix using the diagonal block solution data at the current moment to obtain the intermediate node admittance large matrix.

[0176] (3) Copy the node admittance large matrix corresponding to the diagonal block solution data at this time , and apply it to the low-rank update algorithm. That is, when the admittance matrix undergoes a low-rank update, use the low-rank update strategy to decompose the admittance matrix again. At this time, the initial node admittance large matrix corresponding to the changing node is the node admittance large matrix corresponding to the diagonal block solution data. Because in the normal solution process for The operation is performed in-place and will overwrite the results after all leaf nodes are calculated. Therefore, a copy needs to be made after calculating the leaf nodes for use in subsequent low-rank updates.

[0177] 3. Traverse each layer of the tree from bottom to top and traverse each non-leaf node in that layer and execute:

[0178] (1) Let the child nodes of this node be and , and take the first non-leaf node in the non-leaf node sequence as the initial non-leaf node;

[0179] (2) Assume the node being calculated is , the child nodes are and , the layer being calculated is , let the correction matrix be , and perform LU decomposition on , storing the results in-place, that is, performing LU decomposition on the correction matrix corresponding to the initial non-leaf node, generating non-leaf node decomposition data and counting the number of non-leaf node decompositions;

[0180] (3) Apply the LU decomposition result of to solve the following equation, that is, use the non-leaf node decomposition data to solve the first preset correction equation corresponding to the intermediate node admittance large matrix in-place, generating the first intermediate variable;

[0181] The first correction equation is:

[0182] ;

[0183] where, is the level of in the tree, the of the root node, and so on, represents the maximum value of the ranks of all non-diagonal blocks of the hierarchical non-diagonal low-rank matrix,

[0184] (4) Calculate the product between the first initial intermediate variable and the child node matrix corresponding to the intermediate node admittance large matrix, generating the first variable matrix ;

[0185] (5) Subtract the first variable matrix from the intermediate node admittance large matrix to generate the non-leaf node admittance large matrix:

[0186] ;

[0187] When the decomposition times of non-leaf nodes are less than the number of non-leaf nodes in the non-leaf node sequence, the next non-leaf node corresponding to the initial non-leaf node is used as the new initial non-leaf node, the decomposition times of non-leaf nodes are incremented by 1, and then jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node, generating non-leaf node decomposition data and counting the decomposition times of non-leaf nodes; when the decomposition times of non-leaf nodes are equal to the number of non-leaf nodes, the non-leaf node admittance matrix at the current moment is used as the target node admittance matrix.

[0188] Step 104, perform low-rank solution on the power system network equation based on the target node admittance matrix, and generate the solution data corresponding to the power system.

[0189] Furthermore, step 104 may include the following sub-steps S31 - S35:

[0190] S31, perform low-rank solution on the power system network equation based on the target node admittance matrix, and generate the solution data corresponding to the power system.

[0191] S32, when the node admittance matrix undergoes low-rank update, use multiple nodes corresponding to the updated regional data to construct an update path.

[0192] S33, perform leaf node decomposition on the diagonal block matrix corresponding to the update path based on the leaf node admittance matrix data corresponding to the target node admittance matrix, and generate the leaf node admittance matrix.

[0193] S34, perform non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain the target path node admittance matrix.

[0194] S35, use the target path node admittance matrix as the new target node admittance matrix, and jump to execute the step of performing low-rank solution on the power system network equation based on the target node admittance matrix to generate the solution data corresponding to the power system.

[0195] Furthermore, step S31 may include the following sub-steps S311 - S319:

[0196] S311, initialize the constant term of the linear equation corresponding to the power system network equation for the parameters to be solved in the linear equation to generate the initial parameters to be solved.

[0197] S312, traverse and solve in-place the diagonal block solution equations of each leaf node to be solved corresponding to the initial parameters to be solved using the leaf node decomposition data set corresponding to the target node admittance matrix, and generate the leaf node solution data.

[0198] S313, sort each non-leaf node to be solved corresponding to the initial parameters to be solved in the order from bottom to top to generate a sequence of non-nodes to be solved.

[0199] S314. Take the first unsolved non-node in the initial unsolved non-node sequence as the initial unsolved non-node.

[0200] S315. Solve the second preset correction equation corresponding to the initial unsolved non-node by using the non-leaf node decomposition data set and leaf node solution data corresponding to the target node admittance large matrix, generate the second intermediate variable and count the number of solution times.

[0201] S316. Calculate the product between the second intermediate variable and the child node matrix corresponding to the target node admittance large matrix to generate the second variable matrix.

[0202] S317. Calculate the difference between the leaf node solution data and the second variable matrix to generate the node solution data corresponding to the initial unsolved non-node.

[0203] S318. When the number of solution times is less than the number of unsolved non-nodes in the initial unsolved non-node sequence, perform the steps of solving the second preset correction equation corresponding to the initial unsolved non-node by using the non-leaf node decomposition data set and leaf node solution data corresponding to the target node admittance large matrix, generating the second intermediate variable and counting the number of solution times.

[0204] S319. When the number of solution times is equal to the number of unsolved non-nodes, construct the solution data corresponding to the power system by using all the node solution data at the current moment.

[0205] In the embodiment of the present invention, when performing low-rank solution on the power system network equation, the specific solution process in the solution stage is as follows:

[0206] 1. , initialize with the value of . The subsequent solution is carried out in place, that is, the constant term of the linear equation set corresponding to the power system network equation is used to initialize the parameters to be solved in the linear equation set to obtain the initial parameters to be solved.

[0207] 2. Traverse the leaf nodes. Let the node being traversed be , and apply the LU decomposition result in the decomposition stage to solve the diagonal block solution equation in place:

[0208] ;

[0209] Among them, is the right vector to be solved corresponding to several rows of the index corresponding to the node. Traverse and solve the diagonal block solution equations of each leaf node to be solved corresponding to the initial parameters to be solved by using the leaf node decomposition data set corresponding to the target node admittance large matrix to obtain the leaf node solution data.

[0210] 3. Traverse the tree from the leaf node upwards For each layer, traverse each non-leaf node of the layer :

[0211] (1) Order The child nodes are and , sort the non-leaf nodes to be solved corresponding to the initial parameters to be solved in order from bottom to top to obtain a sequence of non-nodes to be solved. And take the first non-node to be solved in the initial sequence of non-nodes to be solved as the initial non-node to be solved.

[0212] (2) Assume that the node being calculated is , the child nodes are and , the level being calculated is , the LU decomposition result in the above decomposition stage is applied to solve the second preset correction equation, that is, the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data are used to solve the second preset correction equation corresponding to the initial non-node to be solved, generate the second intermediate variable and count the number of solutions. The second preset correction equation is:

[0213] ;

[0214] (3) Calculate the product of the second intermediate variable and the sub-node matrix corresponding to the target node admittance matrix to generate the second variable matrix ;

[0215] (4) Calculate the difference between the leaf node solution data and the second variable matrix to generate the node solution data corresponding to the initial non-node to be solved:

[0216] The calculation formula corresponding to the node solution data is:

[0217] ;

[0218] When the number of solutions is less than the number of non-nodes to be solved in the initial non-node sequence to be solved, the non-leaf node decomposition data set and the leaf node solution data corresponding to the target node admittance large matrix are used to solve the second preset correction equation corresponding to the initial non-node to be solved, generate a second intermediate variable and count the number of solutions; when the number of solutions is equal to the number of non-nodes to be solved, all node solution data at the current moment are used to construct the solution data corresponding to the power system.

[0219] When traversing each layer of the tree structure, the nodes in the layer do not have data dependencies, so the node operations in the layer can be parallelized to improve the computing efficiency. By overwriting the input with the output result, the computing process only needs to use extra memory, which is easy to obtain , so when the hierarchical non-diagonal low-rank matrix is very small, only very little extra memory is required.

[0220] Further, step S33 may include the following sub-steps S331 - S336:

[0221] S331. Number the leaf nodes and non-leaf nodes of the update path in ascending order respectively to generate a path leaf node sequence and a path non-leaf node sequence.

[0222] S332. Take the first path leaf node in the path leaf node sequence as the initial path leaf node.

[0223] S333. Perform LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and store it in-place, generate path leaf node decomposition data and count the number of path leaf node decompositions.

[0224] S334. Use the path leaf node decomposition data to solve in-place the diagonal block decomposition equation corresponding to the leaf node admittance large matrix data of the target node admittance large matrix, and generate path diagonal block solution data.

[0225] S335. When the number of path leaf node decompositions is less than the number of path leaf nodes in the path leaf node sequence, take the next path leaf node corresponding to the initial path leaf node as the new initial path leaf node, increment the number of path leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and storing it in-place, generating path leaf node decomposition data and counting the number of path leaf node decompositions.

[0226] S336. When the number of path leaf node decompositions is equal to the number of path leaf nodes, use the path diagonal block solution data at the current moment to update the corresponding leaf node admittance large matrix in the leaf node admittance large matrix data to obtain the leaf node admittance large matrix.

[0227] Further, step S34 may include the following sub-steps S341 - S347:

[0228] S341. Take the first path non-leaf node in the path non-leaf node sequence as the initial path non-leaf node.

[0229] S342. Perform LU decomposition on the correction matrix corresponding to the initial path non-leaf node, generate path non-leaf node decomposition data and count the number of path non-leaf node decompositions.

[0230] S343. Use the path non-leaf node decomposition data to solve in-place the first preset correction equation corresponding to the leaf node admittance large matrix to generate initial path variables.

[0231] S344. Calculate the product between the initial path variable and the sub-node matrix corresponding to the large admittance matrix of the leaf nodes to generate a path variable matrix.

[0232] S345. Subtract the path variable matrix from the large admittance matrix of the leaf nodes to generate a large admittance matrix of the non-leaf nodes on the path.

[0233] S346. When the decomposition times of the non-leaf nodes on the path are less than the number of non-leaf nodes in the non-leaf node sequence of the path, use the next non-leaf node corresponding to the initial non-leaf node as the new initial non-leaf node, increment the decomposition times of the non-leaf nodes on the path by 1, and jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate decomposition data of the non-leaf nodes on the path and count the decomposition times of the non-leaf nodes on the path.

[0234] S347. When the decomposition times of the non-leaf nodes on the path are equal to the number of non-leaf nodes, use the large admittance matrix of the non-leaf nodes at the current moment as the target large admittance matrix of the path nodes.

[0235] In the embodiment of the present invention, after the network equation has been decomposed and solved once, only one area of the power system has been updated and the rest remains unchanged. For this situation, this patent proposes a low-rank update algorithm. In the hierarchical non-diagonal low-rank structure solution algorithm, taking Figure 3 as an example, it is noted that the calculation of each layer depends on the calculation results of the next layer. Without loss of generality, assume that only the diagonal block corresponding to node 4 has been updated, and the diagonal blocks corresponding to nodes 5, 6, and 7 remain unchanged. Then, only node 4 needs to be re-LU decomposed, and then the calculation results of nodes 2 and 1 are modified, without having to re-execute the calculation tasks of nodes 5, 6, 7, and node 3. As Figure 4 shown, only by calculating the nodes on a critical path can the low-rank update be completed. Define the critical path, that is, the update path as , which has the same number of layers as the index tree of the hierarchical non-diagonal low-rank structure matrix.

[0236] The solution part of the low-rank update algorithm is the same as the solution process of the above-mentioned hierarchical non-diagonal low-rank direct solution algorithm. The decomposition part of the algorithm is as follows:

[0237] 1. From the nodes corresponding to the diagonal blocks to be updated, obtain , that is, when the node admittance matrix undergoes a low-rank update, use multiple nodes corresponding to the updated area data to construct an update path. Number the leaf nodes and non-leaf nodes of the update path in ascending order from bottom to top to generate a path leaf node sequence and a path non-leaf node sequence. And use the first path leaf node in the path leaf node sequence as the initial path leaf node.

[0238] 2. Traverse leaf nodes , perform the following:

[0239] (1) LU decompose the diagonal block matrix corresponding to the leaf node, and store the decomposition result in-place, that is, perform LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and store it in-place, generate path leaf node decomposition data and count the number of path leaf node decompositions;

[0240] (2) Solve multiple right-hand sides in-place, that is, use the path leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the leaf node admittance matrix data of the target node admittance matrix in-place to obtain path diagonal block solution data.

[0241] When the number of path leaf node decompositions is less than the number of path leaf nodes in the path leaf node sequence, take the next path leaf node corresponding to the initial path leaf node as the new initial path leaf node, increment the number of path leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and storing it in-place, generating path leaf node decomposition data and counting the number of path leaf node decompositions. When the number of path leaf node decompositions is equal to the number of path leaf nodes, update the corresponding leaf node admittance matrix in the leaf node admittance matrix data using the path diagonal block solution data at the current moment to obtain the leaf node admittance matrix.

[0242] 3. Traverse from bottom to top each layer of , and traverse each non-leaf node in this layer

[0243] (1) Take the first path non-leaf node in the path non-leaf node sequence as the initial path non-leaf node, and set the child nodes of this node as and ;

[0244] (2) Perform LU decomposition on , and store the result in-place, that is, perform LU decomposition on the correction matrix corresponding to the initial path non-leaf node, generate path non-leaf node decomposition data and count the number of path non-leaf node decompositions;

[0245] (3) Apply the result of LU decomposition to solve the following equation, that is, use the path non-leaf node decomposition data to solve the first preset correction equation corresponding to the leaf node admittance matrix in-place to obtain the initial path variable.

[0246] The first preset correction equation is:

[0247] ;

[0248] (4) Calculate the product of the initial path variable and the sub-node matrix corresponding to the large admittance matrix of the leaf nodes to generate a path variable matrix. ; Subtract the path variable matrix from the large admittance matrix of the leaf nodes to generate a large admittance matrix of non-leaf nodes on the path, that is, calculate the following formula:

[0249] ;

[0250] When the decomposition times of the non-leaf nodes on the path are less than the number of non-leaf nodes in the non-leaf node sequence of the path, use the next non-leaf node corresponding to the initial non-leaf node on the path as the new initial non-leaf node, increment the decomposition times of the non-leaf nodes on the path by 1, and jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node on the path to generate decomposition data of the non-leaf nodes on the path and count the decomposition times of the non-leaf nodes on the path. When the decomposition times of the non-leaf nodes on the path are equal to the number of non-leaf nodes, use the large admittance matrix of the non-leaf nodes on the path at the current moment as the target path node admittance matrix.

[0251] When an area of the power system is updated, focus on performing LU decomposition only on the diagonal blocks of this area, and then correct the calculation results layer by layer from the leaf nodes upwards according to the updated nodes. This strategy allows the algorithm to only recalculate the nodes on the critical path and skip the repeated calculations of the unchanged parts, thus greatly improving the solution efficiency.

[0252] In the embodiment of the present invention, use the target path node admittance matrix as the new target node admittance matrix, and jump to execute the step of performing low-rank solution on the power system network equation based on the target node admittance matrix to generate the solution data corresponding to the power system. Execute the solution part of the hierarchical non-diagonal low-rank algorithm, and the specific algorithm is the same as the solution process in the above solution stage.

[0253] Further, the test results on 280k-order and 560k-order systems are as Figure 5 shown, proving that the algorithm has significant advantages in dealing with large-scale power system network equations. Compared with the traditional MKL (Math Kernel Library) decomposition method, the low-rank update algorithm has achieved a significant improvement in decomposition time, providing an efficient and reliable solution approach for power system analysis and optimization.

[0254] In an embodiment of the present invention, by acquiring the node operation data of the power system, the node operation data is used to construct the power system network equation, and the power system network equation is generated; the nodal admittance matrix in the power system network equation is subjected to hierarchical non-diagonal block low-rank decomposition to construct a left low-rank basis large matrix; based on the left low-rank basis large matrix, the nodal admittance matrix is decomposed to construct a target nodal admittance large matrix; based on the target nodal admittance large matrix, a low-rank solution of the power system network equation is performed to generate the solution data corresponding to the power system. A method for low-rank update solution of a power system network equation proposed by the present invention is an innovative low-rank update solution algorithm for network equations based on a hierarchical non-diagonal low-rank structure. When the parameters or structure of the power system change, this algorithm can only update the changed part instead of recalculating the entire system, thus significantly improving the calculation efficiency. The present invention is particularly optimized for the regionality and low connectivity of the power system network, and significantly improves the solution efficiency through a strategy of trading space for time. Especially when the system structure or parameters change, it can quickly adapt and reduce the consumption of computing resources. After actual testing, this algorithm shows a faster solution speed than the prior art on a large-scale system, while optimizing memory usage, and has strong adaptability, parallel computing ability and broad application prospects. It solves the technical problems that the existing methods for solving power system network equations require a large amount of computing resources and time, have poor adaptability, and result in low solution efficiency.

[0255] Embodiment 2

[0256] Please refer to Figure 6 , Figure 6 which is a structural block diagram of a system for low-rank update solution of a power system network equation provided by Embodiment 2 of the present invention.

[0257] A system for low-rank update solution of a power system network equation provided by the second embodiment of the present invention includes:

[0258] A power system network equation generation module 601, configured to acquire the node operation data of the power system, and use the node operation data to construct a power system network equation to generate a power system network equation.

[0259] A left low-rank basis large matrix construction module 602, configured to perform hierarchical non-diagonal block low-rank decomposition on the nodal admittance matrix in the power system network equation to construct a left low-rank basis large matrix.

[0260] A target nodal admittance large matrix construction module 603, configured to decompose the nodal admittance matrix based on the left low-rank basis large matrix to construct a target nodal admittance large matrix.

[0261] A solution data generation module 604, configured to perform low-rank solution of the power system network equation based on the target nodal admittance large matrix to generate the solution data corresponding to the power system.

[0262] Optionally, the left low-rank basis large matrix construction module 602 includes:

[0263] A first initial coefficient block matrix generation module, configured to perform non-diagonal block partitioning on the coefficient matrix corresponding to the nodal admittance matrix in the power system network equation to generate a first initial coefficient block matrix.

[0264] An initial update matrix generation module, configured to multiply both sides of the first initial coefficient block matrix by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix to generate an initial update matrix.

[0265] A target update matrix generation module, configured to update the initial update matrix using the Woodbury matrix identity to generate a target update matrix.

[0266] A first target coefficient block matrix generation module, configured to perform subscript conversion on the target update matrix to generate a first target coefficient block matrix.

[0267] A second coefficient block matrix generation module, configured to perform non-diagonal block partitioning on the first target coefficient block matrix to generate a second coefficient block matrix.

[0268] A low-rank basis equation set generation module, configured to perform parameter correction on the equation set corresponding to the second coefficient block matrix using the first target coefficient block matrix to generate a low-rank basis equation set.

[0269] A left low-rank basis large matrix construction sub-module, configured to construct all the left low-rank basis large matrices in the low-rank basis equation set to generate a left low-rank basis large matrix.

[0270] Optionally, the target nodal admittance large matrix construction module 603 includes:

[0271] An initial nodal admittance large matrix generation module, configured to initialize the nodal admittance matrix using the left low-rank basis large matrix to generate an initial nodal admittance large matrix.

[0272] A leaf node sequence and non-leaf node sequence generation module, configured to number the leaf nodes and non-leaf nodes of the tree structure corresponding to the initial nodal admittance large matrix in the order from bottom to top to generate a leaf node sequence and a non-leaf node sequence.

[0273] An initial leaf node determination module, configured to use the first leaf node in the leaf node sequence as the initial leaf node.

[0274] A leaf node decomposition data and leaf node decomposition times generation module, configured to perform LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and count the leaf node decomposition times.

[0275] The diagonal block solution data generation module is used to perform in-situ solution on the diagonal block decomposition equation corresponding to the initial node admittance matrix using the leaf node decomposed data, and generate diagonal block solution data.

[0276] The first jump module is used to, when the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, take the next leaf node corresponding to the initial leaf node as the new initial leaf node, increment the number of leaf node decompositions by 1, and jump to execute the steps of performing LU decomposition on the initial leaf node and storing it in-situ, generating leaf node decomposition data and counting the number of leaf node decompositions.

[0277] The intermediate node admittance matrix obtaining module is used to, when the number of leaf node decompositions is equal to the number of leaf nodes, update the initial node admittance matrix using the diagonal block solution data at the current moment to obtain the intermediate node admittance matrix.

[0278] The target node admittance matrix construction sub-module is used to perform non-leaf node decomposition on the intermediate node admittance matrix based on the non-leaf node sequence to obtain the target node admittance matrix.

[0279] Optionally, the target node admittance matrix construction sub-module can perform the following steps:

[0280] Take the first non-leaf node in the non-leaf node sequence as the initial non-leaf node;

[0281] Perform LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and count the number of non-leaf node decompositions;

[0282] Perform in-situ solution on the first preset correction equation corresponding to the intermediate node admittance matrix using the non-leaf node decomposition data to generate the first intermediate variable;

[0283] Calculate the product between the first initial intermediate variable and the sub-node matrix corresponding to the intermediate node admittance matrix to generate the first variable matrix;

[0284] Subtract the first variable matrix from the intermediate node admittance matrix to generate the non-leaf node admittance matrix;

[0285] When the number of non-leaf node decompositions is less than the number of non-leaf nodes in the non-leaf node sequence, take the next non-leaf node corresponding to the initial non-leaf node as the new initial non-leaf node, increment the number of non-leaf node decompositions by 1, and jump to execute the steps of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and count the number of non-leaf node decompositions;

[0286] When the number of non-leaf node decompositions is equal to the number of non-leaf nodes, use the non-leaf node admittance matrix at the current moment as the target node admittance matrix.

[0287] Optionally, the solution data generation module 604 includes:

[0288] A solution data generation module for performing a low-rank solution of the power system network equation based on the target node admittance matrix and generating solution data corresponding to the power system.

[0289] An updated path construction module for constructing an updated path using multiple nodes corresponding to the updated regional data when the node admittance matrix undergoes a low-rank update.

[0290] A leaf node admittance matrix generation module for performing leaf node decomposition on the diagonal block matrix corresponding to the updated path based on the leaf node admittance matrix data corresponding to the target node admittance matrix to generate a leaf node admittance matrix.

[0291] A target path node admittance matrix obtaining module for performing non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain a target path node admittance matrix.

[0292] A second jump module for using the target path node admittance matrix as the new target node admittance matrix and jumping to execute the step of performing a low-rank solution of the power system network equation based on the target node admittance matrix to generate solution data corresponding to the power system.

[0293] Optionally, the solution data generation module may perform the following steps:

[0294] Initializing the parameters to be solved in the linear equation system corresponding to the power system network equation with the constant term of the linear equation system to generate initial parameters to be solved;

[0295] Traversing and in-situ solving the diagonal block solution equations of each leaf node to be solved corresponding to the initial parameters to be solved using the leaf node decomposition data set corresponding to the target node admittance matrix to generate leaf node solution data;

[0296] Sorting each non-leaf node to be solved corresponding to the initial parameters to be solved in the order from bottom to top to generate a sequence of non-node to be solved;

[0297] Taking the first non-leaf node to be solved in the sequence of non-leaf nodes to be solved as the initial non-leaf node to be solved;

[0298] Solving the second preset correction equation corresponding to the initial non-leaf node to be solved using the non-leaf node decomposition data set and the leaf node solution data corresponding to the target node admittance matrix to generate a second intermediate variable and counting the number of solution times;

[0299] Calculating the product of the second intermediate variable and the sub-node matrix corresponding to the target node admittance matrix to generate a second variable matrix;

[0300] Calculate the difference between the solution data of the leaf nodes and the second variable matrix, and generate the node solution data corresponding to the initial non-node to be solved;

[0301] When the number of solution attempts is less than the number of non-nodes to be solved in the initial non-node sequence to be solved, use the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data to solve the second preset correction equation corresponding to the initial non-node to be solved, generate the second intermediate variable, and count the number of solution attempts;

[0302] When the number of solution attempts is equal to the number of non-nodes to be solved, use all the node solution data at the current moment to construct the solution data corresponding to the power system.

[0303] Optionally, the leaf node admittance matrix generation module can perform the following steps:

[0304] Number the leaf nodes and non-leaf nodes on the updated path in the order from bottom to top to generate a path leaf node sequence and a path non-leaf node sequence;

[0305] Take the first path leaf node in the path leaf node sequence as the initial path leaf node;

[0306] Perform LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and store it in-place, generate path leaf node decomposition data, and count the number of path leaf node decompositions;

[0307] Use the path leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the leaf node admittance matrix data of the target node admittance matrix in-place to generate path diagonal block solution data;

[0308] When the number of path leaf node decompositions is less than the number of path leaf nodes in the path leaf node sequence, take the next path leaf node corresponding to the initial path leaf node as the new initial path leaf node, increment the number of path leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and storing it in-place to generate path leaf node decomposition data and count the number of path leaf node decompositions;

[0309] When the number of path leaf node decompositions is equal to the number of path leaf nodes, use the path diagonal block solution data at the current moment to update the corresponding leaf node admittance matrix in the leaf node admittance matrix data to obtain the leaf node admittance matrix.

[0310] Optionally, the target path node admittance matrix obtaining module can perform the following steps:

[0311] Take the first path non-leaf node in the path non-leaf node sequence as the initial path non-leaf node;

[0312] Perform LU decomposition on the correction matrix corresponding to the non-leaf node of the initial path to generate non-leaf node decomposition data of the path and count the number of non-leaf node decomposition times of the path;

[0313] Use the non-leaf node decomposition data of the path to solve the first preset correction equation corresponding to the leaf node admittance matrix in-situ to generate initial path variables;

[0314] Calculate the product between the initial path variables and the sub-node matrix corresponding to the leaf node admittance matrix to generate a path variable matrix;

[0315] Subtract the path variable matrix from the leaf node admittance matrix to generate a non-leaf node admittance matrix of the path;

[0316] When the number of non-leaf node decomposition times is less than the number of non-leaf nodes in the non-leaf node sequence of the path, use the next non-leaf node corresponding to the initial path non-leaf node as the new initial path non-leaf node, increment the number of non-leaf node decomposition times by 1, and jump to execute the step of performing LU decomposition on the correction matrix corresponding to the initial path non-leaf node to generate non-leaf node decomposition data of the path and count the number of non-leaf node decomposition times of the path;

[0317] When the number of non-leaf node decomposition times is equal to the number of non-leaf nodes, use the non-leaf node admittance matrix at the current moment as the target path node admittance matrix.

[0318] Embodiment III

[0319] Please refer to Figure 7 , Figure 7 which is a structural block diagram of an electronic device provided in Embodiment III of the present invention.

[0320] An electronic device according to an embodiment of the present invention, the electronic device includes: a memory 701 and a processor 702, and a computer program is stored in the memory 701; when the computer program is executed by the processor 702, the processor 702 is caused to execute the power system network equation low-rank update solution method as described in any one of the above embodiments.

[0321] The memory 701 may be an electronic memory such as a flash memory, an EEPROM (electrically erasable programmable read-only memory), an EPROM, a hard disk, or a ROM. The memory 701 has a storage space 703 for program code 713 for performing any of the method steps in the above methods. For example, the storage space 703 for the program code may include respective program codes 713 for implementing the various steps in the above methods. These program codes may be read from or written to one or more computer program products. These computer program products include program code carriers such as hard disks, compact discs (CDs), memory cards, or floppy disks. The program code may be compressed in a suitable form, for example. When run by a computing processing device, these codes cause the computing processing device to perform the respective steps in the method for solving the low-rank update of the power system network equation described above.

[0322] Those skilled in the art can clearly understand that for the convenience and brevity of description, the specific working processes of the systems, devices, and units described above can refer to the corresponding processes in the foregoing method embodiments and will not be elaborated here.

[0323] In several embodiments provided by the present invention, it should be understood that the disclosed systems, devices, and methods can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of units is only a logical function division, and there may be other division methods in actual implementation. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Another point is that the displayed or discussed couplings or direct couplings or communication connections to each other may be indirect couplings or communication connections through some interfaces, devices, or units, and may be in electrical, mechanical, or other forms.

[0324] The units described as separate components may or may not be physically separated, and the components displayed as units may or may not be physical units, that is, they may be located in one place or distributed to multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0325] In addition, in each embodiment of the present invention, the functional units may be integrated in a processing unit, or each unit may exist physically alone, or two or more units may be integrated in one unit. The above integrated units may be implemented in the form of hardware or in the form of software functional units.

[0326] When an integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of this technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods of the various embodiments of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as USB flash drives, mobile hard disks, read-only memories (ROM, Read-Only Memory), random access memories (RAM, Random Access Memory), magnetic disks, or optical discs.

[0327] The above embodiments are only used to illustrate the technical solutions of the present invention, rather than to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: they can still modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements on some of the technical features; and these modifications or replacements do not make the essence of the corresponding technical solutions deviate from the spirit and scope of the technical solutions of the various embodiments of the present invention.

Claims

1. A method for solving low-rank updated network equations of a power system, characterized in that, Including: Obtain the node operation data of the power system, and use the node operation data to construct the power system network equation to generate the power system network equation; Perform hierarchical non-diagonal block low-rank decomposition on the node admittance matrix in the power system network equation to construct a left low-rank basis large matrix; The specific steps include: perform non-diagonal block partitioning on the coefficient matrix corresponding to the node admittance matrix in the power system network equation to generate a first initial coefficient block matrix; multiply both sides of the first initial coefficient block matrix by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix to generate an initial update matrix; update the initial update matrix using the Woodbury matrix identity to generate a target update matrix; perform subscript conversion on the target update matrix to generate a first target coefficient block matrix; perform non-diagonal block partitioning on the first target coefficient block matrix to generate a second coefficient block matrix; use the first target coefficient block matrix to correct the parameters of the equations corresponding to the second coefficient block matrix to generate a low-rank basis equation set; construct a large matrix from all the left low-rank bases in the low-rank basis equation set to generate a left low-rank basis large matrix; Based on the left low-rank basis large matrix, decompose the node admittance matrix to construct a target node admittance large matrix; the specific steps include: initialize the node admittance matrix using the left low-rank basis large matrix to generate an initial node admittance large matrix; number the leaf nodes and non-leaf nodes of the tree structure corresponding to the initial node admittance large matrix in ascending order from bottom to top to generate a leaf node sequence and a non-leaf node sequence; use the first leaf node in the leaf node sequence as the initial leaf node; perform LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and count the number of leaf node decompositions; use the leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the initial node admittance large matrix in-situ to generate diagonal block solution data; when the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, use the next leaf node corresponding to the initial leaf node as the new initial leaf node, increment the number of leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the initial leaf node and storing it in-situ to generate leaf node decomposition data and count the number of leaf node decompositions; when the number of leaf node decompositions is equal to the number of leaf nodes, update the initial node admittance large matrix using the diagonal block solution data at the current moment to obtain an intermediate node admittance large matrix; perform non-leaf node decomposition on the intermediate node admittance large matrix based on the non-leaf node sequence to obtain the target node admittance large matrix; Performing low-rank solution on the power system network equation based on the target nodal admittance matrix to generate solution data corresponding to the power system; the specific steps include: performing low-rank solution on the power system network equation based on the target nodal admittance matrix to generate solution data corresponding to the power system; when the nodal admittance matrix undergoes low-rank update, using multiple nodes corresponding to the updated regional data to construct an update path; performing leaf node decomposition on the diagonal block matrix corresponding to the update path based on the leaf node admittance matrix data corresponding to the target nodal admittance matrix to generate a leaf node admittance matrix; performing non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain a target path nodal admittance matrix; taking the target path nodal admittance matrix as the new target nodal admittance matrix, and jumping to execute the step of performing low-rank solution on the power system network equation based on the target nodal admittance matrix to generate solution data corresponding to the power system.

2. The method for solving the low-rank update of the power system network equation according to claim 1, characterized in that The step of performing non-leaf node decomposition on the intermediate nodal admittance matrix based on the non-leaf node sequence to obtain a target nodal admittance matrix includes: Taking the first non-leaf node in the non-leaf node sequence as the initial non-leaf node; Performing LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and counting the non-leaf node decomposition times; Using the non-leaf node decomposition data to perform in-situ solution on the first preset correction equation corresponding to the intermediate nodal admittance matrix to generate a first intermediate variable; Calculating the product between the first initial intermediate variable and the sub-node matrix corresponding to the intermediate nodal admittance matrix to generate a first variable matrix; Subtracting the first variable matrix from the intermediate nodal admittance matrix to generate a non-leaf node admittance matrix; When the non-leaf node decomposition times is less than the number of non-leaf nodes in the non-leaf node sequence, taking the next non-leaf node corresponding to the initial non-leaf node as the new initial non-leaf node, incrementing the non-leaf node decomposition times by 1, and jumping to execute the step of performing LU decomposition on the correction matrix corresponding to the initial non-leaf node to generate non-leaf node decomposition data and counting the non-leaf node decomposition times; When the non-leaf node decomposition times is equal to the number of non-leaf nodes, using the non-leaf node admittance matrix at the current moment as the target nodal admittance matrix.

3. The method for solving the low-rank update of the power system network equation according to claim 1, wherein The step of performing low-rank solution on the power system network equation based on the target nodal admittance matrix to generate solution data corresponding to the power system includes: Initializing the parameters to be solved in the linear equation system corresponding to the power system network equation with the constant term of the linear equation system to generate initial parameters to be solved; Performing traversal in-situ solution on the diagonal block solution equations of each leaf node to be solved corresponding to the initial parameters to be solved using the leaf node decomposition data set corresponding to the target nodal admittance matrix to generate leaf node solution data; Sorting each non-leaf node to be solved corresponding to the initial parameters to be solved in the order from bottom to top to generate a sequence of non-node to be solved; Take the first unsolved non-node in the to-be-solved non-node sequence as the initial to-be-solved non-node; Use the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data to solve the second preset correction equation corresponding to the to-be-solved non-node, generate the second intermediate variable and count the number of solution times; Calculate the product between the second intermediate variable and the sub-node matrix corresponding to the target node admittance matrix to generate a second variable matrix; Calculate the difference between the leaf node solution data and the second variable matrix to generate the node solution data corresponding to the initial to-be-solved non-node; When the number of solution times is less than the number of to-be-solved non-nodes in the to-be-solved non-node sequence, perform the step of using the non-leaf node decomposition data set corresponding to the target node admittance matrix and the leaf node solution data to solve the second preset correction equation corresponding to the initial to-be-solved non-node, generate the second intermediate variable and count the number of solution times; When the number of solution times is equal to the number of to-be-solved non-nodes, use all the node solution data at the current moment to construct the solution data corresponding to the power system.

4. The method for solving the low-rank update of the power system network equation according to claim 1, characterized in that, The step of performing leaf node decomposition on the diagonal block matrix corresponding to the update path based on the leaf node admittance matrix data corresponding to the target node admittance matrix to generate the leaf node admittance matrix includes: Number the leaf nodes and non-leaf nodes of the update path in the order from bottom to top to generate a path leaf node sequence and a path non-leaf node sequence; Take the first path leaf node in the path leaf node sequence as the initial path leaf node; Perform LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and store it in-place, generate path leaf node decomposition data and count the number of path leaf node decompositions; Use the path leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the leaf node admittance matrix data corresponding to the target node admittance matrix in-place to generate path diagonal block solution data; When the number of path leaf node decompositions is less than the number of path leaf nodes in the path leaf node sequence, take the next path leaf node corresponding to the initial path leaf node as the new initial path leaf node, increment the number of path leaf node decompositions by 1, and jump to execute the step of performing LU decomposition on the diagonal block matrix corresponding to the initial path leaf node and storing it in-place, generating path leaf node decomposition data and counting the number of path leaf node decompositions; When the number of path leaf node decompositions is equal to the number of path leaf nodes, use the path diagonal block solution data at the current moment to update the corresponding leaf node admittance matrix in the leaf node admittance matrix data to obtain the leaf node admittance matrix.

5. The method for solving the low-rank update of the power system network equation according to claim 4, characterized in that, The step of performing non-leaf node decomposition on the leaf node admittance matrix based on the path leaf node sequence to obtain the target path node admittance matrix includes: Take the first path non-leaf node in the path non-leaf node sequence as the initial path non-leaf node; Perform LU decomposition on the correction matrix corresponding to the initial path non-leaf node to generate path non-leaf node decomposition data and count the number of path non-leaf node decompositions; Using the decomposed data of the path non-leaf nodes to solve the first preset correction equation corresponding to the admittance matrix of the leaf nodes in-situ, generating initial path variables; Calculating the product between the initial path variables and the sub-node matrix corresponding to the admittance matrix of the leaf nodes, generating a path variable matrix; Subtracting the path variable matrix from the admittance matrix of the leaf nodes, generating a path non-leaf node admittance matrix; When the number of path non-leaf node decompositions is less than the number of path non-leaf nodes in the path non-leaf node sequence, taking the next path non-leaf node corresponding to the initial path non-leaf node as the new initial path non-leaf node, incrementing the number of path non-leaf node decompositions by 1, and jumping to execute the step of performing LU decomposition on the correction matrix corresponding to the initial path non-leaf node, generating decomposed data of the path non-leaf nodes and counting the number of path non-leaf node decompositions; When the number of path non-leaf node decompositions is equal to the number of path non-leaf nodes, using the path non-leaf node admittance matrix at the current moment as the target path node admittance matrix.

6. A low-rank update solution system for power system network equations, characterized in that Including: A power system network equation generation module, configured to obtain node operation data of the power system, and construct a power system network equation by using the node operation data, generating a power system network equation; A left low-rank basis matrix construction module, configured to perform hierarchical non-diagonal block low-rank decomposition on the node admittance matrix in the power system network equation, constructing a left low-rank basis matrix; The specific steps include: performing non-diagonal block partitioning on the coefficient matrix corresponding to the node admittance matrix in the power system network equation, generating a first initial coefficient block matrix; multiplying both sides of the first initial coefficient block matrix by the inverse matrix corresponding to the diagonal block matrix in the first initial coefficient block matrix, generating an initial update matrix; updating the initial update matrix by using the Woodbury matrix identity, generating a target update matrix; performing subscript conversion on the target update matrix, generating a first target coefficient block matrix; performing non-diagonal block partitioning on the first target coefficient block matrix, generating a second coefficient block matrix; using the first target coefficient block matrix to correct the parameters of the equations corresponding to the second coefficient block matrix, generating a low-rank basis equation set; constructing all left low-rank basis matrices in the low-rank basis equation set, generating a left low-rank basis matrix; A target nodal admittance large matrix construction module, which is used to decompose the nodal admittance matrix based on the left low-rank basis large matrix to construct a target nodal admittance large matrix; the specific steps include: initializing the nodal admittance matrix with the left low-rank basis large matrix to generate an initial nodal admittance large matrix; numbering the leaf nodes and non-leaf nodes of the tree structure corresponding to the initial nodal admittance large matrix in the order from bottom to top respectively to generate a leaf node sequence and a non-leaf node sequence; taking the first leaf node in the leaf node sequence as the initial leaf node; performing LU decomposition on the diagonal block matrix corresponding to the initial leaf node to generate leaf node decomposition data and counting the number of leaf node decompositions; using the leaf node decomposition data to solve the diagonal block decomposition equation corresponding to the initial nodal admittance large matrix in-place to generate diagonal block solution data; when the number of leaf node decompositions is less than the number of leaf nodes in the leaf node sequence, taking the next leaf node corresponding to the initial leaf node as the new initial leaf node, adding 1 to the number of leaf node decompositions, and jumping to execute the step of performing LU decomposition on the initial leaf node and storing it in-place to generate leaf node decomposition data and counting the number of leaf node decompositions; when the number of leaf node decompositions is equal to the number of leaf nodes, updating the initial nodal admittance large matrix with the diagonal block solution data at the current moment to obtain an intermediate nodal admittance large matrix; performing non-leaf node decomposition on the intermediate nodal admittance large matrix based on the non-leaf node sequence to obtain a target nodal admittance large matrix; A solution data generation module, which is used to perform low-rank solution on the power system network equation based on the target nodal admittance large matrix to generate solution data corresponding to the power system; the specific steps include: performing low-rank solution on the power system network equation based on the target nodal admittance large matrix to generate solution data corresponding to the power system; when the nodal admittance matrix undergoes low-rank update, using multiple nodes corresponding to the updated regional data to construct an update path; performing leaf node decomposition on the diagonal block matrix corresponding to the update path based on the leaf node admittance large matrix data corresponding to the target nodal admittance large matrix to generate a leaf node admittance large matrix; performing non-leaf node decomposition on the leaf node admittance large matrix based on the path leaf node sequence to obtain a target path nodal admittance large matrix; taking the target path nodal admittance large matrix as the new target nodal admittance large matrix, and jumping to execute the step of performing low-rank solution on the power system network equation based on the target nodal admittance large matrix to generate solution data corresponding to the power system.

7. An electronic device, characterized in that, It includes a memory and a processor, and a computer program is stored in the memory. When the computer program is executed by the processor, the processor executes the steps of the power system network equation low-rank update solution method according to any one of claims 1 to 5.

Images