A method of constructing a low error floor QC-LDPC code with flat floor

Abstract

The application discloses a method for constructing QC-LDPC code with low error floor. The method comprises the following steps: firstly, selecting random number filling matrix elements to generate an index matrix of QC-LDPC code according to an original graph, and performing girth optimization on the index matrix to minimize the number of loops with a specified degree in a Tanner graph corresponding to the matrix; and then, searching for harmful trap sets in the matrix by column through decoding simulation, and eliminating the harmful trap sets by changing the shift value of the matrix elements until all harmful trap sets with a specified size are eliminated. The method has the following advantages: firstly, the method has no special requirements on the parameters of the QC-LDPC code matrix, and supports the design of flexible code rate. Secondly, the method searches for and eliminates the harmful trap sets in the QC-LDPC code, and takes into account the optimization of the minimum girth of the code, so that the constructed QC-LDPC code has good error floor performance. The construction method disclosed by the application can generate QC-LDPC code with uncorrectable error rate lower than 10 ‑15 , and is suitable for occasions with high requirements on error correction performance, such as flash memories.

Description

Technical Field

[0001] This invention belongs to the field of coding technology in communications, and specifically a method for constructing a low-error flat-bottom QC-LDPC code. Background Technology

[0002] Low-density parity check codes (LDPCs) are a channel coding technique proposed by Galler in 1962 that approaches the Shannon limit. Quasi-cyclic low-density parity check codes (QC-LDPCs) are an important subset of LDPC codes, possessing advantages such as low encoding and decoding complexity and simple hardware implementation, and have been widely used in practical storage systems.

[0003] LDPC codes can be represented using a Tanner graph, which contains two types of nodes: variable nodes and check nodes. A variable node corresponds to a column of the check matrix, and a check node corresponds to a row. If the (i, j)th bit of the check matrix is ​​1, it indicates that an edge connects the j-th variable node and the ith check node. Starting from a node, there exists a path that passes through several unique edges and nodes before returning to the original node. The edges and nodes along this path form a cycle in the Tanner graph. The number of nodes in the cycle is equal to the circumference g (g = 4, 6...). In this patent, this is represented by a parameter... It is used to characterize the circumference of the ring.

[0004] LDPC codes suffer from an error floor problem under the belief propagation decoding algorithm. This means that in the low bit error rate region, the slope of their performance curve decreases significantly as channel quality improves. This is mainly due to special subgraph structures in the Tanner graph, called trap sets. A trap set is typically represented by (a, b), where a is the number of variable nodes in the trap set, and b is the number of nodes with incomplete parity (connected to an odd number of variable nodes). In flash memory error correction, the LDPC codes used are generally required to achieve an uncorrectable bit error rate (UBER) of 10. -15 At or below this level, there will be no incorrect flat bottom.

[0005] LDPC code construction methods can be divided into structured construction methods and random construction methods. Structured construction methods mainly utilize mathematical theories, such as finite field theory, to design matrices to eliminate short cycles and improve performance. However, this method imposes many restrictions on matrix parameters and cannot flexibly meet various needs in practical applications. Random construction methods, on the other hand, can design LDPC codes of arbitrary rates and sizes, offering greater flexibility.

[0006] This invention proposes a random construction method, specifically a method for constructing QC-LDPC codes with low error flatness. This method optimizes the minimum matrice length and performs trap set search and elimination on the matrix, effectively improving the error flatness performance of the constructed QC-LDPC codes and making them suitable for practical flash memory applications. Summary of the Invention

[0007] Purpose of the invention: This invention addresses the application requirements of QC-LDPC codes in the field of flash memory error correction by proposing a random construction method. By searching and eliminating trap sets in the parity check matrix, the error flatness performance of the constructed QC-LDPC code can be reduced.

[0008] To achieve the above objectives, this invention discloses a random construction method for the exponent matrix based on QC-LDPC codes. The basic steps include constructing the exponent matrix based on the original model diagram and optimizing its circumference, and searching for and eliminating harmful trap sets in the exponent matrix.

