KR102739945B1 - A method and device for generating a pileup file from compressed domain genomic data - Google Patents

Abstract

A method and device for generating a pileup file from a reference-based compression file are disclosed, comprising the steps of: receiving a reference-based compression file including a plurality of compressed lead data; partially decompressing the plurality of lead data to obtain a differential string associated with each of the plurality of lead data; and generating a pileup file by decoding the differential string based on a plurality of conversion rules.

Description

{A method and device for generating a pileup file from compressed domain genomic data}

The various embodiments relate generally to Next Generation Sequencing (NGS), and more specifically to mechanisms for generating pileup files from compressed NGS genomic data.

In computational biology, next-generation sequencing (NGS) is considered a new, high-throughput technology for sequencing DNA or RNA. NGS can be used to analyze the genome of an individual or a population of individuals, for example, to create a comprehensive list of genetic variations in population samples. NGS-based diagnostics have important implications for prescribing effective treatments to individuals. Such personalized diagnostics are often based on sets of mutations obtained from analyzing an individual's DNA data through an NGS analysis pipeline. These mutations, which characterize an individual's disease, help clinicians tailor treatments. NGS methods typically amplify sequenced DNA molecules and break these copies into smaller strands called reads (10 to 1000 contiguous base pairs). These reads are then aligned, and the results are stored in a FASTQ file (unaligned NGS sequence reads + quality data are stored in a FASTQ file).

In order to analyze genomic data acquired through NGS sequencing, reads are first aligned to a reference (a reference standard for genomic data, which can be interpreted as genomic data representing each species) and stored in a Sequence Alignment Map (SAM) file. For each read, the SAM file has multiple fields such as a read sequence, quality values, a read-level quality value, an alignment position with respect to the reference, and a CIGAR string. The CIGAR string contains a representation of the difference between the read and the reference. The SAM file ranges in size from several MB to GB. Analysis of genomic data requires steps such as variation calling. Variation calling requires a pileup file of the genomic data to be analyzed.

Typically, processing or analyzing compressed genomic data, such as generating pileups and variation calling, is performed using a binarized SAM file, called a Binary Alignment Map (BAM) file. The size of a BAM file can be several MB or GB. If the SAM data is compressed, before calling the pileup and variation calling for generating the pileup file, the compressed genomic data in the SAM file is first decompressed and converted to the BAM format. This consumes a large amount of memory space and processing power, and increases the time for analyzing the genomic data.

A method and device for generating a pileup file from a reference-based compressed file that compresses NGS read information for a reference are provided. The pileup file is generated by decompressing one or more reads from the reference-based compressed file. In this case, the decompression is partial decompression.

In addition, a method is provided for partially decompressing one or more leads to obtain difference strings corresponding to each lead.

In addition, a method of generating a pileup file by decoding difference strings using one or more conversion rules is provided.

A method for generating a pileup file according to one embodiment may include the steps of receiving a reference-based compressed file including a plurality of compressed lead data, partially decompressing the plurality of lead data to obtain a differential string associated with each of the plurality of lead data, and decoding the differential string based on a plurality of conversion rules to generate a pileup file.

A device for generating a pileup file according to one embodiment includes a memory storing one or more instructions and a processor executing the one or more instructions stored in the memory, wherein the processor is configured to receive a reference-based compression file including a plurality of compressed read data, partially decompress the plurality of read data to obtain a differential string associated with each of the plurality of read data, and decode the differential string based on a plurality of conversion rules, thereby generating a pileup file.

In one embodiment, a computer-readable recording medium may be a computer-readable recording medium having recorded thereon a program for causing a computer to execute a method for generating a pileup file, the method including the steps of: receiving a reference-based compression file including a plurality of compressed lead data; partially decompressing the plurality of lead data to obtain a differential string associated with each of the plurality of lead data; and decoding the differential string based on a plurality of conversion rules to generate a pileup file.

FIG. 1 is a diagram illustrating a network execution of a device for generating a pileup file (pileup string) from a reference-based compressed file containing reference-based compressed genomic data according to one embodiment.
FIG. 2 is a block diagram showing the configuration of a device for generating a pileup file according to one embodiment.
FIG. 3 is a flowchart illustrating a method for generating a pileup file from a reference-based compressed file containing reference-based compressed genomic data, according to one embodiment.
FIG. 4a illustrates an example of lead data for generating a pileup string according to one embodiment.
FIGS. 4B to 4K are drawings for reference to explain a method of generating a pileup string for a lead based on transformation rules according to one embodiment.
FIG. 5 is a diagram illustrating a computing device for generating a pileup file from a reference-based compressed file according to one embodiment.

