Method for constructing QC-LDPC code with low error flat bottom

Abstract

The invention discloses a method for constructing a QC-LDPC (Quasi-Cyclic Low-Density Parity-Check) code with a low error flat bottom. The method comprises the following steps of: firstly, selecting a random numerical value filling matrix element according to a protograph to generate an exponential matrix of the QC-LDPC code, and performing girth optimization on the exponential matrix to minimize the number of rings with specified degrees in a Tanner graph corresponding to the matrix; then, harmful trap sets in the matrix are searched according to columns in a decoding simulation mode, and the harmful trap sets are eliminated by changing displacement values of matrix elements until all the harmful trap sets with specified sizes are eliminated. The method has the beneficial effects that firstly, the method has no special requirements on QC-LDPC code matrix parameters and supports the design of a flexible code rate; secondly, the method searches and eliminates a harmful trap set in the QC-LDPC code, and gives consideration to optimization of the minimum girth of the code, and the constructed QC-LDPC code has good error flat bottom performance. According to the construction method provided by the invention, the QC-LDPC code of which the error rate which cannot be corrected is lower than 10-15 can be generated, and the construction method is suitable for occasions such as flash memories with high error correction performance requirements.

Description

Technical Field

[0001] The invention belongs to the field of coding technology in the field of communication, and in particular to a method for constructing a QC-LDPC code with a low error flat bottom. Background Art

[0002] Low Density Parity Check Codes (LDPC) is a channel coding technology close to the Shannon limit proposed by Galler in 1962. Quasi Cyclic Low Density Parity Check Codes (QC-LDPC) is an important subset of LDPC codes. It has the advantages of low coding complexity and simple hardware implementation, and has been widely used in actual storage systems.

[0003] LDPC codes can be represented by Tanner graphs. There are two types of nodes in the Tanner graph, variable nodes and check nodes. A variable node corresponds to a column of the check matrix, and a check node corresponds to a row of the check matrix. If the (i, j)th bit of the check matrix is ​​1, it means that an edge is connected between the jth variable node and the ith check node. Starting from a node, there is a path that returns to the node after passing through a number of non-repeating edges and nodes. The edges and nodes on this path form a ring in the Tanner graph. The number of nodes on the ring is the girth of the ring g (g = 4, 6...). In this patent, the parameter To represent the circumference of the ring.

[0004] LDPC codes have an error floor problem under the belief propagation decoding algorithm, that is, in the area of ​​lower bit error rate, when the channel quality improves to a certain level, the slope of its performance curve will decrease significantly. This is mainly due to the existence of some special subgraph structures in the Tanner graph, called trapping sets. A trapping set is generally represented by (a, b), where a is the number of variable nodes in the trapping set, and b is the number of incomplete check nodes (connected to an odd number of variable nodes) in the trapping set. In the field of flash memory error correction, the LDPC codes used are generally required to be able to achieve an uncorrectable bit error rate (UBER) of 10 -15 or lower, there will be no false flat bottoming.

[0005] The construction methods of LDPC codes can be divided into structured construction method and random construction method. The structured construction method mainly uses mathematical theories, such as finite field theory, to design matrices to eliminate short loops and improve performance. However, this method has many restrictions on matrix parameters and cannot flexibly meet various requirements in practical applications. The random construction rule can design LDPC codes of any code rate and size, and has greater flexibility.

[0006] The present invention proposes a random construction method, in particular a method for constructing a QC-LDPC code with a low error flat floor. The method optimizes the minimum girth of the matrix, searches and eliminates trap sets in the matrix, and can effectively improve the error flat floor performance of the constructed QC-LDPC code, making it suitable for actual flash memory applications. Summary of the invention

[0007] Purpose of the invention: Aiming at the application demand of QC-LDPC code in the field of flash memory error correction, the present invention proposes a random construction method, which can reduce the error floor performance of the constructed QC-LDPC code by searching and eliminating trap sets in the check matrix.

[0008] In order to achieve the above-mentioned purpose, the present invention discloses a random construction method based on a QC-LDPC code exponential matrix. The basic steps include constructing an exponential matrix according to an original model graph and optimizing the girth, searching for and eliminating harmful trap sets in the exponential matrix.

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