[0009] The technical solution of the present invention is as follows:

[0010] Step 1: Construct an exponential matrix based on the original model diagram and optimize the circumference.

[0011] Step 1-1: Replace the matrix elements in the original model diagram that are 0 with -1, and replace the matrix elements in the original model diagram that are 1 with a random number from 0 to z-1. This results in an exponent matrix of a QC-LDPC code with an M×N submatrix of size z×z. Set the maximum number of traversals Iter_max_cycle, initialize the change counter changenumber = 0, and record the number of matrix elements in the exponent matrix that have changed relative to the previous search round.

[0012] Step 1-2: Traverse each non--1 element of the exponent matrix, replacing its shift value with p. p traverses from 0 to z-1. When the position is p, calculate the number of k≤k0+1 cycles ck (k0=2,3) formed by the corresponding variable node of that element. Determine p0 such that ck=ck_best (k=2,3,4), then select p0 as the shift value for that position in the exponent matrix. If p0 is different from the previous element, then changenumber+1. In this step, ck_best represents the optimal value of the number of cycles ck (k=2,3,4) corresponding to all possible shift values ​​p.

[0013] It is important to note that in this step, ck_best is the minimum value of all c2 for k=2, the minimum value of c3 among all p that satisfy c2=c2_best for k=3, and the minimum value of c4 among all p that satisfy c2=c2_best and c3=c3_best for k=4.

[0014] Steps 1-3: In each iteration, record the number of matrix elements that have changed compared to the previous iteration. Exit when all matrix elements are the same as in the previous iteration, or when the maximum number of iterations is reached. This yields the exponential matrix optimized for minimum girth.

[0015] Step 2: Search for and eliminate harmful trap sets in the exponential matrix.

[0016] Step 2-1: Input the exponential matrix after optimization of the trap set length. Set the parameters of the trap set (a, b) to be eliminated. When a ≤ amax and b ≤ bmax, the trap set is considered harmful and needs to be eliminated. Set the Gaussian white noise channel variance SIGMA and mean mu used when searching for the trap set, the number of times Ls is decoded for each simple ring during the search, the maximum number of iterations IterMax for one decoding, and the maximum length g of the simple rings in the base trap set (a simple ring is one in which there are no rings with a smaller degree). Set the maximum number of traversals Iter_max_ts.

[0017] Step 2-2: Initialize the change counter `change_number` to record the number of matrix elements that have changed since the last search round, and initialize `fail_number` to record the number of columns that failed in this search round. Starting from the leftmost column of the exponent matrix, iterate through the columns marked as failed (in the first round of iteration, all columns are marked as failed by default). For each column j, iterate through each non--1 matrix element in row i.

[0018] Steps 2-3: For a non--1 matrix element located at (i, j) in the exponent matrix, replace its shift value with p, where 0 ≤ p ≤ z-1. Calculate the number of k ≤ k0+1 cycles formed by the corresponding variable nodes of this matrix element. Determine p such that ck = ck_best (ck is the number of k cycles, k = k0). Sort all p values ​​that satisfy this constraint in ascending order based on the number of corresponding k0+1 cycles.

[0019] Step 2-4: Following the order in Step 2-3, traverse all p values ​​that satisfy the number of k0+1 rings ck≤ck_best+10 (k=k0+1), replace the matrix element with p, and perform a trap set search on the j-th column.

[0020] Steps 2-5: Search for the trap set formed by the variable nodes corresponding to this column, and initialize failflag = 0. Search for simple rings formed by the variable nodes corresponding to this column. For each simple ring, perform Ls decoding simulations. During the simulation, noise is added only to the variable nodes on the simple rings. Collect the set of erroneous variable nodes that failed to decode, which is considered the trap set. Once a harmful trap set is collected during the simulation, set failflag = 1.

[0021] Steps 2-6: When the matrix element (i, j) is p, if no trap set of a≤maxa, b≤maxb is found in column j, then modify the matrix element to p, marking the column search as successful. If p is different from the original matrix element elem_old at that position, then change_number +1. The next step is to search column j+1 (j+1 < N).