The terms used in the present invention are selected from the most widely used general terms possible while considering the functions of the present invention, but they may vary depending on the intention of engineers working in the field, precedents, the emergence of new technologies, etc. In addition, in certain cases, there are terms arbitrarily selected by the applicant, and in this case, the meanings thereof will be described in detail in the description of the relevant invention. Therefore, the terms used in the present invention should be defined based on the meanings of the terms and the overall contents of the present invention, rather than simply the names of the terms.

When a part of the specification is said to "include" a component, this does not mean that other components are excluded, unless otherwise specifically stated, but rather that other components may be included. In addition, terms such as "? part", "? module", etc. described in the specification mean a unit that processes at least one function or operation, which may be implemented by hardware or software, or a combination of hardware and software.

Below, with reference to the attached drawings, embodiments of the present invention are described in detail so that those skilled in the art can easily implement the present invention. However, the present invention may be implemented in various different forms and is not limited to the embodiments described herein.

In the following embodiments, a method and apparatus for generating a pileup file (pileup string) from a reference-based compressed file are described. The reference-based compressed file is typically based on reference-based NGS (Next generation sequencing) data compression, where sequencing refers to a process of determining a nucleotide order of a given DNA string. The reference-based compressed file includes a plurality of NGS read data (reads). The NGS read data is expressed as a difference string with respect to a reference sequence. The read data is sequenced by overlapping fragments of amplified DNA. After sequencing, the read data can be arranged to positions with respect to the reference that best matches it. The difference string provides information about the difference of the read with respect to the reference sequence at the point where the read data is arranged. The difference string is encoded according to other components of a SAM file for each read, including quality values associated with each base of the read as well as a quality value (quality vector) of the read. Read data can be defined by reference sequences and difference strings in a reference-based compressed file that utilizes reference-based NGS data compression.

A method for generating a pileup file according to one embodiment includes an operation of obtaining a difference string corresponding to each lead data. The operation of generating a pileup file from the difference string can be performed using one or more transformation rules. In addition, the generated pileup file can be used in various applications. For example, the pileup file can be used in variation calling.

Conventional pileup file generation methods required reconstruction or complete decompression of compressed lead data from a SAM file, and conversion to a classified BAM format. However, a pileup file generation method and device according to one embodiment do not require complete decompression or reconstruction of lead data. A pileup file can be generated by decompressing compressed information to obtain a difference string for each lead data from a reference-based compression file. At this time, the difference string can be obtained through partial decompression of the lead data. Partial decompression of the lead data can increase time efficiency and reduce space complexity in generating a pileup file compared to completely reconstructing or decompressing the lead data.

In one embodiment, the use of a reference-based compression mechanism that compresses the entire genome with random access can provide partial decompression for only selective regions. Furthermore, even if the entire genome data needs to be accessed from the reference-based compression file, less memory can be utilized compared to existing methods using equivalent BAM files. This results from efficient compression and partial decompression of the read data.

Hereinafter, the present embodiments will be described with reference to the drawings of FIGS. 1 to 5. Here, similar reference characters may be used for corresponding components between the drawings.

FIG. 1 is a diagram illustrating a network execution of a device (100) for generating a pileup file (pileup string) from a reference-based compression file including reference-based compression genomic data according to one embodiment. In addition, the device (102) according to one embodiment can be implemented as an application for executing a series of instructions in a server (50). In addition, the device (102) can be implemented as various types of computing devices, such as a laptop computer, a desktop computer, a notebook, a workstation, a server, a network server, an electronic device, and the like. In addition, in one embodiment, the device (102) can be executed in a cloud-based environment. The device (102) can be accessed by a plurality of users via one or more user devices (106 ₁ , 106 ₂ , 106 ₃ , ?, 106 _N , hereinafter collectively referred to as user devices (106 )), or applications of the user devices (106 ). For example, the user devices (106) may include, but are not limited to, portable computers, personal digital assistants, hand-held devices, and workstations. Additionally, the user devices (106) may communicate with the device (102) via the network (104).