[0010] Step 1: Construct an index matrix based on the original model and optimize the girth.

[0011] Step 1-1: Replace the matrix elements with 0 in the original model with -1, and replace the matrix elements with 1 in the original model with random numbers from 0 to z-1. That is, an exponential matrix of the QC-LDPC code with a sub-matrix size of M×N and a size of z×z is obtained. Set the maximum number of traversals Iter_max_cycle, initialize the change counter changenumber=0, and record the number of matrix elements that have changed in the exponential matrix after this round of search compared with the previous round of search.

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

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

[0014] Step 1-3: In each round of traversal, the number of matrix elements that have changed in this round relative to the previous round is recorded. When all matrix elements are the same as in the previous round, or when the maximum number of traversals is reached, the process is exited. Thus, the exponential matrix with the minimum girth optimization is obtained.

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

[0016] Step 2-1: Input the exponential matrix after girth optimization, 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 to decode each simple ring during the search, the maximum number of iterations IterMax for one decoding, and the maximum girth g of the simple ring of the trap set as the basis (a simple ring means that there is no ring with a smaller degree in the ring). 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 after this round of search compared to the previous round, and initialize fail_number to record the number of columns that failed in this round of search. Starting from the leftmost column of the exponential matrix, traverse the columns marked as search failures (all columns are marked as search failures by default in the first round of traversal), and traverse each non-1 matrix element in each column j and row i in turn.

[0018] Step 2-3: For the non-1 matrix element at the index matrix (i, j), replace its shift value with p, 0≤p≤z-1, and calculate the number of k≤k0+1 rings formed by the variable nodes corresponding to the matrix element. Determine p so that ck=ck_best (ck is the number of k rings, k=k0). Sort all p that meet this constraint from small to large according to the number of corresponding k0+1 rings.

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

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

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

[0022] Step 2-7: If all ps in the range can lead to a trap set with a≤maxa, b≤maxb being searched from the jth column, then the matrix element p0 is selected so that ck=ck_best(k=k0+1). If p0 is different from the original matrix element elerm_old at this position, then change_number+1. The next step is to search for the next non-1 matrix element in this column.

[0023] Step 2-8: If all matrix elements in this column cannot find p that meets the conditions, then mark the search of this column as failed, fail_number + 1. Next, search the j+1 column (j+1<N).

[0024] Step 2-9: When the number of failed columns fail_number = 0 or the number of changed matrix elements change_number = 0 or the maximum number of traversals Iter_max_ts is reached, exit the traversal, 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 exponential matrix after trap set search and elimination, that is, the exponential matrix of the QC-LDPC code with low error flat floor after optimizing the girth and eliminating harmful trap sets is obtained.

[0026] Beneficial effects:

[0027] 1. The method provided by the present invention has no special requirements on the matrix parameters of the QC-LDPC code and can support the design of flexible code rates.

[0028] 2. The method provided by the present invention searches for and eliminates harmful trap sets in QC-LDPC codes, and takes into account the optimization of the minimum girth of the code. The constructed QC-LDPC code has good error floor performance. BRIEF DESCRIPTION OF THE DRAWINGS

[0029] Figure 1 A schematic diagram of the flow chart of the girth optimization algorithm proposed in the present invention;

[0030] Figure 2 A schematic diagram of the flow of the algorithm for searching and eliminating trap sets proposed by the present invention;

[0031] Figure 3 Schematic diagram of an index matrix according to an embodiment of the present invention;

[0032] Figure 4 is a performance curve diagram of an embodiment of the present invention; DETAILED DESCRIPTION

[0033] The present invention will be further explained below in conjunction with the accompanying drawings and specific embodiments. It should be understood that the embodiments are only used to illustrate the present invention and are not used to limit the scope of the present invention. After reading the present invention, various equivalent forms of modifications to the present invention by those skilled in the art fall within the scope defined by the claims attached to this application. The following is a construction process of an exponential matrix of a QC-LDPC code, whose exponential matrix parameters are N=286, M=28, the submatrix size is 128×128 (z=128), the column weight is 5, and the code rate is 0.902.