[0022] Step 2-7: If all possible values ​​of p would lead to a trap set where a≤maxa, b≤maxb can be found in column j, then the matrix element is set to p0 such that ck = ck_best (k = k0 + 1). If p0 is different from the original matrix element elerm_old at that position, then change_number + 1. The next step is to search for the next non--1 matrix element in that column.

[0023] Step 2-8: If no matching p can be found in any matrix element of this column, mark the column search as failed and increment fail_number by 1. The next step is to search column j+1 (j+1 < N).

[0024] Steps 2-9: Exit the traversal when the number of failed columns fails_number = 0, the number of changed matrix elements changes_number = 0, or the maximum number of traversals Iter_max_ts is reached; otherwise, proceed to the next round of traversal. In each round of traversal, only the columns that failed to be searched are searched.

[0025] Step 2-10: Output the exponent matrix after trap set search and elimination, which is the exponent matrix of the QC-LDPC code with low error flat bottom after optimizing the girth and eliminating harmful trap sets.

[0026] Beneficial effects:

[0027] 1. The method provided by this invention has no special requirements for the matrix parameters of QC-LDPC codes and can support flexible code rate design.

[0028] 2. The method provided by this invention searches for and eliminates harmful trap sets in QC-LDPC codes, while also optimizing the minimum code length, and the constructed QC-LDPC codes have good error flattening performance. Attached Figure Description

[0029] Figure 1 This is a flowchart illustrating the circumference optimization algorithm proposed in this invention;

[0030] Figure 2 This is a flowchart illustrating the algorithm for searching and eliminating trap sets proposed in this invention;

[0031] Figure 3 This is a schematic diagram of the exponent matrix according to an embodiment of the present invention;

[0032] Figure 4 This is a performance curve diagram of an embodiment of the present invention; Detailed Implementation

[0033] The present invention will be further illustrated below with reference to the accompanying drawings and specific embodiments. It should be understood that these embodiments are for illustrative purposes only and are not intended to limit the scope of the invention. After reading this invention, modifications of various equivalent forms of the invention by those skilled in the art fall within the scope defined by the appended claims. The following describes the construction process of the exponent matrix of a QC-LDPC code, with exponent matrix parameters N = 286, M = 28, submatrix size 128 × 128 (z = 128), column weight 5, and code rate 0.902.

[0034] In this embodiment, step 1 includes:

[0035] Step 1-1: Replace the matrix elements in the original model diagram that are 0 with -1, and replace the matrix elements in the original model diagram that are 1 with a random number between 0 and 127. This results in an exponent matrix of the QC-LDPC code with a submatrix of size 128 and a submatrix of size 28×286.

[0036] Steps 1-2: Traverse each non--1 element of the exponent matrix, and denote p as the shift value at that position, where 0 ≤ p ≤ 127. When the position is p, calculate the number of four-rings and six-rings formed by the corresponding variable nodes of that element. Let c4_best be the minimum number of four-rings among all p. When the number of four-rings of a certain p0 is equal to c4_best, the number of six-rings corresponding to it is also the minimum among the ps that satisfy this constraint. Then, select p0 as the shift value for that position in the exponent matrix.

[0037] It is important to note that in this step, the calculation of the number of four rings (k=2) formed by a variable node corresponding to a matrix element is performed as follows: Let the position of the matrix element be (i, j). Initialize an array `cyclenum` of size `z`. The p-th position of this array records the number of four rings formed when the matrix element is p. With the row index fixed at `i`, traverse the exponent matrix column by column. Let `e2` be the value of the matrix element at (i1, j1), where `i1` = `i`, `j1!` = `j`, and `e2!` = `-1`. With the column index fixed at `j1`, traverse the exponent matrix row by row. Let `e3` be the value of the matrix element at (i2, j2), where `i2!` = `i1`, `j2` = `j1`, and `e3!` = `-1`. Let `e4` be the value of the matrix element at (i3, j3), where `i3` = `i2`, `j3` = `j`, and `e4!` = `-1`. Then, calculate `e1` = (e2 - e3 + e4 + z) % z. Increment the value of the e1st element of the array by 1.