In one embodiment, the network (104) may be a wireless network, a wired network, or a combination thereof. The network (106) may be implemented as one of other types of networks, such as an intranet, a local area network (LAN), a wide area network (WAN), the Internet, etc.

FIG. 2 is a block diagram illustrating a configuration of a device (102) for generating a fileup file according to one embodiment. Referring to FIG. 2, the device (102) may include a processor (202) and an input/output (I/O) interface (206), and the device (102) may further include a memory (204) for storing various modules executed by the processor (202). The device (102) may be configured to allow the processor (202) to access a reference-based compression file. In addition, in one embodiment, the device (102) may receive a reference-based compression file from another storage device via the I/O interface (206). At this time, the reference-based compression file includes a plurality of lead data or leads stored as difference strings. The device (102) according to one embodiment may generate a difference string associated with each lead data included in the reference-based compression file.

A device (102) for generating a pileup file can generate a difference string by partially decompressing a plurality of lead data included in a reference-based compressed file. In addition, the device (102) can generate a pileup file by decoding a difference string of each lead data based on a plurality of conversion rules. The conversion rules will be described later with reference to the drawings of FIG. 3 and FIGS. 4A to 4K. The generated pileup file can be stored in a memory (204) or another storage device and can be used in various applications. For example, it can be used in variation calling, but is not limited thereto.

The block diagram of the device (102) for generating a file-up file illustrated in FIG. 2 is a block diagram for one embodiment. Each component of the block diagram may be integrated, added, or omitted according to the specifications of the device (102) to be actually implemented. That is, two or more components may be combined into one component, or one component may be subdivided into two or more components, as needed. In addition, the functions performed by each block are for describing embodiments, and the specific operations or devices thereof do not limit the scope of the present invention. In addition, the device (102) may include various other modules or components. In addition, the device (102) may include various other modules or components that interact with hardware or software components locally or remotely to communicate with each other. For example, a component may include, but is not limited to, a process, an object, an executable process, an execution thread, a program, or a computer operating on a controller or processor.

FIG. 3 is a flowchart illustrating a method for generating a pileup file from a reference-based compressed file including reference-based compressed genomic data according to one embodiment. Referring to FIG. 3, the method for generating a pileup file according to one embodiment may include, in step 302, an operation of receiving a reference-based compressed file (compressed genetic information) as an input. The reference-based compressed file includes a plurality of read data stored using a reference-based compression mechanism. In one embodiment, the reference-based compression mechanism may be NGS compressed data including a plurality of read data expressed as a difference string. The method for generating a pileup file according to one embodiment may include, in step 304, an operation of decompressing the plurality of read data included in the reference-based compressed file to generate a difference string associated with each of the read data. At this time, unlike a conventional method that completely decompresses reads to generate a pileup file, the read data is partially decompressed to generate the difference string. A method for generating a pileup file according to one embodiment may include, in step 306, an operation of generating a pileup file by decoding a difference string of each read data based on one or more conversion rules. The conversion rules enable decoding of each segment of a difference string associated with each read data that may be required to generate a pileup file. The conversion rules will be described later. The generated pileup file may be a standard pileup file including a plurality of fields corresponding to each decoded difference string. The plurality of fields may include a position field of read data for a reference, a reference field (reference read data), a read base information field (a vector of match and mismatch), and a quality information field (a quality vector). The length of the vector at each position is approximately equal to the depth of the SAM file. The quality vector indicates quality values corresponding to strings in the vector fields. An example of a pileup string corresponding to a specific read is given below in Table 1.

location
(Position) Reference Read base Information Quality Information 1024 A .....A$A -@23567

The generated pileup file can be used for various applications including, but not limited to, variation calling.

A device (102) for generating a pileup file according to one embodiment can generate a pileup file based on partial decompression of leads by performing a pileup file generating method including the operations in steps 302 to 306.

Various operations, actions, blocks, steps, and the like of the method for creating a pileup file according to one embodiment may be performed in the order described with reference to FIG. 3, or in a different order, or simultaneously. Furthermore, as another embodiment, some operations, actions, blocks, steps, and the like may be deleted, added, modified, or omitted without departing from the scope of the present invention.

