## 2 Fundamentals
### LU Decomposition Methods  
In the following, we outline the main concepts behind the considered LU decomposition methods. This serves as a basis for understanding how the partial refactorisation approach is integrated into NICSLU and highlights key differences with respect to the methods SuperLU and KLU, against which we benchmark the proposed method. In this paper, we distinguish between four main steps of the considered LU decomposition methods:  
1. Preprocessing: Preprocessing involves steps for the scaling and ordering of the matrix. This improves the numerical properties of the matrix and the performance of the LU decomposition by reducing the _fill-in_ (i.e., additional nonzero entries arising during the factorisation). 2. Factorisation: The factorisation step performs the actual decomposition of the original matrix into its corresponding \(\mathbf{L}\) and \(\mathbf{U}\) matrices. 3. Refactorisation: Refactorisation implies the simplification of the factorisation procedure if subsequent LU decompositions are computed. Optionally, it may involve the use of a partial refactorisation approach. 4. Solution: The computation of the solution vector is commonly based on a forward/backward substitution approach that makes use of the decomposed \(\mathbf{LU}\) matrix. SuperLU [4; 15; 27] is a sparse LU decomposition method based on a matrix characteristic named supernodes. The aforementioned general steps are implemented by SuperLU as follows:  
Figure 2: MNA based solution procedure for real-time simulation with a varying system matrix, with \(k\) as the discrete-time index and \(j\) as the iteration index of any fixed-point algorithm. Preprocessing: Optionally, SuperLU can determine diagonal scaling matrices for stability. It then proceeds to calculate the column ordering of the input matrix, which is determined to preserve sparsity (fill-in reduction). 2. Factorisation: To compute a numeric factorisation with partial pivoting, the method aims to exploit the supernodal structure of the input matrices and calculates the LU decomposition using the scaling (optionally) and fill-in ordering matrices. 3. Solution: To solve for the RHS, SuperLU uses forward/backward substitution. KLU [16] is also designed to operate on sparse matrices, but it does not rely on supernodes. In contrast, KLU performs additional preordering steps to yield a better-suited matrix for factorisation. The steps of KLU encompass the following:  
1. Preprocessing: KLU utilises the block triangular form (BTF) transformation, which ensures a zero-free diagonal and orders the matrix to a form in which the resulting matrix has smaller block matrices on its diagonal and zero entries below it. Then, the Approximate Minimum Degree Ordering Algorithm (AMD) is performed for fill-in reduction on each of these blocks. 2. Factorisation: In the numerical procedure, KLU factorises each block independently with partial pivoting using the Gilbert-Peierls algorithm [28]. 3. Refactorisation: If one needs another factorisation of a matrix with different numerical values but the same symbolic pattern, KLU can perform factorisation without recomputing the fill-in reduction or partial pivoting. 4. Solution: KLU successively solves for the unknown vector using forward/backward substitution starting at the lowest block. The main focus of NICSLU [14; 29] is on the parallelisation of sparse LU factorisations. This is conducted by analysing column dependency in the preprocessing step. Furthermore, NICSLU implements the main steps as follows:  
1. Preprocessing: NICSLU performs MC64 scaling, which places large values on the diagonal and enhances numerical stability. As opposed to KLU, AMD is then used on the entire matrix. As a final preprocessing step, static symbolic factorisation is performed to determine parallelisability. The decision of whether to use parallelisation is up to the user. 2. Factorisation: In contrast to KLU, factorisation is performed on the entire matrix.