[0038] It is important to note that in this step, the calculation of the number of six rings (k=3) formed by a variable node corresponding to a matrix element is performed as follows: Let the position of the matrix element be (i, j). Initialize an array `cyclenum` of size `z`. The p-th position of this array records the number of six rings formed when the matrix element is p. With a fixed row index `i`, traverse the exponent matrix column by column. Let `e2` be the value of the matrix element at position (i1, j1), where `i1` = `i`, `j1!` = `j`, and `e2!` = -1. With a fixed column index `j1`, traverse the exponent matrix row by row. Let `e3` be the value of the matrix element at position (i2, j2), where `i2!` = `i1`, `j2` = `j1`, and `e3!` = -1. With a fixed row index `i2`, traverse the exponent matrix column by column. Let `e4` be the value of the matrix element at position (i3, j3), where `i3` = `i2`, `j3!` = `j2`, ​​`j3!` = `j`, and `e4!` = -1. With a fixed column index j3, traverse the index matrix row by row. Let e5 be the value of the matrix element at (i4, j4), where i4! = i3, i4! = i1, j4 = j3, and e5! = -1. Let e6 be the value of the matrix element at (i5, j5), where i5 = i4, j5 = j, and e6! = -1. Then, calculate e1 = (e2 - e3 + e4 - e5 + e6 + z + z) % z. Increment the value of the e1-th element of the array by 1.

[0039] It is important to note that in this step, the calculation of the number of eight rings (k=4) formed by a variable node corresponding to a matrix element is performed as follows: Let the position of the matrix element be (i, j). Initialize an array `cyclenum` of size `z`. The p-th position of this array records the number of eight rings formed when the matrix element is p. With a fixed row index `i`, traverse the exponent matrix column by column. Let `e2` be the value of the matrix element at position (i1, j1), where `i1` = `i`, `j1!` = `j`, and `e2!` = `-1`. With a fixed column index `j1`, traverse the exponent matrix row by row. Let `e3` be the value of the matrix element at position (i2, j2), where `i2!` = `i1`, `j2` = `j1`, and `e3!` = `-1`. With a fixed row index `i2`, traverse the exponent matrix column by column. Let `e4` be the value of the matrix element at position (i3, j3), where `i3` = `i2`, `j3!` = `j2`, ​​and `e4!` = `-1`. With a fixed column index j3, traverse the exponent matrix row by row. Let e5 be the value of the matrix element at (i4, j4), where i4! = i3, j4 = j3, and e5! = -1. With a fixed row index i4, traverse the exponent matrix column by column. Let e6 be the value of the matrix element at (i5, j5), where i5 = i4, j5! = j4, and e6! = -1. With a fixed column index j5, traverse the exponent matrix row by row. Let e7 be the value of the matrix element at (i6, j6), where i6! = i5, j6 = j5, and e7! = -1. Let e8 be the value of the matrix element at (i7, j7), where i7 = i6, j7 = j, and e8! = -1. Then, calculate e1 = (e2 - e3 + e4 - e5 + e6 - e7 + e8 + z + z + z) % z. Increment the value of the e1th element of the array by 1.

[0040] Steps 1-3: Set the maximum number of iterations (Iter_max_cycle = 40). In each iteration, record the number of matrix elements whose shift values ​​changed (changenumber). Exit when all matrix elements are the same as in the previous iteration, or when the maximum number of iterations is reached. This yields the exponential matrix optimized for minimum girth. In this embodiment, the exponential matrix does not contain a fourth ring, i.e., c4best = 0.

[0041] In this embodiment, step 2 includes...

[0042] Step 2-1: Input the exponent matrix after length optimization. Set the parameters of the trap set (a, b) to be eliminated. When a ≤ 8 and b ≤ 8, this trap set is the one to be eliminated. Set the parameters SIGMA = 0.42, mu = -100.0, Ls = 15, IterMax = 20, and the maximum degree g of the simple cycle in the base trap set = 6. Set the maximum number of traversals Iter_max_ts = 40.