FIG. 4a illustrates an example of lead data for generating a pileup string according to one embodiment. FIG. 4a illustrates arrangement details of lead data for a reference according to one embodiment. FIG. 4a includes a reference (402a), a lead (404a), a lead arranged for the reference (406a), and a CIGAR and a differential string (408a). The CIGAR string is used to store the difference between the reference and the lead in a conventional SAM file format. Although the CIGAR may be considered a difference string, it does not contain specific information about the location of changes, such as substitutions and mismatches in the lead for equivalent positions in the reference, as well as information about such changes.

The reference (402a) is used as a reference sequence for the read (404a) to generate a reference-based compression file. The difference information between the reference (402a) and the read (404a) is stored in the reference-based compression file as a difference string (408a) in addition to other read-related information. In the reference-based NGS data compression, the difference information can be encoded, which can result in significant memory reduction. The location of the difference can be encoded using a differential offset. Additionally, a nucleotide sequence can be encoded after the change type between the read and the reference (except for the case of a delete operation). An entropy coder (e.g., an operation coder) can be used to compress each of the above parameters. The quality values can be compressed using a method related to compressing codes such as those used in the compression of unaligned NGS data (e.g., a FASTQ file).

A difference string indicating the difference between the reference sequence and the read may include indicators including substitution "S", insertion "I", deletion "D", and softclipping "@". A difference string (408a) according to one embodiment may be "0@AAA 0SC 3SA 0IAT 0SCG 0D2".

A device (102) for generating a pileup file according to one embodiment can generate a pileup file by decoding a difference string using conversion rules. The conversion rules according to one embodiment will be described below with reference to Table 2. A plurality of fields included in a pileup file can include a position field (indicating a relative position with respect to a reference), a reference field, a read base information field, and a quality information field.

Action 1 Select a segment of the difference string associated with the lead and insert the reference base. 2 If the segment to be decoded is the first segment of the difference string,
- Insert the starting point of the lead and the reference base value corresponding to the starting point into the location field and reference field of the pileup string, respectively.
- Insert "^" (the first symbol) indicating the start of the lead into the "Lead base information" field.
- Insert the quality value of the lead into the lead base information field as an ASCII value of quality value = (lead quality + predefined value) (in one embodiment, the predefined value may be 33). 3 ■Check the indicator in each segment of the difference string
■If the indicator at the beginning or end of the lead is an "@" indicator indicating soft clipping, the soft clipping and its corresponding sequence are ignored.
■ If the indicator is “S” indicating substitution,
- Check for one or more substitutions from the difference string,
- At the location of the substitution: Insert the substitution base values into the lead base information field of the pileup string, insert the quality values corresponding to the substitution base values into the quality information field, insert the reference base value into the reference field, and insert the corresponding reference location into the location field.
- Determine the internal state by substitution (indicated by S)
- Increase the position by the number of substitutions
■ If the indicator is “I”,
- Insertion always captures the previous position
- The values of the bases inserted at the current location are inserted into the read base information field, and the corresponding quality values are inserted into the quality information field. A "+" is added in front of the base values.
- Determine the internal state as "I"
- The location value does not change.
■If the indicator is “D”,
This can be done in two ways:
- If there was a match or substitution at the previous position, add a "-" sign at the previous position, and insert the number of bases to be deleted and the actual values of the bases based on the reference after the "-" sign. Insert the sign "*" into the read base information field corresponding to the position where deletion occurred. Also, insert "!" (ASCII=33: lowest quality) into the quality information field corresponding to those positions. Insert related values into the position field and the reference field.
- If a deletion occurs after an insertion (other cases), insert the symbol "*" into the lead base information field corresponding to the deletion position. Insert related values into the position field and reference field. In addition, insert "!" (ASCII=33: lowest quality) into the quality information field corresponding to those positions.
- Determine the internal state as "D"
- Increase the position by the number of deletions.
■ Change or maintain internal state to a determined internal state
■ Change location
■ Match inserts the symbol "." into the lead base information field and inserts the corresponding quality values into the quality information field. It also inserts related values into the location field and reference field.
■ At the end of the lead, the sign "$" (second sign) is inserted into the last entry of the lead base information field.

FIGS. 4b to 4k are drawings referenced to explain a method of generating a pileup string for a lead (404a) based on transformation rules according to one embodiment.