[0034] In an embodiment, step 1 includes:

[0035] Step 1-1: Replace the matrix elements with 0 in the original model with -1, and replace the matrix elements with 1 in the original model with random numbers between 0 and 127. That is, an exponential matrix of a QC-LDPC code with a submatrix size of 28×286 and a size of 128 is obtained.

[0036] Step 1-2: Traverse each non-1 matrix element of the exponential matrix, and record p as the shift value of the position, 0≤p≤127. When the position is p, calculate the number of four-rings and six-rings that the variable node corresponding to the matrix element participates in forming. C4_best is recorded as the minimum number of four-rings corresponding to 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 least among the p that meets the constraint, then the p0 is selected as the shift value of the exponential matrix at that position.

[0037] It should be noted that in this step, the calculation of the number of four-rings (k=2) formed by the variable nodes corresponding to a matrix element is performed in the following manner. The position of the matrix element is recorded as (i, j), and an array cyclenum of size z is initialized. The pth position of the array records the number of four-rings formed by the matrix element when it is p. The row index is fixed to i, and the index matrix is ​​traversed by column. E2 is recorded as the value of the matrix element at (i1, j1), i1=i, j1!=j, e2!=-1. The column index is fixed to j1, and the index matrix is ​​traversed by row. E3 is recorded as the value of the matrix element at (i2, j2), i2!=i1, j2=j1, e3!=-1, and e4 is recorded as the value of the matrix element at (i3, j3), i3=i2, j3=j, e4!=-1. Then e1=(e2-e3+e4+z)%z is calculated. The value at position e1 of the array is increased by 1.

[0038] It should be noted that in this step, the calculation of the number of six rings (k=3) formed by the variable nodes corresponding to a matrix element is performed in the following manner. The position of the matrix element is recorded as (i, j), and an array cyclenum of size z is initialized. The pth bit of the array records the number of six rings formed by the matrix element when it is p. The row index is fixed to i, and the index matrix is ​​traversed by column. E2 is recorded as the value of the matrix element at (i1, j1), i1=i, j1!=j, e2!=-1. The column index is fixed to j1, and the index matrix is ​​traversed by row. E3 is recorded as the value of the matrix element at (i2, j2), i2!=i1, j2=j1, e3!=-1. The row index is fixed to i2, and the index matrix is ​​traversed by column. E4 is recorded as the value of the matrix element at (i3, j3), i3=i2, j3!=j2, j3!=j, e4!=-1. Fix the column index to j3, traverse the index matrix row by row, record e5 as the value of the matrix element at (i4, j4), i4! = i3, i4! = i1, j4 = j3, e5! = -1. Record e6 as the value of the matrix element at (i5, j5), i5 = i4, j5 = j, e6! = -1. Then calculate e1 = (e2-e3+e4-e5+e6+z+z)%z. The value of the e1th position of the array + 1.

[0039] It should be noted that in this step, the calculation of the number of eight rings (k=4) formed by the variable nodes corresponding to a matrix element is performed in the following manner. The position of the matrix element is recorded as (i, j), and an array cyclenum of size z is initialized. The pth bit of the array records the number of eight rings formed by the matrix element when it is p. The row index is fixed to i, and the index matrix is ​​traversed by column. E2 is recorded as the value of the matrix element at (i1, j1), i1=i, j1!=j, e2!=-1. The column index is fixed to j1, and the index matrix is ​​traversed by row. E3 is recorded as the value of the matrix element at (i2, j2), i2!=i1, j2=j1, e3!=-1. The row index is fixed to i2, and the index matrix is ​​traversed by column. E4 is recorded as the value of the matrix element at (i3, j3), i3=i2, j3!=j2, e4!=-1. Fixed column index is j3, traverse the index matrix row by row, record e5 as the value of the matrix element at (i4, j4), i4! = i3, j4 = j3, e5! = -1. Fixed row index is i4, traverse the index matrix column by column, record e6 as the value of the matrix element at (i5, j5), i5 = i4, j5! = j4, e6! = -1. Fixed column index is j5, traverse the index matrix row by row, record e7 as the value of the matrix element at (i6, j6), i6! = i5, j6 = j5, e7! = -1. Record e8 as the value of the matrix element at (i7, j7), i7 = i6, j7 = j, e8! = -1. Then calculate e1 = (e2-e3+e4-e5+e6-e7+e8+z+z+z)%z. The value of the e1th position of the array + 1.