[0043] Step 2-2: Initialize the change counter `change_number` to record the number of matrix elements that have changed since the last search round, and initialize `fail_number` to record the number of columns that failed in this search round. Starting from the leftmost column of the exponent matrix, iterate through the columns marked as failed (in the first round of iteration, all columns are marked as failed by default). For each column j, iterate through each non--1 matrix element in row i.

[0044] Steps 2-3: For a non--1 matrix element located at (i, j) in the exponent matrix, replace its shift value with p, where 0 ≤ p ≤ 127. Calculate the number of four-rings and six-rings formed by the variable nodes corresponding to this matrix element. The minimum value of the number of four-rings c4 among all p is c4best, which is 0. Sort all p according to the number of six-rings in ascending order, and denote c6_best as the minimum value of the number of six-rings c6 among all p that satisfies the condition c4 = c4best = 0.

[0045] Steps 2-4: For the p-values ​​at this position that satisfy c4 = c4_best = 0, traverse them by sorting them in ascending order of the number of six rings, and the corresponding number of six rings c6 ≤ c6_best + 10. Perform a trap set search on the j-th column.

[0046] Steps 2-5: Use decoding simulation to search for the trap set formed by the variable nodes corresponding to the j-th column. Initialize failflag = 0, and the input is the simple cycle k formed by the variable nodes corresponding to the j-th column, k≤3. If a trap set within a≤8 and b≤8 is found during the search, then failflag = 1.

[0047] It is important to note that the specific implementation of a trap set search is as follows: Ts is the set of trap sets found, initialized to the simple ring Tk formed by the j-th column, where k ≤ g / 2. For each simple ring in the set Tk, Ls = 15 decoding simulations are performed. The specific implementation of a decoding simulation is as follows: all codewords are initialized to 0 and BPSK modulation is performed. Gaussian noise with a mean of mu = -100.0 and a variance of SIGMA = 0.42 is added only to the variable nodes contained in the simple ring. A decoding simulation is performed, and the maximum number of iterations in a decoding is set to IterMax = 20. If decoding fails, the variable nodes that malfunctioned are returned, and the set of variable nodes is classified as a trap set to determine the number of variable nodes a and the number of nodes with insufficient parity b. Once a trap set with a ≤ 8 and b ≤ 8 is found during the search process, the search for that p value is immediately terminated.

[0048] It should be noted that the decoding simulation algorithm is a floating-point minimum sum decoding algorithm based on column grouping.

[0049] It is important to note that the search for the simple cycle k formed by the variable node in column j in this step is performed as follows: The first variable node in column j of the exponent matrix is ​​selected as the starting point to avoid repeated searches of isomorphic structures in the QC-LDPC matrix caused by cyclic shifts. Also note that the path length here refers to the sum of the number of variable nodes and check nodes along the path.

[0050] When k=2, the degree of the simple cycle g=4. Initialize set T2, which is the set of simple cycles with degree g=4 formed by the variable node. Starting from any two distinct check nodes of the variable node, find two paths of length 1, where each path contains a variable node that is different from the starting variable node. If any two paths terminate at the same variable node, then this variable node and the initial variable node are considered as a sequence of simple cycles. If the variable node is not in T2, add it to T2.

[0051] For k=3, the degree of the simple cycle g=6. Initialize set T3, which is the set of simple cycles with degree g=6 formed by the variable node. Starting from any two distinct check nodes of the variable node, find two paths of length 2, where each path contains a variable node and a check node, and the variable node is different from the starting variable node, and the check node is different from the starting check node. If any two paths terminate at the same check node, and the two variable nodes are distinct and do not share any other check nodes except for the check node of the endpoint, then these two variable nodes and the initial variable node form a simple cycle sequence. If they are not in T3, add them to T3.

[0052] For k=4, the degree of the simple cycle g=8. Initialize set T4, which is the set of simple cycles with degree g=8 formed by the variable node. Starting from any two distinct check nodes of the variable node, find two paths of length 3, where each path contains two variable nodes and one check node, and the two variable nodes are different from the starting variable node, and the check node is different from the starting check node. If any two paths terminate at the same variable node, and the two paths do not share any other nodes except the ending variable node, then these three variable nodes and the initial variable node form a simple cycle sequence. If it is not in T4, add it to T4.