[0039] FIG. 4b shows a first step for generating a pileup string (402b) for a lead (404a) with a reference (402a) illustrated in FIG. 4b. A difference string (408a) for the lead (404a) is represented as “0@AAA 0SC 3SA 0IAT 0SCG 0D2 0IAA 0D2”. 1024 is a starting point of the reference (402a), and the device (102) for generating the pileup file inserts a “^” symbol indicating the start of the lead 404a into the lead base information field, and inserts the base “A” into the reference field of the pileup string (402b). In addition, the device (102) inserts a quality value (0) calculated as an ASCII value of quality value = (quality of lead + 33) into the lead base information field.

Fig. 4c shows a second step for generating a pileup string (402b) for a lead (404a) with the reference (402a) shown in Fig. 4c. The segment "0@AAA" of the difference string (408a) indicates soft clipping "@" of AAA bases at index 0 from the initial position (1024) of the reference (402a). According to the conversion rules of Table 2, soft clipping at the beginning and end of the lead is ignored. In addition, the internal state is marked with @, and the position in the reference is maintained as 1024.

FIG. 4d illustrates a third step for generating a pileup string (402b) for a lead (404a) based on the reference (402a) illustrated in FIG. 4d. The segment "0SC" of the difference string (408a) indicates a substitution of the base C at the previously changed position (1024). In addition, a quality value may be inserted into the quality information field corresponding to the position (1024). For example, the device (102) may insert a quality value (#) corresponding to the base C into the quality information field, as illustrated in FIG. 4d. In addition, the position for the reference may be changed from 1024 to 1025, increasing by 1 (the number of substitutions).

FIG. 4e illustrates a fourth step for generating a pileup string (402b) for a lead (404a) based on the reference (402a) illustrated in FIG. 4e. For the segment "3SA" of the difference string (408a), two sub-steps may be performed. In the first sub-step, the segment "3SA" indicates a match to the reference at positions 1025, 1026 and 1027 (three positions). Accordingly, the device (102) may insert a symbol "." into the lead base information fields corresponding to positions 1025, 1026 and 1027. In addition, the device (102) may insert quality values (=, +, p) corresponding to the corresponding bases (T, C, G) respectively into the quality information fields corresponding to positions 1025, 1026 and 1027, respectively. The device (102) can determine the internal state as M and change the location for the reference from 1024 to 1027.

Additionally, in the second sub-step, the segment "3SA" indicates substituting base C with base A at position 1028 with respect to the reference (402a). In the second sub-step, the device (102) may insert a quality value (e.g., q) of the substituted base (e.g., base A) into the quality information field. Additionally, the device (102) may determine the internal state to be S and change the position with respect to the reference from 1028 to 1029.

FIG. 4f illustrates a fifth step for generating a pileup string (402b) for a read (404a) based on the reference (402a) illustrated in FIG. 4f. The segment "0IAT" of the difference string (408a) indicates an insertion ("I") of two bases (A and T) at position (1029). Since the insertion is always captured at a previous position according to multiple transformation rules, A and T are inserted at position 1029, which is a previous position of the current position (1029). At this time, "+" is added in front of A and T, as illustrated in FIG. 4f. In addition, the quality information at position 1028 is updated, and r and t corresponding to bases A and T, respectively, are added to the quality information field, as illustrated in FIG. 4f. In addition, the device (102) determines the internal state as "I", and maintains the position for the reference as 1029.

FIG. 4g illustrates a fifth step for generating a pileup string (402b) for a read (404a) based on the reference (402a) illustrated in FIG. 4g. The segment "0SCG" of the difference string (408a) indicates a substitution with two bases (C and G). The device (102) may mark the substitution with base C in the read base information field corresponding to position 1029, and may mark the substitution with base G in the read base information field corresponding to position 1030, as illustrated in FIG. 4g. In addition, the device (102) may update the quality information at each position and determine the internal state as "S". In addition, the device (102) may change the position for the reference from 1029 to 1031 by increasing the number of substituted bases (2).

FIG. 4h illustrates a seventh step for generating a pileup string (402b) for a read (404a) based on the reference (402a) illustrated in FIG. 4h. The segment "0D2" of the difference string (408a) indicates a deletion of two bases at a position that is 0 distance from position 1031. The deletion can be marked in two ways. The first way can be used when "M" (match) or "S" (substitution) was performed before the deletion. In the case of the first way, if the number of bases to be deleted is n, -n and the value of the base to be deleted can be inserted into the read base information field corresponding to the previous position. In addition, the sign "*" can be marked in the read base information field corresponding to the deletion position, and "!" can be inserted into the quality information field corresponding to the deletion position. The second way can be used except when "M" (match) or "S" (substitution) was performed before the deletion. For the second method, the deletion location may be marked with a "*" and the quality information field corresponding to the deletion location may be inserted with a "!".

For the segment "0D2" of the difference string (408a), since the substitution operation has been performed previously, the first method can be used. The device (102) can identify the reference bases (here, A and A) at positions 1031 and 1032. According to the first method, the device (102) can insert -2AA into the read base information field corresponding to the previous position 1030. In addition, the device (102) can insert a sign "*" into the read base information fields corresponding to positions 1031 and 1032, and insert "!" into the quality information fields corresponding to positions 1031 and 1032. In addition, the position for the reference can be changed to 1033 by increasing by the number (2) of bases deleted from 1031, and the internal state can be determined as "D".

FIG. 4i shows the 8th step for generating a pileup string (402b) for a lead (404a) based on the reference (402a) illustrated in FIG. 4i. The segment '0IAA' of the difference string (408a) indicates an insertion of two bases (A and A) at a position whose distance is 0 from the position 1033. According to the transformation rules, since the insertion is always captured at a previous position, A and A are inserted at 1032, which is a previous position of the current position (1033). At this time, "+" is added before A and A, as illustrated in FIG. 4i. In addition, the quality information at the position 1032 is updated, and ^ and -, which correspond to the bases A and A, respectively, are added to the quality information field, as illustrated in FIG. 4i. In addition, the internal state is determined as "I", and the position for the reference is maintained as 1033.

FIG. 4j illustrates a ninth step for generating a pileup string (402b) for a lead (404a) based on the reference (402a) illustrated in FIG. 4j. The segment '0D2' of the difference string (408a) represents deletion of two bases, and the device (102) can identify two bases at positions 1033 and 1034. For the segment "0D2", since an insertion operation has been performed previously, the second method of deletion can be utilized. According to the second method, the device (102) can insert a symbol "*" into the lead base information fields corresponding to positions 1033 and 1034, and insert "!" into the quality information fields corresponding to positions 1033 and 1034. Additionally, the device (102) can change the position for the reference from 1033 to 1035 by increasing the number of bases deleted (2) and mark the internal state as “D”.

FIG. 4K illustrates a tenth step for generating a pileup string (402b) for a read (404a) based on the reference (402a) illustrated in FIG. 4K. At this time, the position of the reference is 1035, and there may be no more segments left to be processed in the difference string. However, the number of reads processed is 14, whereas the length of the known read is 16. Therefore, the number of remaining bases to be processed becomes 2 (16-14=2). In this case, if the number of remaining bases to be processed is greater than 0, the device (102) may perform a "match" operation on the remaining bases to be processed. For example, the device (102) may insert a symbol "." into a base information field corresponding to the remaining reference, and insert a quality value corresponding to the reference base into the quality information field. Additionally, as illustrated in FIG. 4k, the device (102) may add a symbol “$” indicating the end of a lead to the last entry of the lead base information field.

According to one embodiment, the device (102) can generate a fileup string (402b) by performing steps 1 through 10 described in FIGS. 4b through 4k.

FIG. 5 is a diagram illustrating a computing device for generating a fileup file from a reference-based compression file according to one embodiment. Referring to FIG. 5, the computing device (500) may include a processing unit (508) including a control unit (504) and an operation unit (506), a memory (510), a storage unit (512), a network interface (516), and an I/O interface (514).

In addition, the processing unit (508) can process instructions of the algorithm. The processing unit (508) can receive commands from the control unit (504) to perform processing. In addition, any logical and arithmetic operations included in the execution of the instructions can be performed in the operation unit (506).

A computing device (500) according to one embodiment may include a plurality of homogeneous or heterogeneous cores, a plurality of different types of CPUs, special media, and other accelerators. The processing unit (508) may be implemented as one chip or multiple chips. However, the present invention is not limited thereto.

An algorithm including instructions and codes required for execution is stored in memory (510) or storage (512), or both. At execution time, the instructions can be fetched from memory (510) or storage (512) and executed by processing unit (508).

In the case of any hardware execution device, the computing device (500) can be connected to various other devices through a network interface (516), and can receive commands from a user or provide the user with processing results from the computing device (500) through an I/O interface (514).

The embodiments may be implemented by at least one software program that operates on at least one hardware device and performs network management functions for controlling the components. The components illustrated in FIGS. 1 to 5 include blocks, and the blocks may be at least one hardware device, or a combination of a hardware device and a software module.

Meanwhile, the method for creating a pileup file according to one embodiment can be implemented as a computer-readable code on a computer-readable recording medium. The computer-readable recording medium includes all types of recording devices that store data that can be read by a computer system. Examples of the computer-readable recording medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage device, etc., and also includes those implemented in the form of a carrier wave, such as transmission via the Internet. In addition, the computer-readable recording medium can be distributed to computer systems connected to a network, so that the code that can be read by a processor can be stored and executed in a distributed manner.

In addition, although the embodiments of the present invention have been illustrated and described above, the present invention is not limited to the specific embodiments described above, and various modifications may be made by a person skilled in the art without departing from the gist of the present invention as claimed in the claims. Furthermore, such modifications should not be individually understood from the technical idea or prospect of the present invention.

Claims (15)

A step of receiving a reference-based compressed file, comprising a plurality of compressed lead data;
A step of partially decompressing the plurality of lead data to obtain a differential string associated with each of the plurality of lead data; and
A step of generating a pileup file by decoding the difference string based on a plurality of conversion rules;
The step of generating a fileup file by decoding the difference string based on the above plurality of conversion rules is as follows.
A step of determining whether the position of a segment processed to create the fileup file is the first position among a plurality of segments included in the above difference string; and
If the position of the above segment is determined to be the first position, a step of inserting the start position of the lead data into the position field of the pileup file;
A step of inserting a base of a reference corresponding to the start position into a reference field of the above-mentioned pileup file;
A step of inserting a first symbol indicating the start of the lead data into the lead base information field of the above-mentioned file-up file; and
A method for creating a pileup file, comprising the step of inserting a quality value of the lead data as an ASCII value of a value obtained by adding a preset value to the lead quality. In the first paragraph,
The above fileup file includes a plurality of fields corresponding to the difference string,
A method wherein the plurality of fields include a position field, a reference field, a read base information field, and a quality information field. delete delete In the first paragraph,
The step of generating a fileup file by decoding the difference string based on the above plurality of conversion rules is as follows.
If it is determined that the position of the above segment is not the first position,
In the above segment, a step of checking the indicator;
A step of processing the segment based on the indicator identified in the segment; and
A method comprising: a step of marking an internal state for the processed segment; In paragraph 5,
The step of generating a fileup file by decoding the difference string based on the above plurality of conversion rules is as follows.
A method further comprising the step of inserting a second symbol indicating the end of the read data into a read base information field when all of the plurality of segments included in the above difference string are processed. In paragraph 5,
A method, wherein the above indicators include a soft clipping indicator, a replacement indicator, a deletion indicator and an insertion indicator. In a device that creates a file-up file,
Memory for storing one or more instructions; and
A processor comprising: a processor for executing one or more instructions stored in the memory;
The above processor,
A method of receiving a reference-based compressed file including a plurality of compressed lead data, partially decompressing the plurality of lead data to obtain a differential string associated with each of the plurality of lead data, and generating a pileup file by decoding the differential string based on a plurality of conversion rules,
Among the multiple segments included in the above difference string, determine whether the location of the segment processed to create the above fileup file is the first location,
A device for inserting a start position of the read data into a position field of the pileup file, inserting a base of a reference corresponding to the start position into a reference field of the pileup file, inserting a first symbol indicating the start of the read data into a read base information field of the pileup file, and inserting a quality value of the read data as an ASCII value of a value obtained by adding a preset value to the read quality, if the position of the above segment is determined to be a first position. In Article 8,
The above fileup file includes a plurality of fields corresponding to the difference string,
A device wherein the plurality of fields include a position field, a reference field, a read base information field, and a quality information field. delete delete In Article 8,
The above processor,
A device for determining, when it is determined that the position of the above segment is not the first position, checking an indicator in the above segment, processing the segment based on the indicator checked in the above segment, and marking an internal state for the processed segment. In Article 12,
The above processor,
A device that inserts a second symbol indicating the end of the read data into a read base information field when all of the plurality of segments included in the above difference string are processed. In Article 12,
The above indicators include a soft clipping indicator, a replacement indicator, a deletion indicator and an insertion indicator, the device. A computer-readable recording medium having recorded thereon a program for executing the method of the first paragraph above on a computer.

Images