[0040] Step 1-3: Set the maximum number of traversals Iter_max_cycle = 40. Each round of traversal records the number of matrix elements whose shift values ​​change in this round, changenumber. When all matrix elements are the same as the previous round, or when the maximum number of traversals is reached, exit. Thus, the exponential matrix after the minimum girth optimization is obtained. For this embodiment, there is no four-ring in the exponential matrix, that is, c4best = 0.

[0041] In an embodiment, step 2 includes

[0042] Step 2-1: Input the exponential matrix after girth optimization, set the parameters of the trap set (a, b) to be eliminated, when a≤8 and b≤8, the trap set is the eliminated trap set. Set the parameters SIGMA=0.42, mu=-100.0, Ls=15, IterMax=20, and the maximum degree of the simple ring of the basic trap set g=6. Set the maximum traversal number Iter_max_ts=40.

[0043] Step 2-2: Initialize the change counter change_number to record the number of matrix elements that have changed after this round of search compared to the previous round, and initialize fail_number to record the number of columns that failed in this round of search. Starting from the leftmost column of the exponential matrix, traverse the columns marked as search failures (all columns are marked as search failures by default in the first round of traversal), and traverse each non-1 matrix element in each column j and row i in turn.

[0044] Step 2-3: For the non-1 matrix element at the index matrix (i, j), replace its shift value with p, 0≤p≤127, and calculate the number of four-rings and six-rings that the variable node corresponding to the matrix element participates in forming. The minimum value c4best of the number of four-rings c4 corresponding to all p is 0. Sort all p from small to large according to the number of corresponding six-rings, and record c6_best as the minimum value of the number of six-rings c6 corresponding to all p that satisfy the number of four-rings c4=c4best=0.

[0045] Step 2-4: traverse the p values ​​at that position that satisfy c4=c4_best=0 after sorting them in ascending order by the number of six rings, and the corresponding number of six rings c6≤c6_best+10, and search for trap sets on the jth column.

[0046] Step 2-5: Use decoding simulation to search for the trap set composed of the variable nodes corresponding to the jth column. Initialize failflag = 0, input a simple ring k composed of the variable nodes corresponding to the jth column, k≤3, if a≤8, b≤8 is found in the search process, then failflag = 1.

[0047] It should be noted that a trap set search is specifically implemented as follows, Ts is the searched trap set set, initialized to the simple ring Tk composed of the jth column, k≤g / 2. For each simple ring in the set Tk, Ls=15 decoding simulations are performed. A decoding simulation is specifically implemented as follows: all codewords are initialized to 0, and BPSK modulation is performed, and 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, and a decoding simulation is performed. The maximum number of iterations of a decoding is set to IterMax=20. If the decoding fails, the variable node with decoding error is returned, and the variable node set is classified into trap sets to determine its variable node number a and the number of unfilled check nodes b. Once a trap set with a≤8, b≤8 is found during the search process, the search for the p value is immediately exited.

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

[0049] It should be noted that the search for the simple loop k formed by the variable nodes corresponding to the jth column in this step is performed in the following manner: the first variable node in the jth column of the exponential matrix is ​​selected as the starting point to avoid repeated searches for isomorphic structures caused by cyclic shifts in the QC-LDPC matrix, and note that the path length here refers to the sum of the number of variable nodes and check nodes on the path.

[0050] When k=2, the simple ring degree g=4. Initialize set T2, which is the simple ring set of degree g=4 formed by the variable node. Starting from any two different check nodes of the variable node, find two paths with a path length of 1, on which there is a variable node, and the variable node is different from the variable node at the starting point. If any two paths end at the same variable node. Then treat the variable node and the initial variable node as a simple ring sequence, and add it to T2 if it is not in T2.