[0053] Steps 2-6: When the matrix element (i, j) is p, if no trap set of a≤8, b≤8 is found in column j, change the matrix element to p and mark the column search as successful. If p is different from the original matrix element elem_old at that position, increment change_number by 1. The next step is to search column j+1 (j+1 < 286).

[0054] Step 2-7: If all possible values ​​of p lead to a trap set where a≤8, b≤8 can be found from column j, then the matrix element is set to p0 such that c4=c4_best=0, and its c6 is the smallest among the p values ​​that satisfy this constraint. If p0 is different from the original matrix element elem_old at this position, then change_number+1. The next step is to search for the next non--1 matrix element in this column.

[0055] Step 2-8: If no matching p can be found in any matrix element of this column, mark the column search as failed and increment fail_number by 1. The next step is to search column (j+1) (j+1 < 128).

[0056] Steps 2-9: Exit the traversal when the number of failed columns (fail_number) = 0, the number of changed matrix elements (change_number) = 0, or the maximum number of traversals (40) is reached; otherwise, proceed to the next round of traversal. In each round of traversal, only the columns that failed to be searched are searched.

[0057] The matrix was constructed using a two-round search. In the first round, the number of failed columns was 4, and the number of changed matrix elements was 66. In the second round, the number of failed columns was 0, and the number of changed matrix elements was 1.

[0058] Step 2-10: Output the exponent matrix after trap set search and elimination. Figure 3 A schematic diagram of the final exponent matrix is ​​shown.

[0059] To verify that the QC-LDPC code constructed in this invention has good error-flattening performance, FPGA simulation was performed in this embodiment. Specifically, the decoding simulation was conducted under a 2-bit quantized Gaussian white noise channel using a column-grouped minimum sum decoding algorithm, with a maximum of 50 iterations during decoding.

[0060] like Figure 4 The graph shown is the performance curve of this embodiment. The vertical axis represents the uncorrectable error rate (UBER), and the horizontal axis represents the signal-to-noise ratio (SNR). The last sampling point indicates that after 80 hours of simulation on the FPGA, no error frames were obtained, confirming that the error peak position is below UBER = 10. -15 This demonstrates that the QC-LDPC code constructed in this invention exhibits excellent error-flattening performance, making it suitable for practical flash memory applications.

Claims

1. A method of constructing a QC-LDPC code with low error floor, characterized by, The method comprises the following steps: Step one: according to the original mold map structure index matrix and girth optimization, on the basis of the original mold map MxN sub-matrix size is z index matrix, M is the row number of index matrix, N is the column number of index matrix, replace the matrix element of 0 on the original mold map with-1, replace the matrix element of 1 on the original mold map with a random integer p between 0 and z-1, get the index matrix, traverse each matrix element, calculate the number of short loops formed by the corresponding variable node, determine the optimal shift value p0 so that the k loop formed by it is optimal, k=2, 3 or 4, g is from a node in the original mold map, after returning to the node along the path through a number of non-repeating edges and nodes, the number of nodes contained in the path; finally get the girth optimized index matrix; Step two: on the basis of the matrix obtained in step one, search and eliminate a certain range of harmful trap sets in the Tanner graph, use the result of girth optimization to traverse each non-1 matrix element in the exponent matrix, search the short loop formed by the variable nodes corresponding to the column of the matrix element, further search the harmful trap set within the specified range formed by the variable nodes, change the shift value of the matrix element to eliminate the harmful trap set, and repeatedly traverse the entire matrix until the maximum traversal number is reached or no harmful trap set is searched from any variable node corresponding to a column.