[0051] When k=3, the simple ring degree g=6. Initialize set T3, which is a simple ring set of degree g=6 formed by the variable node. Starting from any two different check nodes of the variable node, find two paths with a path length of 2, on which there is a variable node and a check node, and the variable node is different from the variable node at the starting point, and the check node is different from the check node at the starting point. If any two paths end at the same check node, and the two variable nodes are different from each other and do not share any other check nodes except the check node at the end point. Then treat these two variable nodes and the initial variable node as a simple ring sequence, and add them to T3 if they are not in T3.

[0052] When k=4, the simple ring degree g=8. Initialize set T4, which is a simple ring set of degree g=8 formed by the variable node. Starting from any two different check nodes of the variable node, find two paths with a path length of 3, on which there are two variable nodes and one check node, and the two variable nodes are different from the variable node at the starting point, and the check node is different from the check node at the starting point. If any two paths end at the same variable node, and the two paths do not share any other nodes except the variable node at the end point. Then treat these three variable nodes and the initial variable node as a simple ring sequence, and add them to T4 if they are not in T4.

[0053] Step 2-6: When the matrix element (i, j) is p, if no trap set with a≤8, b≤8 is found from the jth column, the matrix element is changed to p, marking the column search successful. If p is different from the original matrix element elem_old at this position, change_number+1. The next step is to search the j+1 column (j+1<286).

[0054] Step 2-7: If all ps in the range can lead to a trap set with a≤8, b≤8 being searched from the jth column, then the matrix element p0 is selected so that c4=c4_best=0, and its c6 is the smallest among the ps that satisfy the 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 all matrix elements in this column cannot find p that meets the conditions, then mark the search failure of this column, fail_number + 1. Next, search the (j+1) column (j+1<128).

[0056] Step 2-9: When the number of failed columns fail_number = 0 or the number of changed matrix elements change_number = 0 or the maximum number of traversals 40 times is reached, exit the traversal, otherwise proceed to the next round of traversal. In each round of traversal, only the columns that failed to search are searched.

[0057] When constructing the matrix, two rounds of searching were performed. In the first round of searching, the number of failed columns was fail_number=4, and the number of changed matrix elements was change_number=66. In the second round of searching, the number of failed columns was fail_number=0, and the number of changed matrix elements was change_number=1.

[0058] Step 2-10: Output the index matrix after trap set search and elimination. Figure 3 A schematic diagram showing the resulting exponential matrix.

[0059] In order to verify that the QC-LDPC code constructed by the present invention has good error floor performance, this embodiment performs FPGA simulation, and the specific operation is to perform decoding simulation using the minimum sum decoding algorithm grouped by column under a 2-bit quantized Gaussian white noise channel, and the maximum number of iterations during decoding is 50 times.

[0060] like Figure 4 The performance curve of this embodiment is shown in FIG. 1 , where the vertical axis is the uncorrectable error bit rate UBER and the horizontal axis is the signal-to-noise ratio SNR (Signal Noise Ratio). The last sampling point indicates that after 80 hours of simulation experiments on the FPGA, no error frame is obtained. It can be determined that the position of the error bottom is lower than UBER=10. -15 , which can be applied to actual flash memory applications. This proves that the QC-LDPC code constructed by the present invention has good error floor performance.

Claims

1. A method for constructing a QC-LDPC code with a low error floor, characterized in that The steps include: Step 1: Construct an exponential matrix based on the original model graph and optimize the girth. Construct an exponential matrix of size z with an M×N submatrix on the basis of the original model graph (M is the number of rows of the exponential matrix, and N is the number of columns of the exponential matrix). Replace the matrix elements that are 0 on the original model graph with -1, and replace the matrix elements that are 1 on the original model graph with random integers p between 0 and z-1 to obtain the exponential matrix. Optimize the girth of the exponential matrix, traverse each matrix element, calculate the number of short rings formed by its corresponding variable nodes, and determine the optimal shift value p0 so that the properties of the k-rings formed by it are optimal. Get the exponential matrix after girth optimization; Step 2: Search for and eliminate harmful trap sets in the exponential matrix, traverse each non-1 matrix element in the exponential matrix by column, use the result of girth optimization to select its shift value, search for the short loop formed by the variable node corresponding to the matrix element through path expansion, further search for the harmful trap set within the specified range formed by it through decoding simulation, change the shift value of the matrix element to eliminate the harmful trap set, and repeatedly traverse the entire matrix until the maximum number of traversals is reached, or all matrix elements do not change after one round of traversal, or no harmful trap set can be found starting from the variable node corresponding to any column.

2. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When performing girth optimization in step 1, traverse each non-1 matrix element in the exponential matrix in turn, and change its shift value to p while fixing the shift values ​​of other matrix elements. p traverses from 0 to z-1, and calculates the number of short loops formed by the variable nodes corresponding to the matrix element under the current shift value. Select the optimal shift value and traverse the matrix repeatedly until girth optimization can no longer be performed or the maximum number of traversals is reached.

3. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When calculating the number of short rings formed by the variable nodes corresponding to a matrix element in step 1, the shift value of the matrix element when the ring exists is solved according to the values ​​of other matrix elements in the exponential matrix that form a ring structure with the matrix element in position, and the conditional formula for forming a ring in the QC-LDPC matrix, and the number of ring structures formed by the matrix element when it is calculated when the matrix element takes p.

4. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When determining the optimal shift value p0 in step 1, p0 is optimal if the number of k-1 rings is satisfied. Under the premise, the number of its rings k is minimized; the p with the best four-ring (k=2) property is defined as the p with the least number of four-rings in all p of the matrix element; the p with the best six-ring (k=3) property is defined as the p with the least number of six-rings in all p of the matrix element with the best four-ring property; the p with the best eight-ring (k=4) property is defined as the p with the least number of eight-rings in all p of the matrix element with the best six-ring property; and so on.

5. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When using the result of girth optimization in step 2, traverse each non-1 matrix element in the exponential matrix by column. For each matrix element, select the shift value with the best k0 ring property, and traverse it from small to large according to the number of its k0+1 rings, and ensure that the number of its corresponding k0+1 rings does not exceed 10 (k0=2, 3) compared with the optimal number of k0+1 rings. The 10 here is an empirical value and can be replaced by other values.

6. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When searching for the short loop formed by the variable nodes corresponding to the column where the matrix element is located in step 2, the search is performed starting from the first variable node among the z variable nodes corresponding to the column where the matrix element is located in the exponential matrix.

7. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When searching for short loops by path expansion in step 2, according to the parameter k (k=2, 3, 4) of the short loop, starting from any two check nodes of the variable node, search for a path of specified length k-1 (the calculation of the path length does not include the starting check node) so that there are k-1 nodes on the path, and the two paths end at the same node, and do not share any other nodes except the node at the end point.

8. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: In step 2, when searching for a harmful trap set within a specified range consisting of variable nodes corresponding to a matrix element through decoding simulation, a simple ring of k≤g / 2 (k=2, 3, 4) where the variable node corresponding to the column where the matrix element is located under the current shift value is located is used as input (a simple ring means that there is no ring with a smaller degree in the ring). For each simple ring, decoding simulation is performed by adding noise to the variable nodes on it, and the erroneous variable node combination involved in the decoding failure is regarded as a trap set. If it is found that the size of the harmful trap set is within the specified range, the search for the current shift value is stopped.

9. A method for constructing a QC-LDPC code with a low error floor as claimed in claim 1, characterized in that: When changing the shift value of the matrix element in step 2 to eliminate the harmful trap set, for each matrix element, if the current shift value makes it impossible to search for the harmful trap set of (a, b) (a<=amax, b<=bmax) in this column, 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 rings of the current shift value is more than 10 more than the minimum number of k0+1 rings, and the harmful trap set in the specified range can still be searched, the shift value with the minimum k0+1 rings is selected as the shift value of the matrix element (k0=2, 3), and the search for the next matrix element in the column is continued until there is a shift value that makes it impossible to search for the harmful trap set in this column or all non-1 matrix elements in this column are traversed.

Images