2. The method of constructing a QC-LDPC code with low error floor according to claim 1, wherein, In step one, when performing girth optimization, each non-1 matrix element in the exponent matrix is traversed in turn, the shift value of the matrix element is changed to p under the condition that the shift values of other matrix elements are fixed, p is traversed from 0 to z-1, the number of short loops formed by the variable nodes corresponding to the matrix element is calculated under the current shift value, the optimal shift value is selected, and the matrix is repeatedly traversed until girth optimization cannot be performed or the maximum traversal number is reached.

3. The method of constructing a QC-LDPC code with low error floor according to claim 1, wherein, In step one, when calculating the number of short loops formed by the variable nodes corresponding to a matrix element, the value of the shift value of the matrix element is solved according to the values of other matrix elements in the exponent matrix which form a loop structure with the matrix element and the formula for the condition of the loop in the QC-LDPC matrix, and the number of loop structures formed by the matrix element when p is taken is calculated.

4. The method of constructing a QC-LDPC code with low error floor according to claim 1, wherein, In the step one, the optimal shift value p0 is determined, p0 satisfies the condition that the number of k-1 is optimal, k=3 or 4, The number of its ring k is the least; the four ring, namely k=2, the optimal p is defined as the p which makes the number of the four ring participated by the p the least among all the p of the matrix element; the six ring, namely k=3, the optimal p is defined as the p which makes the number of the six ring participated by the p the least among all the p of the four ring of the matrix element; the eight ring, namely k=4, the optimal p is defined as the p which makes the number of the eight ring participated by the p the least among all the p of the six ring of the matrix element; and so on.

5. The method of constructing a QC-LDPC code with low error floor according to claim 1, wherein, In step two, when using the result of girth optimization, each non-1 matrix element in the exponent matrix is traversed by column, for each matrix element, the shift value with the optimal k0 loop property is selected, the number of k0+1 loops is traversed from small to large, and it is ensured that the number of k0+1 loops corresponding to the matrix element does not exceed 10 compared with the optimal k0+1 loop number, k0=2 or 3.

6. The method of constructing a QC-LDPC code with low error floor as in claim 1, wherein, In step two, when searching the short loop formed by the variable nodes corresponding to the column of the matrix element, the first variable node among the z variable nodes corresponding to the column of the matrix element in the exponent matrix is taken as the starting point for the search.

7. The method of constructing a QC-LDPC code with low error floor as in claim 1, wherein, In step two, when searching a short loop by path extension, according to the parameter k of the short loop, k=2, 3 or 4, a path of a specified length k-1 is searched from any two check nodes of the variable node, the starting check node is not included in the path length calculation, so that there are k-1 nodes on the path, and the two paths end at the same node, and except for the terminal node, they do not share any other nodes.

8. The method of constructing a QC-LDPC code with low error floor as in claim 1, wherein, In step two, when searching a harmful trap set within a specified range formed by the variable nodes corresponding to a matrix element by decoding simulation, the simple loop within the loop of k≤g / 2 in which the variable nodes corresponding to the column of the matrix element are located is taken as the input, the simple loop refers to the loop in which there is no loop with a smaller degree, when k=2, 3 or 4, for each simple loop, decoding simulation is performed by adding noise to the variable nodes thereon, the error variable node combination involved in decoding failure is regarded as a trap set, and if the size of the harmful trap set is within the specified range, the search for the current shift value is stopped.

9. The method of constructing a QC-LDPC code with low error floor as in claim 1, wherein, In the step of changing the shift value of the matrix element in the second step, for each matrix element, if the current shift value makes the column search fail to find a harmful trap set satisfying that the number of variable nodes a is not more than the maximum number of variable nodes amax allowed in the trap set and the number of odd check nodes b is not more than the maximum number of odd check nodes bmax allowed in the trap set, then the matrix element is changed to the current shift value, and the search of the next column is performed, if the number of k0+1 loops of the current shift value is more than 10 more than the minimum number of k0+1 loops, and a harmful trap set in the specified range can still be searched, then the shift value with the minimum number of k0+1 loops is selected as the shift value of the matrix element, where k0=2 or 3, and the search of the next matrix element in the column is continued, until there is a shift value making the column search fail to find a harmful trap set or all non-1 matrix elements in the column are traversed.

Images