Method and system for generating and storing graph reference genomes

Abstract

A computer-implemented method 100 for representing a graph genome data structure in a memory of a computer system, the method comprising: receiving (120) a graph reference genome definition including: (i) a plurality of graph genome edges, each of which specifies a character sequence; and (ii) a plurality of links representing connections between the plurality of graph genome edges; generating (130) a graph data structure for the received graph reference genome definition including a reference sequence count specifying a number of the plurality of reference sequences; and storing (140) the generated graph data structure in the memory.

Description

[Technical field]

[0001] The present disclosure relates generally to methods and systems for generating graph data structures that include genetic information. [Background technology]

[0002]

[0002] A linear reference genome containing one gene sequence is the most widespread model used for processing and analysis, including alignment of reads and variant calling in next generation sequencing (NGS). A linear reference genome is based on the use of one preferred tiling path to generate one consensus representation of the genome. For example, the linear reference NCBI GRCh38 (Hg38) is a composite genome containing about 93% primary assembly consisting of sequences from 11 individuals.

[0003]

[0003] However, despite its ease of reference and its popularity among scientists due to its relatively low demands on computational analysis, one tiling pass of a linear reference genome is insufficient to represent allelic diversity in complex genomic regions of most mammalian genomes. With many genomic variations excluded, a linear reference genome introduces extensive reference bias. This can negatively impact the accuracy of downstream analyses. For example, if a patient's genomic region containing a clinically relevant mutation differs significantly from the reference genome, the patient's sequencing reads in that region will not map correctly to the reference, resulting in missing calls of variants that may be important for diagnosis and treatment. The latest human reference genome, GRCh38, attempted to improve the representation of allelic diversity by including alternative locus scaffolds in regions with known alternative haplotypes (e.g., major histocompatibility complex regions), high diversity (e.g., olfactory receptor regions), and large structural variants greater than 5 Kb. However, this does not adequately encompass and represent the diversity found within the genome.

[0004]

[0004] One of the most effective ways to represent complex genomic diversity in a reference cohort is through a genome graph, where genome variations are captured as edges associated with different nucleotide sequences. With the advancement of bioinformatics algorithms and computing power, graph-based genome analysis will become one of the mainstream approaches for genome research. However, like linear reference genomes, existing genome graphs are not designed or structured to adequately encompass or represent the diversity found in the genomes of a cohort. Summary of the Invention [Problem to be solved by the invention]

[0005]

[0005] There remains a need for graph-based genome structures that can adequately and efficiently represent the genomic diversity of a cohort. [Means for solving the problem]

[0006]

[0006] The present disclosure relates to a method and system of the present invention for generating and storing a graph data structure including genetic information. Various embodiments and implementations herein relate to a system or method for generating a graph data structure that can be stored in a memory of a computer system and regenerating the stored graph data structure. The graph data structure represents a plurality of genome sequences and can include at least a portion of a reference genome. The graph data structure system receives a graph reference genome definition including a plurality of graph genome edges, each of which specifies a character sequence, and a plurality of links, each of which specifies a connection between the plurality of graph genome edges. The system then generates a graph data structure for the received graph reference genome definition including a reference sequence count specifying the number of a plurality of reference sequences (e.g., chromosomes). Furthermore, each of the plurality of reference sequences includes a unique reference sequence identifier and an edge count specifying the number of a plurality of graph genome edges corresponding to the reference sequence. Each of the plurality of graph genome edges includes (i) a unique edge identifier, (ii) an edge group identifier, each edge group identifier identifying an edge group to which the edge belongs, and the plurality of graph genome edges optionally belong to two or more different edge groups, (iii) an edge array including a character array including an empty string represented by the edge, and (iv) a number of connections associated with the edge. Each connection associated with the graph genome edge includes (a) a connecting edge identifier identifying a second edge to which the respective edge is connected, (b) a direction specifying whether the identified second edge is upstream or downstream of the respective edge, (c) a connection type specifying which of a plurality of different possible connection types the respective edge includes, and (d) a location specifying a location on the identified second edge or on the respective edge at which the connection occurs. The system then stores the generated graph data structure in memory.

[0007]

[0007] Generally, there is provided a method for representing a graph genome data structure in a memory of a computer system, the method including: receiving a graph reference genome definition including (i) a plurality of graph genome edges, each of which specifies a character sequence, and (ii) a plurality of links, which specify connections between the plurality of graph genome edges; and generating a graph data structure for the received graph reference genome definition including a reference sequence count specifying a number of a plurality of reference sequences (e.g., chromosomes), each of the plurality of reference sequences including a unique reference sequence identifier and an edge count specifying a number of a plurality of graph genome edges corresponding to the reference sequence, each of the plurality of graph genome edges including (i) a unique edge identifier and (ii) an edge count specifying a number of the plurality of graph genome edges corresponding to the reference sequence. and (iii) a number of connections associated with the edges, each connection associated with the graph genome edges including (a) a connecting edge identifier that identifies a second edge to which the respective edge is connected, (b) a direction that specifies whether the identified second edge is upstream or downstream of the respective edge, (c) a connection type that specifies which of a plurality of different possible connection types the respective edge includes, and (d) a location that specifies a location on the identified second edge or on the respective edge at which the connection occurs; and storing the generated graph data structure in memory.

[0008]

[0008] According to an embodiment, each link connection associated with a graph genome edge includes (a) a connecting edge identifier that identifies the second edge to which the respective edge is connected, (b) a direction that specifies whether the identified second edge is upstream or downstream of the respective edge, (c) a connection type that specifies which of a plurality of different possible connection types the respective edge includes, and (d) a position that specifies the position on the identified second edge or on the respective edge at which the connection occurs.

[0009]

[0009] In an embodiment, the connection type, which identifies which of multiple different possible connections each edge includes, includes at least the following different types of connections: (1) a connection between the endpoints of two edges; (2) a connection that connects the middle of each edge to or from an endpoint of another edge array; and (3) a connection that connects the endpoint of each edge to or from the middle of another edge array.

[0010]

[0010] According to an embodiment, the graph data structure further includes, for each of the plurality of graph genome edges, (iv) an edge group identifier, each edge group identifier identifying an edge group to which the edge belongs, and wherein the plurality of graph genome edges optionally belong to two or more different edge groups; (v) an edge rank specifying the rank of the edge within a set of overlapping edges in the reference genome, where a rank of 0 represents an underlying linear reference, with an increment of 1 for each further layer of overlap; and (vi) the number of characters in the character sequence represented by the edge.

[0011]

[0011] According to an embodiment, the graph data structure further includes an edge group count that specifies the number of edge groups in the graph genome, and each of the identified edge groups further includes a unique edge group identifier.

[0012]

[0012] According to an embodiment, each of the identified edge groups further comprises a version identifier that identifies the major and / or minor version of the graph genome to which the edge group was originally added.

[0013]

[0013] According to an embodiment, the method further includes receiving the graph data structure from the memory at a graph genome data structure decoder, decoding the received graph data structure by the graph genome data structure decoder to construct at least a portion of the graph genome, and providing the constructed graph genome.

[0014]

[0014] According to an embodiment, the method further includes receiving a plurality of graph genome edges from one or more new edge groups and updating the graph data structure including (i) updating an edge count, (ii) adding a new edge group identifier for each of the received plurality of graph genome edges, (iii) adding a unique edge sequence identifier for each of the received plurality of graph genome edges, (iv) adding a number of connections associated with each edge, and for each connection, adding the edge connection, connection type, and position, and (v) updating the edge group information to include the one or more new edge groups, and updating the stored graph data structure including storing the updated generated graph data structure in memory.

[0015] According to one aspect, there is a method for representing and processing a plurality of reads in a genomic data structure in a memory of a computer system, the method comprising: receiving a genomic dataset including information describing a plurality of genomic read alignments and further including a parameter indicating whether the reads are aligned to a graph reference genome or a linear reference genome; generating a data structure for a representation of the read alignment with inclusion of further data components for the graph-based alignment including: (i) a pathway information descriptor including pathway information for each genomic read, the pathway information including an arrangement of one or more edges of a plurality of edges in the graph reference genome to which the respective genomic read is aligned; and (ii) a start position descriptor for each genomic read including a start position for the genomic read alignment relative to the beginning of the pathway to which it is aligned; and storing the generated graph-based read alignment data structure in memory.

[0016]

[0016] According to an embodiment, the data structure further includes inclusion of a splice descriptor containing splicing information for each split segment of each genomic read that can be aligned to all possible positions in the reference genome.

[0017]

[0017] According to an embodiment, the method further includes inferring one or more new edges to the graph reference genome while adding the received plurality of genomic reads to the genome data structure when the plurality of genomic reads cannot be mapped to the graph reference genome, adding the plurality of genomic reads that cannot be mapped to the graph reference genome to the genome data structure using information from the one or more new edges, and storing the one or more inferred new edges as auxiliary edges in the graph reference genome.

[0018]

[0018] According to an embodiment, the method further includes receiving a genomic read dataset from the memory in a genomic read data structure decoder, decoding the graph reference genomic data structure from the memory in the graph genomic data structure decoder, decoding the received genomic read data structure by the genomic read data structure decoder to reconstruct at least a portion of the genomic read, and providing the reconstructed genomic read via a user interface.

[0019]

[0019] According to an embodiment, decoding the received genomic read data structure to construct at least a portion of a genomic read includes extracting spliced ​​sequences corresponding to aligned segments defined in the splice descriptor.

[0020]

[0020] According to an embodiment, the method further includes decoding and fusing one or more of the auxiliary edges into a graph reference genome data structure for decoding the genome read.

[0021]

[0021] According to an embodiment, the method further includes identifying a version of the graph reference genome to which the genome read dataset is aligned, and if the graph reference genome received at the decoder is of a later version, removing edges belonging to the later version as indicated by the version number of the associated edge group from the graph reference genome data structure before decoding the genome reads.

[0022] In various embodiments, the processor or controller is associated with one or more storage media (e.g., volatile and non-volatile computer memory, e.g., RAM, PROM, EPROM, and EEPROM, floppy disks, compact disks, optical disks, magnetic tapes, etc., generally referred to herein as "memory"). In some embodiments, the storage media may be encoded with one or more programs that, when executed in one or more processors and / or controllers, perform at least some of the functions described herein. The various storage media may be fixed within the processor or controller, or may be movable such that one or more programs stored on the various storage media can be loaded into the processor or controller to perform the various aspects described herein. The term "program" or "computer program" is used herein in a generic sense to refer to any type of computer code (e.g., software or microcode) that can be used to program one or more processors or controllers.

[0023]

[0023] It should be understood that all combinations of the above concepts and further concepts described in more detail below (provided that such concepts are not mutually inconsistent) are contemplated as part of the inventive subject matter disclosed herein. In particular, all combinations of subject matter described in the claims at the end of this disclosure are contemplated as part of the inventive subject matter disclosed herein. It should also be understood that terms explicitly used in this specification that also appear in any disclosure incorporated by reference should be given the meaning most consistent with the specific concepts disclosed herein.

[0024]

[0024] These and other aspects of the various embodiments will be apparent from and will be elucidated with reference to the embodiments described hereinafter.

[0025] In the drawings, like reference characters generally represent the same parts throughout the different views. Further, the drawings are not necessarily to scale, emphasis instead being placed upon illustrating the principles of various embodiments throughout. [Brief description of the drawings]

[0026] [Figure 1] 4 is a flowchart of a method for generating a graph data structure according to an embodiment. [Diagram 2]

[0027] 1 is a schematic diagram of a graph data structure system, according to an embodiment. [Diagram 3]

[0028] FIG. 1 is a schematic diagram of a graph-based reference genome according to the prior art. [Figure 4]

[0029] FIG. 1 is a schematic diagram of a graph-based reference genome according to the prior art. [Diagram 5]

[0030] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 6]

[0031] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 7]

[0032] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 8]

[0033] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 9]

[0034] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 10]

[0035] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 11]

[0036] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 12]

[0037] 1 is a flowchart of a method for generating a graph data structure according to an embodiment. [Figure 13]

[0038] 1 is a flowchart of a method for generating a graph data structure according to an embodiment. [Figure 14]

[0039] FIG. 1 is a schematic diagram of a graph-based reference genome according to an embodiment. [Figure 15]

[0040] 1 is a plot of sequencing read reconstruction time versus number of edges in a path from a simulation experiment showing speed improvement using a novel graph data structure over existing approaches, in accordance with an embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0027]

[0041] The present disclosure describes various embodiments of systems and methods for generating and storing graph data structures including genetic information. Applicant has recognized and appreciated that it would be beneficial to provide methods and systems including a graph-based genome structure capable of representing the genomic diversity of a cohort. The graph data structure system receives a graph reference genome definition including a plurality of graph genome edges, each of which specifies a character sequence, and a plurality of links representing connections between the plurality of graph genome edges. The system then generates a graph data structure for the received graph reference genome definition including a reference sequence count specifying a number of a plurality of reference sequences (e.g., chromosomes). Further, each of the plurality of reference sequences includes a unique reference sequence identifier and an edge count specifying a number of a plurality of graph genome edges corresponding to the sequence. Each of the plurality of graph genome edges includes (i) a unique edge identifier, (ii) an edge group identifier, each edge group identifier identifying an edge group to which the edge belongs, and the plurality of graph genome edges optionally belong to two or more different edge groups, (iii) an edge array including a character sequence including an empty string represented by the edge, and (iv) a number of connections associated with the edge. And each connection associated with a graph genome edge includes (a) a connecting edge identifier that identifies the second edge to which the respective edge is connected, (b) a direction that specifies whether the identified second edge is upstream or downstream of the respective edge, (c) a connection type that specifies which of a plurality of different possible connection types the respective edge includes, and (d) a position that specifies the location on the identified second edge or on the respective edge at which the connection occurs. The system then stores the generated graph data structure in memory.

[0028]

[0042] Referring to Figure 1, in one embodiment, a flow chart of a method 100 for generating a graph data structure using a graph data structure system is shown. It should be understood that the method described in connection with the figure is provided by way of example only and does not limit the scope of the present disclosure. The graph data structure system may be any of the systems described or otherwise contemplated herein. The graph data structure system may be one system or multiple different systems.

[0029]

[0043] In step 110 of the method, a graph data structure system is provided. Referring to the embodiment of graph data structure system 200 shown in FIG. 2, for example, the system includes one or more of a processor 220, a memory 230, a user interface 240, a communication interface 250, and a storage 260 interconnected via one or more system buses 212. It will be understood that FIG. 2 constitutes an abstraction in some respects, and that the actual arrangement of the components of system 200 may differ from and be more complex than that shown. Moreover, graph data structure system 200 may be any of the systems described or otherwise contemplated herein. Other elements and components of graph data structure system 200 are disclosed and / or contemplated elsewhere herein.

[0030]

[0044] Referring to FIG. 3, a schematic diagram of a graph-based reference genome 300 is shown in which genomic variations are captured as edges associated with different nucleotide sequences according to the prior art. For example, in FIG. 3, the graph-based reference genome 300 includes multiple aligned genomic sequences (edges 312a, 312b, 312c, 312d, 312e, 312f, and 312g). The alignment utilizes a conventional reference, such as reference 310. The graph nature of the reference genome 300 allows genomic variations to be represented in the reference genome. For example, at position "A" of the reference genome 300, there are two genomic sequences 312a and 312b, which consequently represent two different variations in the reference genome. The variations can of course be any type of genomic variation, including but not limited to single nucleotide variants (SNVs), deletions, insertions, inversions, duplications, or any other genomic variation. At position "B" of the reference genome, there is one genomic sequence 312d, and therefore there is no genomic variation identified at this position yet. At position "C" of the reference genome, there are three different genomic sequences 312e, 312f, and 312g, which result in three different variations in the reference genome.

[0031]

[0045] Referring to Figure 4, according to the prior art, a schematic representation of a graph-based reference genome 400 is shown in which genomic variations are again captured as edges associated with different nucleotide sequences. This is a variation of the graph-based reference genome 300 from Figure 3, where a new genomic variation 312h has been identified and aligned with another genomic sequence. This new edge 312h is connected by a node 314 that extends from transition 314a at the end of edge 312d to transition 314b at the beginning of edge 312h. Thus, after the addition of this new edge to the graph-based reference genome, position "C" of the reference genome now contains four different genomic sequences 312e, 312f, 312g, and 312h, which represent the four different variations in the reference genome.

[0032]

[0046] Referring to FIG. 5, in one embodiment, a graph-based reference genome 500 is shown using a novel structure that represents genome diversity more completely and efficiently. In this embodiment, multiple genome sequences (edges 312a, 312b, 312c, 312d, 312e, 312f, and 312g) are aligned to generate a graph-based reference genome. Similar to the graph-based reference genomes in FIG. 3 and FIG. 4, the graph nature of the reference genome 500 allows genome variations to be represented in the reference genome. For example, at position "A" of the reference genome 300 (in FIG. 4), there are two genome sequences 312a and 312b, which result in two different variations in the reference genome. The variations can, of course, be any type of genome variation, including but not limited to single nucleotide variants (SNVs), deletions, insertions, inversions, duplications, or any other genome variation. At position "B" of the reference genome (in FIG. 4), there is one genome sequence 312d, and thus there is no genome variation identified at this position yet. As a result, at position "C" of the reference genome (in FIG. 4), there are three different genomic sequences 312e, 312f, and 312g representing three different variations in the reference genome.

[0033]

[0047] Unlike the graph-based reference genomes in Figures 3 and 4, this reference genome in Figure 5 includes two different types of edge transitions. As shown in Figure 5, the reference genome 500 includes a conventional transition from the end of one edge to the end of another edge. This conventional transition can be described as an end point edge transition. For example, edge 312a includes transition 314c from the end of the edge to transition 314d at the end of edge 312d. There are several other examples of end point edge transitions in Figure 5.

[0034]

[0048] However, reference genome 500 also includes novel transitions that may be defined as mid sequence edge transitions that transition from and / or to the extent of another edge rather than at the end of another edge. For example, in Figures 3 and 4, edge 312c transitions to edge 312d via an end point edge transition. However, in Figure 5, edge 312c transitions to edge 312b via end point edge transition 316a to mid sequence edge transition 316b. Similarly, edge 312f transitions to edge 312e via mid sequence edge transition 318a to end point edge transition 318b. Similarly, the graph also includes mid-arrangement edge transition 320a from edge 312a to end point edge transition 320b at one end of edge 312h, and end point edge transition 322a from the other end of edge 312h to mid-arrangement edge transition 322b of edge 312e.

[0035]

[0049] These novel mid sequence edge transitions offer many advantages over the prior art. For example, enabling mid sequence transitions reduces the total number of edges in the graph. Furthermore, since the inclusion of additional genomes in the graph does not require splitting any of the existing edges, mid sequence transitions enable backward compatibility of graph references, thus allowing graph structures inherited from previous versions to remain intact.

[0036]

[0050] New edges may be added to the graph-based reference genome. For example, ongoing research or sequencing may detect new genomic variations that must be represented in the graph-based reference genome 500. Referring to FIG. 6, in one embodiment, edge 312i represents a new genomic sequence. Edge 312i generally aligns with a region of the reference genome 600, but includes a genomic variation not yet discovered in genomic sequence 312a, 312b, 312c, or 312d. Thus, edge 312i may be added to the reference genome 600.

[0037]

[0051] As shown in Figure 7, a node connects the mid sequence edge transition 324 to the endpoint edge transition 326 at one end of edge 312i. Referring to Figure 8, a node connects the endpoint edge transition 328 at the other end of edge 312i to the mid sequence edge transition 330 located within edge 312d. The new edge 312i is now added to the graph-based reference genome 600.

[0038]

[0052] 9, in one embodiment, a graph-based reference genome 900 is shown that includes multiple edges with both edge transition types. There are many possible paths through the graph-based reference genome 900. For example, referring to FIG. 10, a possible path through the graph-based reference genome 900 that includes some or all of edges 312c, 312i, 312d, 312f, and 312e is shown in black shading. This is just one possible path through the reference genome 900.

[0039]

[0053] Referring to FIG. 11, in one embodiment, a graph-based reference genome 1100 is shown that includes multiple edges. In this embodiment, the edges are patterned to represent a common source of the edges. For example, edges 312a and 312e have the same pattern and are therefore obtained from the same sample or source. Edges 312c and 312g also have a common pattern and are obtained from the same sample or source, but a different sample or source than edges 312a and 312c. Edges 312i and 312h have a common pattern and are obtained from the same sample or source, but different from the previous sample or source. Finally, edges 312b, 312d, and 312f have a common pattern and are obtained from the same sample or source. In this example, edges 312b, 312d, and 312f correspond to the linear reference genome and have a rank of 0. Edges 312a and 312e have a rank higher than 0, for example rank 1, and so on.

[0040]

[0054] The representation of the reference genome may, but need not, include a visual indication of source or any other visual indicator, such as the color or patterning shown in Figure 11. Additionally, when the reference genome is stored in memory, the indication of source is the data points associated with the stored reference genome.

[0041]

[0055] According to an embodiment, the graph-based reference genome may be stored in a memory of a computer system as a graph data structure as described herein. The graph data structure represents a plurality of genome sequences and may include at least a portion of the reference genome. The reference genome may be for anything including a genome. The graph data structure thus includes a graph reference genome including a plurality of graph genome edges, each of which specifies a character sequence, and a plurality of links representing connections between the plurality of graph genome edges. Each of the plurality of graph genome edges represents a respective path through a portion of the graph reference genome.

[0042]

[0056] According to an embodiment, in step 120 of method 100 in Figure 1, a graph data structure system receives a definition of a graph reference genome. The received definition may include at least (i) a plurality of graph genome edges, each of which specifies a character sequence, where the character sequence may be a sequence of nucleotides, and (ii) a plurality of links representing connections between the plurality of graph genome edges. For example, the received definition of a graph reference genome may include a plurality of graph genome edges and a plurality of links, each of which represents a connection between two edges.

[0043]

[0057] There are many different methods and techniques available for obtaining a graph reference genome definition that includes a plurality of graph genome edges. For example, there are many different methods and techniques available for obtaining graph genome edges, including many different methods for exome and whole genome sequencing, among other sequencing methods and techniques. The input genome sequence is obtained from a sample obtained from an organism, or from genomic material left behind by an organism, or from many other sources. According to an embodiment, the graph reference genome definition is obtained by the graph data structure system from a database, or is otherwise received from a database. Alternatively, the graph reference genome definition is obtained by the graph data structure system from a local or remote data source that is not a database, or is otherwise received from a local or remote data source that is not a database.

[0044]

[0058] The received definition of the graph reference genome may be used immediately by the graph data structure system or may be stored in a local or remote database for downstream use in the method.

[0045]

[0059] In step 130 of the method, the graph data structure system generates a graph data structure for the received graph reference genome definition. The graph data structure may include one or more elements necessary to represent the received graph reference genome definition in memory. According to an embodiment, the graph data structure system includes an existing graph data structure, and the existing graph data structure is updated using the received graph reference genome definition.

[0046]

[0060] According to an embodiment, the graph data structure includes a reference sequence count that specifies the number of multiple reference sequences (e.g., chromosomes). In other words, the reference sequence count is the number of reference sequences as individual graphs in the raw reference. The reference sequence count can be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the reference sequence count is represented in the graph data structure as a seq_count, although many other representations are possible.

[0047]

[0061] The received graph reference genome definition includes a number of graph genome edges, each of which specifies a character sequence, and a number of links representing connections between the graph genome edges. According to an embodiment, each of the number of reference sequences includes a unique reference sequence identifier and an edge count specifying the number of the number of graph genome edges corresponding to that reference sequence. In other words, each reference sequence identifier is unique and corresponds to a sequence name. The edge count is the total number of edges in the graph of the reference sequence identified by the unique reference sequence identifier. The unique reference sequence identifier and the edge count can be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the unique reference sequence identifier is represented as sequence_ID[i] and the edge count is represented as edge_count[i], although many other representations are possible.

[0048]

[0062] According to an embodiment, each of a number of graph genome edges in the received graph reference genome definition includes (i) a unique edge identifier, (ii) an edge sequence including a character sequence represented by the edge, e.g., a gene sequence or an empty string, and (iii) a number of connections associated with the edge.

[0049]

[0063] The unique edge identifier, edge group identifier, edge sequence, and number of connections associated with an edge may be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the unique edge identifier is represented as edge_ID[i][j], the edge group identifier is represented as edge_group_ID[k] (referenced by the edge group index k=edge_group_idx[i][j]), the edge sequence is represented as edge_seq[i][j], and the number of connections associated with an edge is represented as n_conn[i][j], although many other representations are possible.

[0050]

[0064] According to an embodiment, each connection associated with a graph genome edge includes (a) a connecting edge identifier that identifies the second edge to which the respective edge is connected, (b) a direction that specifies whether the identified second edge is upstream or downstream of the respective edge, (c) a connection type that specifies which of a plurality of different possible connection types the respective edge includes, and (d) a position that specifies the location on the or respective identified second edge at which the connection occurs.

[0051]

[0065] The connecting edge identifier, direction, connection type, and position may be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the connecting edge identifier is represented by conn_edge_ID[i][j][k], the direction is represented by conn_is_upstream[i][j][k] (where conn_is_upstream[i][j][k] is a flag that, when set to 1, indicates that the connecting edge is upstream of the current edge, otherwise it indicates that the connecting edge is downstream), the connection type is represented by conn_type[i][j][k], and the position is represented by conn_pos[i][j][k], although many other representations are possible.

[0052]

[0066] According to an embodiment, the connection type identifies which of a plurality of different possible connections each edge includes. According to an embodiment, the different possible connections may include, but are not limited to, at least the following different types of connections: (1) a connection between the endpoints of two edges, (2) a connection that connects the middle of each edge to or from an endpoint of another edge array, and (3) a connection that connects the endpoint of each edge to or from the middle of another edge array.

[0053]

[0067] According to an embodiment, the graph data structure further includes, for each of the plurality of graph genome edges, (iv) an edge group identifier, each edge group identifier identifying an edge group to which the edge belongs, where a plurality of graph genome edges optionally belong to two or more different edge groups, (v) an edge rank specifying the rank of the edge within a collection of overlapping edges in the reference genome (optionally, e.g., a rank of 0 represents an underlying linear reference, with an increment of 1 for each further layer of overlap), and (vi) a string in the character array represented by the edge.

[0054]

[0068] According to embodiments, edge ranks and strings may be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, edge ranks are represented by edge_rank[i][j] and strings are represented by edge_len[i][j], although many other representations are possible.

[0055]

[0069] According to an embodiment, the graph data structure further includes an edge group count that specifies the number of edge groups in the graph genome. Each of the identified edge groups may further include a unique edge group identifier. According to an embodiment, the edge group count and the unique edge group identifier may be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the edge group count may be represented by edge_group_count and the unique edge group identifier may be represented by edge_group_ID[i], although many other representations are possible. Each of the identified edge groups may further include a version identifier that identifies the major and / or minor version of the graph genome to which the edge group was originally added. The version identifier may be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the version identifier may be represented by [edge_group_maj_ver[i],edge_group_min_ver[i]], although many other representations are possible.

[0056]

[0070] In method step 140, the generated graph data structure is stored in a memory. According to an embodiment, the memory is a memory or database of the graph data structure system. Alternatively, the memory is a local memory and / or a remote memory or database in communication with the graph data structure system. The generated graph data structure is stored in the memory using any method for storing the generated data structure in a memory.

[0057]

[0071] According to an embodiment, the graph data structure system updates the stored graph data structure. For example, the graph data structure system receives new sequencing data, reference genome data, and / or any other genome data represented in the graph data structure. Thus, in step 150 of the method, the graph data structure system receives a plurality of graph genome edges from one or more new edge groups. The plurality of graph genome edges may be received from any source. For example, the data may be received from a local or remote source. The data may be received from a local or remote database, a sequencing machine, and / or any other source.

[0058]

[0072] In step 152 of the method, the graph data structure system updates the stored graph data structure using the received graph genome edges. According to an embodiment, updating the stored graph data structure includes updating an edge count specifying the number of graph genome edges (based on the number of edges received in the received graph genome edges), and further includes adding a unique edge sequence identifier for each of the received graph genome edges. Updating the stored graph data structure further includes adding a new edge group identifier for each of the received graph genome edges. Updating the stored graph data structure further includes adding a number of connections associated with each of the received graph genome edges. And for each connection, updating the stored graph data structure includes adding an edge connection, a connection type, and a location. Updating the stored graph data structure may further include updating edge group information (e.g., information represented by edge_group_count, edge_group_ID[i], and edge_group_maj_ver[i], edge_group_min_ver[i]) to include one or more new edge groups.

[0059]

[0073] The updated graph data structure may then be stored in memory, for example in method step 140. According to an embodiment, the memory is a memory or database of the graph data structure system. Alternatively, the memory is a local and / or remote memory or database in communication with the graph data structure system. The updated graph data structure is stored in memory using any method for storing a generated data structure in memory.

[0060]

[0074] The graph data structure system may further decode the stored graph data structures. Because the graph data structure system includes logic or algorithms for generating the graph data structures, the graph data structure system may use the same logic or algorithms to reconstruct the graph genome from the graph data structures. According to an embodiment, the graph data structure system comprises a graph genome data structure decoder responsible for reconstructing, or decoding, or constructing at least a portion of the graph genome from the stored graph data structures using the methods and systems described or otherwise contemplated herein.

[0061]

[0075] Thus, in method step 160, a graph genome data structure decoder of the graph data structure system receives the graph data structure from a memory, which may be a local or remote memory, which may be a component of the graph data structure system or a remote system, or which is otherwise in communication with the graph data structure system. The received graph data structure may be used directly by the graph genome data structure decoder or may be stored for future use or analysis.

[0062]

[0076] In method step 170, a graph genome data structure decoder decodes the received graph data structure and constructs at least a portion of a graph genome from the data, resulting in a constructed graph genome. The graph genome data structure decoder decodes the received graph data structure using methods and systems described or otherwise contemplated herein.

[0063]

[0077] In step 180 of the method, the resulting constructed graph genome may be provided in any of a variety of different ways. For example, according to an embodiment, the constructed graph genome may be provided in a separate memory, represented in a data structure, or provided via a user interface of the graph data structure system. The user interface may be any device or system that allows the constructed graph genome to be communicated and / or received, including a display, a mouse, and / or a keyboard for receiving user commands. The user interface may be located with one or more other components of the graph data structure system, or may be located remotely from the graph data structure system and communicate via a wired and / or wireless communication network.

[0064]

[0078] Referring to FIG. 12, a flow chart of a method 1200 for representing and processing multiple reads in a genomic data structure in a memory of a computer system described or otherwise contemplated herein is shown, according to one embodiment. It should be understood that the method described in connection with the figure is provided by way of example only and does not limit the scope of the present disclosure. The computer system may be any of the systems described or otherwise contemplated herein. The computer system may be one system or multiple different systems.

[0065]

[0079] In step 1210 of the method, a graph data structure system is provided. Referring to the embodiment of graph data structure system 200 shown in FIG. 2, for example, the system includes one or more of a processor 220, a memory 230, a user interface 240, a communication interface 250, and a storage 260 interconnected via one or more system buses 212. It will be understood that FIG. 2 constitutes an abstraction in some respects, and that the actual arrangement of the components of system 200 may differ from and be more complex than that shown. Moreover, graph data structure system 200 may be any of the systems described or otherwise contemplated herein. Other elements and components of graph data structure system 200 are disclosed and / or contemplated elsewhere herein.

[0066]

[0080] In step 1220 of the method, the graph data structure system receives a genomic dataset including information describing a plurality of genomic read alignments, the genomic dataset further including a parameter indicating whether the reads are aligned to a graph reference genome or a linear reference genome. According to an embodiment, the parameter indicating whether the reads are aligned to a graph reference genome or a linear reference genome may be represented by any indicator. According to just one non-limiting embodiment, the parameter is represented as graph_ref_flag, although many other representations are possible.

[0067]

[0081] According to an embodiment, the genomic dataset is obtained by the graph data structure system from a database or is otherwise received from a database. Alternatively, the genomic dataset is obtained by the graph data structure system from a local or remote data source that is not a database or is otherwise received from a local or remote data source that is not a database.

[0068]

[0082] In step 1230 of the method, the graph data structure system generates a data structure - called a graph-based read alignment data structure - for a representation of the read alignment to the received genomic dataset. According to an embodiment, the graph-based read alignment data structure includes (i) a path information descriptor containing path information for each genomic read, the path information including one or more sequences of a plurality of edges in the graph reference genome to which the respective genomic read is aligned, and (ii) a start position descriptor for each genomic read including a start position for the genomic read alignment relative to the beginning of the path to which it is aligned. The path information descriptor and the start position descriptor can be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the path information descriptor can be represented by gr_path and the start position descriptor can be represented by gr_pos, although many other representations are possible.

[0069]

[0083] According to an embodiment, the graph-based read alignment data structure further comprises (iii) a splice descriptor that includes splicing information for each split segment of each genome read that can be aligned to all possible positions in the reference genome. The splice descriptor can be represented in the graph data structure in many different ways. According to just one non-limiting embodiment, the splice descriptor is represented by a splice, although many other representations are possible.

[0070]

[0084] In step 1270 of the method, the graph data structure system stores the generated graph-based read alignment data structure in a memory - with or without compression. According to an embodiment, the memory is a memory or database of the graph data structure system. Alternatively, the memory is a local memory and / or a remote memory or database in communication with the graph data structure system. The graph-based read alignment data structure is stored in the memory using any method for storing the generated data structure in a memory.

[0071]

[0085] In optional step 1240 of the method, the graph data structure system, while adding the received plurality of genomic reads to the genome data structure, identifies that one or more of the plurality of genomic reads cannot be mapped to the graph reference genome, and then infers or otherwise identifies one or more new edges to the graph reference genome for each of these genomic reads that cannot be mapped to the graph reference genome.

[0072]

[0086] Thus, in step 1250 of the method, the graph data structure system uses information from the one or more new edges to add multiple genomic reads to the genome data structure that cannot be mapped to the graph reference genome.

[0073]

[0087] In step 1260 of the method, the graph data structure system stores the inferred new edge or edges as auxiliary edges, storing them as data components in the read alignment data set or as an independent auxiliary data set of the new edges. According to an embodiment, during enhancement of the graph reference genome (e.g., upgrading to a newer version), more robust and frequently occurring edges can be merged into the current graph reference genome. According to an embodiment, the memory is a memory or database of the graph data structure system. Alternatively, the memory is a local memory and / or a remote memory or database in communication with the graph data structure system. The data is stored in the memory using any method for storing the generated data structure in the memory.

[0074]

[0088] According to an embodiment, the graph-based read alignment data structure may be decoded by a graph data structure system, e.g., by a genome read data structure decoder of the system, to generate a reconstructed genome read. Referring to FIG. 13, a method 1300 for generating a reconstructed genome read is shown according to one embodiment. It should be understood that the method described in connection with the figure is provided by way of example only and does not limit the scope of the present disclosure. In step 1310 of the method, a graph data structure system is provided, e.g., an embodiment of the graph data structure system 200 shown in FIG. 2. The system may be any of the systems described or otherwise contemplated herein. The system may be one system or multiple different systems.

[0075]

[0089] In method step 1320, a genomic read data structure decoder of the graph data structure system receives a genomic read dataset from memory, such as the genomic read dataset received in step 1220 of method 1200 in FIG. 12 for an embodiment where the genomic dataset is obtained by the graph data structure system from a database or is otherwise received from a database. Alternatively, the genomic dataset is obtained by the graph data structure system from a local or remote data source that is not a database or is otherwise received from a local or remote data source that is not a database.

[0076]

[0090] In method step 1330, a genomic read data structure decoder of the graph data structure system decodes the stored graph reference genomic data. The graph reference genomic data is obtained by the graph data structure system from a database or is otherwise received from a database. Alternatively, the genomic data set is obtained by the graph data structure system from a local or remote data source that is not a database or is otherwise received from a local or remote data source that is not a database. The graph reference genomic data is decoded using any of the methods described or otherwise contemplated herein.

[0077]

[0091] In method step 1340, a genomic read data structure decoder of the graph data structure system decodes the received genomic read data structure to reconstruct at least a portion of the genomic read. The received genomic read data structure is decoded to reconstruct at least a portion of the genomic read using any of the methods described or otherwise contemplated herein.

[0078]

[0092] According to an embodiment, decoding the received genomic read data structure to reconstruct at least a portion of the genomic read includes extracting spliced ​​sequences corresponding to the aligned segments defined in the splice descriptors.

[0079]

[0093] In step 1350 of the method, the graph data structure system provides the reconstructed genomic read. The reconstructed genomic read may be provided in any of a variety of different ways. For example, according to embodiments, the reconstructed genomic read may be provided in a separate memory, represented in a data structure, or provided via a user interface of the graph data structure system. The user interface may be any device or system that allows the reconstructed genomic read to be communicated and / or received, including a display, a mouse, and / or a keyboard for receiving user commands. The user interface may be located with one or more other components of the graph data structure system, or may be located remotely from the graph data structure system and communicate via a wired and / or wireless communication network.

[0080]

[0094] According to an embodiment, the received genomic data set includes one or more auxiliary edges, and thus, in step 1360 of the method, a genomic read data structure decoder of the graph data structure system decodes one or more of the auxiliary edges into a graph reference genomic data structure for decoding the genomic read.

[0081]

[0095] According to an embodiment, the method further comprises analyzing the version of the graph reference genome to which the genomic read dataset is aligned. Thus, in step 1370 of the method, the graph data structure system identifies the version of the graph reference genome to which the genomic read dataset is aligned. In step 1380, if the graph reference genome received at the decoder is of a later version, the graph data structure system removes edges belonging to the later version, as indicated by the version number of the associated edge group, from the graph reference genome data structure before decoding the genomic reads. Thus, the system may then return to step 1340 of the method to decode the genomic reads.

[0082]

[0096] 2, in one embodiment, a schematic diagram of a graph data structure system 200 is shown. System 200 may be any of the systems described or otherwise contemplated herein and may include any of the components described or otherwise contemplated herein.

[0083]

[0097] According to an embodiment, system 200 includes one or more of a processor 220, a memory 230, a user interface 240, a communication interface 250, and storage 260 interconnected via one or more system buses 212. It will be appreciated that Figure 2 constitutes an abstraction in some respects, and that the actual arrangement of components of system 200 may differ from and be more complex than that shown.

[0084]

[0098] According to an embodiment, the system 200 comprises a processor 220 capable of executing instructions stored in the memory 230 or storage 260 or otherwise processing data, for example to perform one or more steps of a method. The processor 220 is formed from one or more modules. The processor 220 may take any suitable form, including but not limited to a microprocessor, a microcontroller, multiple microcontrollers, a circuit, a field programmable gate array (FPGA), an application specific integrated circuit (ASIC), a processor, or multiple processors.

[0085]

[0099] The memory 230 may take any suitable form, including non-volatile memory and / or RAM. The memory 230 may include various memories, such as, for example, L1, L2, or L3 caches, or system memory. Thus, the memory 230 may include, among others, static random access memory (SRAM), dynamic RAM (DRAM), flash memory, read-only memory (ROM), or other similar memory devices. The memory may store, for example, an operating system. The RAM is used by the processor for temporary storage of data. According to an embodiment, the operating system includes code that, when executed by the processor, controls the operation of one or more components of the system 200. It will be apparent that in embodiments in which the processor implements one or more of the functions described herein in hardware, software that is described as corresponding to such functions in other embodiments may be omitted.

[0086]

[0100] User interface 240 includes one or more devices for enabling communication with a user. A user interface may be any device or system that enables information to be communicated and / or received, including a display, a mouse, and / or a keyboard for receiving user commands. In some embodiments, user interface 240 encompasses a command line interface or a graphical user interface that is presented to a remote terminal via communication interface 250. A user interface may be located with one or more other components of the system or may be located remotely from the system and communicate via a wired and / or wireless communication network.

[0087]

[0101] Communications interface 250 includes one or more devices for enabling communication with other hardware devices. For example, communications interface 250 includes a network interface card (NIC) configured to communicate according to the Ethernet protocol. Additionally, communications interface 250 implements a TCP / IP stack for communication according to the TCP / IP protocol. Various alternative or additional hardware or configurations for communications interface 250 are contemplated.

[0088]

[0102] Storage 260 includes one or more machine-readable storage media, such as read-only memory (ROM), random access memory (RAM), magnetic disk storage media, optical storage media, flash memory devices, or similar storage media. In various embodiments, storage 260 stores instructions for execution by processor 220 or data to be operated on by processor 220. For example, storage 260 stores operating system 261 for controlling various operations of system 200.

[0089]

[0103] It will be apparent that various information described as being stored in storage 260 may additionally or alternatively be stored in memory 230. In this regard, memory 230 may be considered to constitute a storage device, and storage 260 may be considered a memory. Various other configurations are envisioned. Moreover, both memory 230 and storage 260 are considered to be non-transitory machine-readable media. As used herein, the term non-transitory is understood to exclude transitory signals and to encompass all forms of storage, including both volatile and non-volatile memory.

[0090]

[0104] Although system 200 is shown including one of each of the described components, various components may be duplicated in various embodiments. For example, processor 220 may include multiple microprocessors configured to independently execute the methods described herein or configured to perform steps or subroutines of the methods described herein, such that the multiple processors cooperate to achieve the functionality described herein. Furthermore, when one or more components of system 200 are implemented by a cloud computing system, various hardware components may reside in separate physical systems. For example, processor 220 may include a first processor in a first server and a second processor in a second server. Many other variations and configurations are possible.

[0091]

[0105] According to an embodiment, storage 260 of system 200 stores one or more algorithms and / or instructions for performing one or more functions or steps of methods described or otherwise contemplated herein. For example, processor 220 comprises one or more of graph data structure generating instructions 262, decoding instructions 263, updating instructions 264, and / or reporting instructions 265.

[0092]

[0106] According to an embodiment, the graph data structure generation instructions 262 cause a graph data structure to be generated and stored in a system described or otherwise contemplated herein by means including, but not limited to, by means of the methods described in connection with FIG. 1 and other figures.

[0093]

[0107] According to an embodiment, the decode instructions 263 cause the system described or otherwise contemplated herein to decode the generated graph data structure by means including but not limited to by means in the manner described in connection with FIG. 1 and other figures.

[0094]

[0108] According to an embodiment, update instructions 264 cause the system to update the generated graph data structure as described or otherwise contemplated herein, by means including but not limited to by means of the methods described in connection with FIG. 1 and other figures.

[0095]

[0109] According to an embodiment, the reporting instructions 265 cause the system to provide an output including any of the information generated or stored by the graph data structure system. For example, the output includes information about the generated or stored graph data structure. The output further includes some or all of the available information about the generated or stored graph data structure. The output further includes a portion of the read alignment associated with the graph reference genome. The output is provided to a researcher or other user. The output is provided to a user via any mechanism including but not limited to displaying, visualizing, or otherwise providing information via a user interface. According to an embodiment, the information is communicated to a user interface and / or to another device via wired and / or wireless communication. For example, the system communicates the information to a mobile phone, computer, laptop, wearable device, and / or any other device configured to enable display and / or other communication of the report. The user interface may be any device or system that allows information to be communicated and / or received, including a display, mouse, and / or keyboard for receiving user commands.

[0096]

[0110] Thus, within the context of the disclosure herein, aspects of the embodiments take the form of a computer program product embodied in one or more non-transitory computer readable mediums including computer readable program code embodied thereon. Thus, according to one embodiment, a non-transitory computer readable storage medium is shown including computer program code instructions that, when executed by a processor, cause the processor to perform a method having the steps described in conjunction with Figures 1 and 14, although other steps are possible. The program code may be implemented entirely on the user's computer, partially on the user's computer, implemented as a stand-alone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server.

[0097]

[0111] Processing genome information, which includes comparing multiple genome sequences to a reference genome, aligning multiple genome sequences to the reference genome, and storing genome information in memory, involves millions or billions of calculations that the human mind is not equipped to perform even with a pen and pencil. Even the reference genome of the smallest genome contains millions of pieces of information. For example, next-generation DNA sequencing data contains hundreds of millions or even billions of reads.

[0098]

[0112] Thus, according to embodiments, the received definition of the graph reference genome includes a plurality of graph genome edges each specifying a character sequence, the plurality of graph genome edges including, among other options, 1000 or more edges, 10,000 or more edges, 100,000 or more edges, or 1,000,000 or more edges, each of which includes, among other options, a sequence of 10 or more characters, 100 or more characters, or 1,000 or more characters.

[0099]

[0113] Furthermore, the method described herein significantly improves the speed and functionality of the graph data structure system. For example, by implementing the method described herein, the graph data structure system includes a novel graph data structure that accelerates the system. In one simulation experiment, a significant improvement in read reconstruction speed was observed using the novel graph data model described or otherwise envisioned herein, with link information being fused into the edge data structure as connections, which is superior to a data model derived directly from the graph fragment assembly (GFA) format. The advantage becomes more pronounced as the number of edges increases, from 13.3% for a path with one edge to 15.8% for a path with six or more edges (see FIG. 15). Prior art systems are slower and less capable because they cannot provide this functionality. Thus, the method described herein significantly improves the speed and functionality of the graph data structure system.

[0100]

[0114] Working Example

[0115] Examples of possible applications of the methods and systems described or otherwise contemplated herein are described below. These examples are provided merely as possible embodiments of the methods and systems described or otherwise contemplated herein, and therefore do not limit or prohibit other possible variations and embodiments. The data structures and formats in which genomic data are packaged and stored may take any of a wide variety of forms. Although a particular form of data storage and manipulation is described below with reference to various embodiments, it is understood that this is merely one example of a data structure used by the graph data structure system described or otherwise contemplated herein. In these examples, MPEG-G specifications ISO / IEC 23092-1 "Transmission and storage and genomic information" (3rd edition) will be referred to simply as Part 1, and ISO / IEC 23092-2 "Encoding of genomic information" (3rd edition) will be referred to simply as Part 2.

[0101]

[0116] 1. Proposed syntax and semantics

[0117] 1.1.Data Structures

[0118] 1.1.1. Reference Box

[0119] According to an embodiment, in association with the reference data structure, fields may be included to specify that a graph reference genome is being used and its characteristics, such as the number of bits to represent the position on the edge (graph_edge_pos_32_bits_flag) and whether the edge connection can occur in the middle of the sequence (graph_with_mid_seq_branches). Table 1 contains a list of the reference box syntax.

[0102]

[0120] Table 1. Reference Box Syntax [Table 1]

[0103]

[0121] According to an embodiment, the graph data structure system includes the following semantics associated with Table 1:

[0104]

[0122] When the reference is a graph genome, graph_ref_flag may be set to 1, otherwise the reference is linear.

[0105]

[0123] When positions on edges in a graph reference are represented as 32-bit integers, graph_edge_pos_32_bits_flag can be set to 1. Otherwise, all edge positions are represented as 16-bit integers.

[0106]

[0124] graph_with_mid_seq_branches may be a flag which, when set to 1, indicates that the graph reference contains edges that branch off from / to other edges. Otherwise, all edges are connected at their endpoints. It is only relevant when graph_ref_flag is set to 1.

[0107]

[0125] reference_type may specify the type of external reference, and may take any of the values ​​in the first column of Table 2.

[0108]

[0126] Table 2. reference_type values [Table 2]

[0109]

[0127] 1.1.2. Dataset Header

[0128] According to an embodiment, further fields are included in association with the dataset header structure to specify one or more of the following:

[0110]

[0129] Auxiliary references (in addition to the primary reference) to which the read was aligned. The number of auxiliary references is specified by num_supp_refs. This is particularly useful for graph aligned reads with new edges generated during the alignment process to represent clusters of reads that cannot be properly mapped to the primary reference.

[0111]

[0130] Whether a secondary path delimiter is used (gr_second_path_delimiter) to indicate transitions between edges that branch off in the middle of a sequence.

[0112]

[0131] For graph references that support backward compatibility of the major and minor versions (ori_ref_maj_ver and ori_ref_min_ver) of the original reference genome to which the dataset was aligned, reads that were originally mapped to an earlier reference version can be reconstructed using the newer version of the reference.

[0113]

[0132] Table 3. Dataset Header Syntax [Table 3]

[0114]

[0133] According to an embodiment, the graph data structure system includes the following semantics associated with Table 3:

[0115]

[0134] num_supp_refs is the number of auxiliary references used by the dataset for the alignment in addition to the primary reference.

[0116]

[0135] For each reference, indexed by i (where i=0 for the primary reference) used by the dataset, the following fields are specified: reference_ID[i] is the unique identification number of the reference used by the dataset for the alignment.

[0117]

[0136] For each array indexed by j in the reference box identified by reference_ID[i], the following fields are specified:

[0118]

[0137] seq_ID[i][j]: Its value shall correspond to any of the varying values ​​of sequence_ID in the reference box, as specified in subclause 6.5.2.3.

[0119]

[0138] seq_blocks[i][j] is the number of access units per reference. A value of 0 means "not specified" (e.g. in the transmission format).

[0120]

[0139] It should be noted that references relating to the same dataset shall either all be linear based (graph_ref_flag==0) or all be graph based (graph_ref_flag==1), but not a mixture. Primary and auxiliary (if present) references are merged into a raw (graph) reference data structure used by the decoding process.

[0121]

[0140] ori_ref_maj_ver, ori_ref_min_ver are the major and minor versions, respectively, of the reference genome to which the reads in the dataset were aligned. Note that if backward compatibility is supported, the version of the original reference may be earlier than the version of the primary reference identified by reference_ID[0].

[0122]

[0141] gr_second_path_delimiter is a flag that, when set to 1, indicates that the secondary delimiter '>' (indicating a mid-array edge transition) is used to specify paths in the graph reference in addition to the primary delimiter '.' (indicating an end-point transition). Otherwise, it is set to 0 and only the primary delimiter is used.

[0123]

[0142] 1.1.3. Raw Graph Reference

[0143] This subclause may specify a new data structure used to represent a raw graph reference or a set of primary and auxiliary graph references. This structure shall be used to deliver the graph reference array to the decoder and to return the decoded graph reference array or a portion thereof from the decoder. If a raw graph reference is required to decode an access unit, this raw graph reference shall be made available to the decoder before any other data unit. To support backward compatibility of graph references, all edges belonging to edge groups of all versions later than that of the original reference of the dataset specified by ori_ref_maj_ver and ori_ref_min_ver in the dataset header shall be removed for decoding of the dataset.

[0124]

[0144] Table 4. Raw Graph Reference Syntax [Table 4]

[0125]

[0145] According to an embodiment, the graph data structure system includes the following semantics associated with Table 4:

[0126]

[0146] seq_count is the number of reference sequences as individual graphs in the raw reference.

[0127]

[0147] sequence_ID[i] is a reference sequence identifier. Each sequence_ID shall be unique and correspond to one sequence_name as specified in ISO / IEC 23092-1:2020, 6.5.2.3.3.

[0128]

[0148] edge_count[i] is the total number of edges in the graph of the reference sequence identified by sequence_ID[i].

[0129]

[0149] For each edge indexed by j in the graph of the reference sequence identified by sequence_ID[i], the following fields are specified: edge_ID[i][j] is a unique identifier for the edge in the graph. edge_group_idx[i][j] is an index into edge_group_ID[] indicating the ID of the group to which the edge belongs. Edges in the same group generally come from the same source. edge_rank[i][j] is the rank of the edge in the graph, 0 for edges in linear references and >0 otherwise. edge_len[i][j] is the string in the array represented by the edge. edge_seq[i][j] is the character array represented by the edge. n_conn[i][j] is the number of connections associated with the edge.

[0130]

[0150] For each connection associated with the edge indexed by k, the following fields are specified: conn_edge_ID[i][j][k] is the ID of the edge to which the current edge is connected. conn_is_upstream[i][j][k] is a flag that, when set to 1, indicates that the connecting edge is upstream of the current edge, i.e., a path can only traverse from the connecting edge to the current edge, but not vice versa. Otherwise, it is downstream.

[0131]

[0151] If the graph reference supports edges branching in or out of the middle of the edge array, the following additional fields are needed: conn_type[i][j][k] is the type of connection. Possible values ​​include 0 for a connection between the endpoints of two edges, 1 for a branch in the middle of the current edge array, and 2 for a connection that connects an endpoint of the current edge to / from the middle of another edge array. conn_pos[i][j][k] is the position at which the connection occurs on the current edge (when conn_type[i][j][k]==1) or on the connecting edge (when conn_type[i][j][k]==2). This value is omitted when the connection is at the endpoints of two edges (conn_type[i][j][k]==1).

[0132]

[0152] edge_group_count is the number of edge groups in the graph reference. Edge groups are generally used to indicate the source from which a set of edges originates.

[0133]

[0153] For each edge group, indexed by i, the following fields are specified: edge_group_ID[i] is a unique edge group identifier. edge_group_maj_ver[i], edge_group_min_ver[i] are the major and minor versions, respectively, of the graph reference to which the edge group was originally attached.

[0134]

[0154] edgePosSize is specified in the semantics of the data field graph_edge_pos_32_bits_flag in section 2.1.1.

[0135]

[0155] 14, in one embodiment, a schematic diagram of different types of edge connections or transitions for edge R01 is shown along with their corresponding parameters in the raw graph reference data structure (shown in a table). A connection or transition involves at least one end point of the edge.

[0136]

[0156] 1.2. Genomic Descriptors and Their Decoding Process

[0157] According to an embodiment, it is proposed to include three further descriptors in part 2 clause 8 for the representation of sequencing reads aligned to a graph reference genome: (1) splice holds the splicing / splitting information for each read alignment, allowing splices / splits of the same segment to be mapped to different reference sequences and pathways, (2) gr_path holds the pathway information for each read alignment, and (3) gr_pos holds the start position of each read alignment relative to the beginning of the pathway it is aligned to.

[0137]

[0158] Table 5. Genomic descriptors [Table 5]

[0138]

[0159] 1.2.1 Splice Descriptors

[0160] The splice descriptor holds the splicing / splitting information for each read alignment. It supports complex constructs where splices / splits are mapped to different pathways and reference sequences and are stored in multiple genome records and access units. All its subsequences are listed in Table 6. If splices / splits of the same read alignment always map to the same reference sequence and pathway (due to graph references), this descriptor can be omitted.

[0139]

[0161] The inputs to the decoding process (specified in Table 6) are the variables numberOfRecordSegments and numberOfAlignedRecordSegments specified in sub-clause 10.4.10 of Part 2, the variable numberOfAlignments and the array numberOfSegmentAlignments[] specified in sub-clause 10.4.12 of Part 2, the array readLength[] specified in sub-clause 10.4.9 of Part 2, the variable seqId set to sequence_ID specified in sub-clause 7.5.1.2 of Part 2, the reference box Decoder[] and the variable numberOfAlignments[] specified in sub-clause 10.4.13 of Part 2, the array readLength[] specified in sub-clause 10.4.14 of Part 2, the variable seqId set to sequence_ID specified in sub-clause 7.5.1.2 of Part 2, the reference box Decoder[] and the variable numberOfAlignments[] specified in sub-clause 10.4.15 of Part 2, the array readLength[] specified in sub-clause 10.4.16 of Part 2, the variable numberOfAlignments specified in sub-clause 10.4.17 of Part 2, the array numberOfSegmentAlignments[] specified in sub-clause 10.4.19 of Part 2, the variable numberOfAlignments specified in sub-clause 10.4.20 of Part 2, the array numberOfSegmentAlignments[] specified in sub-clause 10.4.3 of Part 2, the variable numberOfAlignments specified in sub-clause 10.4.4 of Part 2, the array numberOfSegmentAlignments[] specified in sub-clause 10.4.5 of Part 2, the variable numberOfAlignments specified in sub-clause 10.4. the variable graph_ref_flag specified in the data structure, the array gr_path_pos[] specified in the decoding step of the gr_path_pos descriptor, the array mappingPos[][] specified in sub-clause 10.4.2 of Part 2, the syntax element spliced_reads_flag specified in sub-clause 7.4.2 of Part 2, the variable classId specified in sub-clause 10.2.3 of Part 2, the array alignPtr[][] specified in sub-clause 10.4.12 of Part 2, and the array softClipSizes[][] specified in sub-clause 10.4.7 of Part 2.

[0140]

[0162] The output of this process is the following arrays providing splicing / splitting information for each read alignment: n_splices[][], the number of spliced ​​segments; splice_len[][][], the length of each of the spliced ​​segments; splice_mapped_len[][][], the mapped length of each of the spliced ​​segments; splice_seq_ID[][][], the ID of the reference sequence to which the spliced ​​segments were aligned; splice_pos[][][], the position of each of the spliced ​​segments (in case of linear referencing, the position is relative to the start of the reference sequence; in case of graph referencing, the position is relative to the start of the reference sequence). in this case, the position is relative to the start of the pathway to which the spliced ​​segment was aligned; splice_AU_ID[][][], the ID of the access unit to which the spliced ​​segment primarily belongs (if it matches the containing access unit, it is set to -1); splice_rec_idx[][][], the index of the genome record to which the spliced ​​segment primarily belongs (if it matches the containing genome record, it is set to -1); splice_same_path[][][], a flag that, when set to 1, indicates that the spliced ​​segment is in the same pathway as the previous one in the same read alignment.

[0141]

[0163] Note that all output arrays share the same multi-dimensional structure, the first being a template-specific alignment index, the second being the template index, and the third being the splice index, if available. The first two dimensions of these output arrays are directly matched to those of the arrays gr_path[][] and splice_path[][][] specified in the decoding of the gr_path descriptor, gr_path_pos[][] specified in the decoding of the gr_path_pos descriptor, and mappingPos[][] specified in subclause 10.4.10 of Part 2.

[0142]

[0164] In this description, subsequenceN is the subsequence identified by descriptor_subsequence_ID=N (ie, subsequenceN=decoded_symbols[1][N]).

[0143]

[0165] Table 6. Subsequences for descriptor_ID=18 (splice descriptor) [Table 6]

[0144]

[0166] Table 7. Decoding process of splice descriptor [Table 7] JPEG2025514695000009.jpg255158JPEG2025514695000010.jpg77170

[0145]

[0167] 1.2.2 gr_path Descriptor

[0168] The gr_path (Graph Reference Path) descriptor holds path information for each alignment or the first spliced ​​segment of an alignment. It shall be present in a compliant bitstream when the graph_ref_flag specified in the reference box identified by reference_ID[0] in the dataset header is set to 1. Its subarrays are listed in Table 8.

[0146]

[0169] Each gr_path descriptor is a string of ASCII characters. It is essentially a concatenated list of edge IDs separated by delimiters. The primary delimiter is the symbol "." to indicate an end transition. For graph references that support mid sequence transitions (graph_with_mid_seq_branches specified in the reference box is set to 1), when gr_second_path_delimiter specified in the dataset header is set to 1, a secondary delimiter of the symbol ">" is used to indicate a mid sequence transition.

[0147]

[0170] To make the representation of the path more compact, we denote the previous edge E i-1 If it is the only possible edge or one of the highest preferences in the graph, then i may be omitted. The edge omission rules are as follows: 1. Downstream E i-1 If both graph_with_mid_seq_branches and gr_second_path_delimiter are set to 1, then if the delimiter symbol is ">", then E i-1 Extract only edges that branch out from the middle of i-1 Extract only the edges connected to the endpoints of 2. In all possible downstream edges, E i-1 If there are one or more edges that belong to the same edge group as p and proceed to step 4. 3. If there is one among all possible downstream edges that belongs to the linear reference of rank 0, then it is the preferred edge E p is selected as. 4.E i ==E p If, then edge Ei may be omitted in the path.

[0148]

[0171] The omission rule is applied iteratively to all edges in the path except the first one. After path shortening, any consecutive sequences of "." at the ends may be removed.

[0149]

[0172] When the encodingMode_ID specified in Table 8 of Part 2 is set to 0, the syntax, semantics, and decoding process for the gr_path descriptor is that for the tokentype descriptor specified in sub-clause 10.4.20.

[0150]

[0173] When descriptor_ID is equal to 19, the output of the decoding step of the gr_path descriptor is the array decodedStrings[] specified in sub-clause 10.4.20.5 of Part 2.

[0151]

[0174] Table 9 shows the further inputs, namely, the value of numberOfTemplateSegments specified in sub-clause 7.4.2 of Part 2, the variable classId specified in sub-clause 10.2.3 of Part 2, the variable unpairedRead specified in sub-clause 10.4.10 of Part 2, the variable numberOfAlignments specified in sub-clause 10.4.12 of Part 2, and the arrays alignPtr[][] and numberOfSegmentMappings[], This shows how the arrays gr_path[][] and splice_path[][][] are operated on using the array gr_path_same_as_prev[] specified in the splice descriptor, the syntax element spliced_reads_flag specified in sub-clause 7.4.2 of Part 2, the variable numberOfAlignedRecordSegments specified in sub-clause 10.4.10 of Part 2, and the arrays n_splices[][] and splice_same_path[][][] specified in the splice descriptor decoding step.

[0152]

[0175] The output array gr_path[][][] holds the path of each unspliced ​​read alignment or the first spliced ​​segment. The output array splice_path[][][] holds the path of each spliced ​​segment of each read alignment.

[0153]

[0176] Note that for both output arrays, the first dimension represents the template-specific alignment index, while the second dimension represents the template index. The third dimension of the splice_path[][][] array represents the splice index. The first two dimensions of these output arrays are directly matched to those of the output arrays specified in the decoding of the splice descriptor, the gr_path_pos[][] specified in the decoding of the gr_path_pos descriptor, and the mappingPos[][] specified in subclause 10.4.10 of Part 2.

[0154]

[0177] Table 8. Subarrays for descriptor_ID=11, 15, and 19 (msar, rname, and gr_path descriptors) [Table 8]

[0155]

[0178] Table 9. Decoding process of gr_path descriptor [Table 9] JPEG2025514695000013.jpg79170

[0156]

[0179] gr_path_pos Descriptor

[0180] The gr_path_pos (graph reference path position) descriptor holds a position in a path marking the start of each of the aligned segments. It shall be present in a compliant bitstream when the graph_ref_flag specified in the reference box identified by reference_ID[0] in the dataset header is set to 1. Its subarrays are listed in Table 10.

[0157]

[0181] The inputs to the decoding process (as specified in Table 11) are the value of numberOfTemplateSegments specified in sub-clause 7.4.2 of Part 2, the variable classId specified in sub-clause 10.2.3 of Part 2, the variable unpairedRead specified in sub-clause 10.4.10 of Part 2, the variable numberOfAlignments, and the arrays alignPtr[][] and numberOfSegmentMappings[] specified in sub-clause 10.4.12 of Part 2.

[0158]

[0182] The output of this process is gr_path_same_as_prev[], which contains a flag that, if set to 1, indicates that the current alignment is on the same path as the previous one, and gr_path_pos[][], which contains the positions of all pairs of alignments on their respective paths, including the first index to the alignment pair and the second index to the template segment.

[0159]

[0183] Note that for the gr_path_pos[][] array, the first dimension represents the template-specific alignment index, while the second dimension represents the template index. They are directly matched to the first two dimensions of the output array specified in the decoding of the splice descriptor, gr_path[][] and splice_path[][][] specified in the decoding of the gr_path descriptor, and mappingPos[][] specified in subclause 10.4.10 of Part 2.

[0160]

[0184] Note that there is a one-to-one correspondence between the elements in gr_path[][], gr_path_pos[][] and mappingPos[][] specified in sub-clause 10.4.10 of Part 2, where gr_path[][0], gr_path_pos[][0] correspond to the alignment of read 1, and gr_path[][1], gr_path_pos[][1] correspond to the alignment of read 2.

[0161]

[0185] In this description, subsequenceN is the subsequence identified by descriptor_subsequence_ID=N (ie, subsequenceN=decoded_symbols[1][N]).

[0162]

[0186] Table 10. Subarray for descriptor_ID=20 (gr_path_pos descriptor) [Table 10]

[0163]

[0187] Table 11. Decoding process of gr_path_pos descriptor [Table 11]

[0164]

[0188] Note that the subsequence elements are ordered starting with the first read 1 alignment, followed by its paired or paired and unique read 2 alignments. The same ordering is then applied to the set of alignment pairs of the next unique read 1 alignment, and so on. The ordering of the alignment pairs is explained using the example in Table 12. The numbers in brackets represent alignment indices that have already appeared before, and the numbers in circles represent the subsequence ordering.

[0165]

[0189] Table 12. Examples of alignment indexing and ordering [Table 12]

[0166]

[0190] 2. Decoding process of graph aligned reads

[0191] 2.1. Decoding process of route sequence in graph reference

[0192] This process extracts nucleotide sequence spans from loci in a graph reference based on the following input arguments, as specified in Table 13: seqID, which is one of the sequence IDs specified in the raw graph reference; path, which is the sequence ID of a connected edge specified using the gr_path descriptor syntax; startPos, which is the zero-based starting position of the subject sequence relative to the beginning of the path; and segLen, which is the length of the subject sequence to be extracted.

[0167]

[0193] In addition, the process uses a raw graph reference structure that contains the data for the primary and any auxiliary graph references.

[0168]

[0194] The following are the main steps of the process: 1. Parse the path into an array of edge IDs and their associated transition types as indicated by their delimiter symbols. 2. Infer any omitted edges in the path 3. Check whether the edge-to-edge transition is valid in the graph reference 4. Identify the characteristics and location of edge-to-edge connection points 5. Extract the nucleotide sequence between the two connection points on each edge 6. Concatenate the extracted nucleotide sequences until the full length of the target sequence is reached

[0169]

[0195] Table 13. Decoding process of route sequence in graph reference [Table 13] JPEG2025514695000018.jpg187170

[0170]

[0196] The following string operators are defined:

[0171]

[0197] 1.strcat(s1,…,sN) returns the concatenation of strings s1 through sN. If any of the input strings s1 through sN is a single character, it is considered to be a string of length 1.

[0172]

[0198] 2.strlen(s) returns the length of the string s.

[0173]

[0199] 3. strtoc(s) returns all the characters in string s in an array conforming to the c(n) data type specified in subclause 6.3, where n corresponds to the length of string s.

[0174]

[0200] 4. substr(s,i,l) returns the substring from s starting at the (i+1)th character of length l. If (i+l)>strlen(s), it returns the substring from s up to length (strlen(s)-i) including the last character.

[0175]

[0201] The function find(keys, match_value) returns an array of indices for elements in the one-dimensional array keys containing the match_value, or a single index if the match_value is unique.

[0176]

[0202] The mathematical function Min(x,y) returns x if x<=y, and returns y if x>y.

[0177]

[0203] The notation return_error() is used herein to indicate that the decoding process should stop due to a decoding error that cannot be handled.

[0178]

[0204] The infer_omitted_edge() method (specified in Table 14) returns a guess at the ID of the edge immediately following pEdgeID[idx-1] in the path, based on its adjacent downstream edges in the graph reference and the transition type specified by pDelim[idx-1], if available. Note that if idx>=sizeof(pEdgeID), a new element is added to pEdgeID.

[0179]

[0205] Table 14. Methods for inferring omitted edges in a path [Table 14] JPEG2025514695000020.jpg155170

[0180]

[0206] If the edge identified by connEdgeID is an invalid upstream (connIsUpStream==1) or downstream (connIsUpStream==0) edge connected to the edge indexed by curEdgeIdx based on the graph reference, the validate_transition() method (specified in Table 15) returns -1. Otherwise, it returns the index for the connection that is being validated.

[0181]

[0207] Table 15. Methods for checking if an edge transition is valid in a graph reference [Table 15]

[0182]

[0208] 2.2. Decoding process of aligned reads (classes P, N, M, I, HM)

[0209] With reference to sub-clause 10.5.2 of Part 1 regarding the decoding process of aligned reads, further inputs specific to graph-based reads shall be included, namely the variable graph_ref_flag specified in the primary reference box of the dataset identified by reference_ID[0] in the dataset header, if graph_ref_flag==0, the arrays ref_sequence[][] and seq_start[] specified in sub-clause 7.3 of Part 1, and the array gr_path[0][] specified in the decoding process of the gr_path descriptor (descriptor_ID=19) if graph_ref_flag==1.

[0183]

[0210] The steps for obtaining sequences from the reference genome need to be adapted to handle graph-based references using the process for decoding path sequences in graph references described in the previous section. The modifications required to the decoding process specified in Table 87 of Part 1 are highlighted in Table 16.

[0184]

[0211] Note that the codes in Table 16 are for handling simple splicing constructs, where no information from the splice descriptor is used. For complex splicing constructs, the following substitutions can be made: 1.From: for (j = 0; j < numberOfSplicedSeg[i]; j++) { mappedLength = splicedSegLength[i][j] To: for (j = 0; j < n_splices[0][i]; j++) { mappedLength = splice_len[0][i][j] 2.From: splicedSequence[i][j] = get_gr_sequence(seqId, gr_path[0][i], splicedSegMappingPos[i][j], mappedLength) To: splicedSequence[i][j] = get_gr_sequence(splice_seq_ID[0][i][j], splice_path[0][i][j], splice_pos[0][i][j], mappedLength) Here, the arrays n_splices[][][], splice_len[][][], splice_seq_ID[][][], and splice_pos[][][] are specified in the decoding process of the splice descriptor, and the array splice_path[][][] is specified in the decoding process of the gr_path descriptor.

[0185]

[0212] Table 16. Sequence[] decoding process for aligned reads [Table 16]

[0186]

[0213] 2.3. Decoding process of splicedSegMappingPos[][]

[0214] With reference to sub-clause 10.4.10 of Part 1 regarding the decoding process of pair descriptors, further input specific to graph-based reads shall be included, namely the variable graph_ref_flag specified in the Primary Reference Box of the dataset identified by reference_ID[0] in the dataset header, and, if graph_ref_flag==1, the array gr_path_pos[0][] specified in the decoding process of the gr_path_pos descriptor (descriptor_ID=20).

[0187]

[0215] The modifications required to the decoding process of splicedSegMappingPos[][] specified in Table 6 of Part 1 are highlighted in Table 17.

[0188]

[0216] Table 17. Decoding process of pair descriptor for splicedSegMappingPos [Table 17]

[0189]

[0217] 2.4. Decoding process for Type 1 AU (Class P)

[0218] With reference to sub-clause 10.2.3 of Part 1 concerning the decoding process of one record within an access unit decoded with a binary value of type 1 (class P), the following steps shall be inserted after step 7: decoding the gr_path_pos descriptor if graph_ref_flag==1 in the primary reference box of the dataset identified by reference_ID[0] in the dataset header, decoding the splice descriptor if the syntax element spliced_reads_flag==1 specified in sub-clause 7.4.2 of Part 2, and decoding the gr_path descriptor if graph_ref_flag==1 in the primary reference box of the dataset identified by reference_ID[0] in the dataset header.

[0190]

[0219] 2.5. Decoding process of Type 4 AU (Class I)

[0220] With reference to sub-clause 10.2.6 of Part 1 concerning the decoding process of access units of type 4 (class I), further inputs specific to graph-based reads shall be included, namely the variable graph_ref_flag specified in the primary reference box of the dataset identified by reference_ID[0] in the dataset header, and, if graph_ref_flag==0, the arrays ref_sequence[][] and seq_start[] specified in sub-clause 7.3 of Part 1, and, if graph_ref_flag==1, the array gr_path[0][] specified in the decoding process of the gr_path descriptor (descriptor_ID=19).

[0191]

[0221] The modifications required in the sequence decoding process for the mismatches specified in Table 42 of Part 1 are highlighted in Table 18.

[0192]

[0222] Note that the codes in Table 18 are for handling simple splicing constructs where no information from the splice descriptor is used. For complex splicing constructs, the following substitutions can be made: From: splicedSequence[segment][splSeg][rlen - 1] = get_gr_sequence(seqId, gr_path[0][segment], splicedSegMappingPos[segment][splSeg] + rlen + indelsCount, 1) To: splicedSequence[segment][splSeg][rlen - 1] = get_gr_sequence(splice_seq_ID[0][segment][splSeg], splice_path[0][segment][splSeg], splice_pos[0][segment][splSeg] + rlen + indelsCount, 1) Here, the arrays splice_seq_ID[][][] and splice_pos[][][] are specified in the decoding process of the splice descriptor, and the array splice_path[][][] is specified in the decoding process of the gr_path descriptor.

[0193]

[0223] Table 18. Sequence Decoding Procedures for Mismatches in Class I and HM [Table 18]

[0194]

[0224] All definitions defined and used herein should be understood to take precedence over dictionary definitions, definitions in documents incorporated by reference, and / or ordinary meanings of the defined terms.

[0195]

[0225] The singular forms "a," "an," and "the" as used herein in the specification and claims of this disclosure should be understood to mean "at least one," unless expressly indicated otherwise.

[0196]

[0226] The term "and / or" as used in the specification of this disclosure and in the claims should be understood to mean "either or both" of the elements so conjoined, i.e., elements that are conjunctive in some cases and elements that are disjunctive in other cases. Multiple elements listed with "and / or" should be construed in the same manner, i.e., "one or more" of the elements so conjoined. Other elements may optionally be present other than the elements specifically identified by the term "and / or," whether related or unrelated to the elements specifically identified.

[0197]

[0227] When used in the specification of this disclosure and in the claims, "or" should be understood to have the same meaning as "and / or" as defined above. For example, when items are distinguished by a list, "or" or "and / or" shall be interpreted as non-exclusive, i.e., including at least one of the elements or list of elements, but also including more than one element and, optionally, including additional, unlisted items. Conversely, for example, an item designated as "only one of" or "only one of," or when used in the claims, designated as "consisting of," only includes only one element of the elements or list of elements. In general, the term "or" as used herein shall be interpreted as indicating exclusive alternatives (i.e., "one or the other, but not both") only when modified by terms of exclusivity, such as "either," "one of," "only one of," or "only one of."

[0198]

[0228] As used in the specification of this disclosure and in the claims, the phrase "at least one" in reference to a list of one or more elements should be understood to mean at least one element selected from any one or more of the elements included in the list of elements, but is not limited to including at least one of each of the elements specifically listed within the list of elements, and does not exclude any combination of elements in the list of elements. This definition further allows for the optional presence of elements other than those specifically identified in the list of elements to which the phrase "at least one" refers, whether related or unrelated to the specifically identified elements.

[0199]

[0229] It should also be understood that, unless expressly stated otherwise, in any method recited in the claims of this disclosure that includes more than one step or action, the order of the method steps or actions is not necessarily limited to the order in which the method steps or actions are recited.

[0200]

[0230] In the claims, and in the specification thus far, all transitional phrases such as "comprising," "including," "having," "having," "containing," "involving," "holding," "composed of," etc., are understood to be non-exclusive, i.e., meaning including, but not limited to. Only the transitional phrases "consisting of" and "consisting essentially of" shall be exclusive or semi-exclusive transitional phrases, respectively.

[0201]

[0231] While several embodiments of the present invention have been described and illustrated herein, those skilled in the art will readily conceive of various other means and / or structures for performing the functions and / or obtaining one or more of the results and / or advantages described herein, and each of such variations and / or modifications is deemed to fall within the scope of the embodiments of the present invention described herein. More generally, those skilled in the art will readily appreciate that all parameters, dimensions, materials, and configurations described herein are intended to be exemplary, and that the actual parameters, dimensions, materials, and / or configurations will depend on the particular application or applications in which the teachings of the present invention are used. Those skilled in the art will recognize or be able to ascertain, with no more than routine experimentation, many equivalents to the specific embodiments of the present invention described herein. It is therefore understood that the foregoing embodiments are presented by way of example only, and that, within the scope of the appended claims and equivalents, the embodiments of the present invention may be practiced otherwise than as specifically described and claimed. The inventive embodiments of the present disclosure relate to each individual function, system, article, material, kit, and / or method described herein. In addition, any combination of two or more such features, systems, articles, materials, kits, and / or methods is within the scope of the present disclosure, if such features, systems, articles, materials, kits, and / or methods are not mutually inconsistent.

Claims

1. A method performed by a computer to represent a graph genome data structure in the memory of a computer system, wherein the method is (i) receiving a definition of a graph reference genome, which includes a plurality of graph genome edges, each specifying a character sequence, and (ii) a plurality of links representing the connections between the plurality of graph genome edges. A step of generating a graph data structure for the definition of the received graph reference genome, which includes a reference sequence count specifying the number of multiple reference sequences, Each of the plurality of reference sequences includes a unique reference sequence identifier and an edge count that specifies the number of graph genome edges, Each of the plurality of graph genome edges includes (i) a unique edge identifier, (ii) an edge sequence representing the edge, which includes a character sequence containing an empty string, and (iii) several connections associated with the edge. The steps to generate, The steps include storing the generated graph data structure in memory, A method having

2. Each connection is associated with a graph genome edge, including (a) a connection edge identifier that identifies a second edge to which each of the edges is connected, (b) a direction that specifies whether the identified second edge is upstream or downstream of each of the edges, (c) a connection type that specifies which of a plurality of different possible connection types each of the edges includes, and (d) a location that specifies the location on the identified second edge or on each of the edges where the connection occurs. The method according to claim 1.

3. The connection type that identifies which of a plurality of different possible connections each of the aforementioned edges includes includes at least the following different types of connections: (1) a connection between the endpoints of two edges; (2) a connection that connects the middle of each of the aforementioned edges to or from the endpoint of another edge array; and (3) a connection that connects the endpoint of each of the aforementioned edges to or from the middle of another edge array. The method according to claim 1.

4. The graph data structure further includes, for each of the plurality of graph genome edges, (iv) an edge group identifier, each of which identifies the edge group to which the edge belongs, and the plurality of graph genome edges optionally belong to two or more different edge groups; (v) an edge rank specifying the rank of an edge within a group of overlapping edges in a reference genome, where a rank of 0 represents the underlying linear reference and increases by 1 for each further overlapping layer; and (vi) the number of characters in the character sequence represented by the edge. The method according to claim 1.

5. The graph data structure further includes an edge group count specifying the number of edge groups in the graph genome, and each identified edge group further includes a unique edge group identifier. The method according to claim 1.

6. Each identified edge group further includes a version identifier that identifies the major and / or minor version of the graph genome to which the edge group was first attached. The method according to claim 5.

7. The steps include receiving the graph data structure from memory in a graph genome data structure decoder, To construct at least a portion of the graph genome, the received graph data structure is decoded by a graph genome data structure decoder, The steps include providing the constructed graph genome, The method according to claim 1, further comprising:

8. The process further includes the step of updating the stored graph data structure, wherein the updating step is The steps include receiving multiple graph genome edges from one or more new edge groups, A step of updating the graph data structure, comprising: (i) updating the edge count; (ii) adding a new edge group identifier to each of the received plurality of graph genome edges; (iii) adding a unique edge sequence identifier to each of the received plurality of graph genome edges; (iv) adding several connections associated with each of the edges, and for each of the connections, adding an edge connection, connection type, and location; and (v) updating the edge group information to include one or more new edge groups. The steps include storing the updated generated graph data structure in the memory, The method according to claim 1, comprising:

9. A method performed by a computer for representing and processing multiple reads in a genome data structure in the memory of a computer system, wherein the method is The steps include receiving a genome dataset that includes information describing multiple genome read alignments, and further includes parameters indicating whether the reads are aligned to a graph reference genome or a linear reference genome, (i) A path information descriptor that includes path information for each genome read, wherein the path information includes the sequence of one or more edges of a plurality of edges in the graph reference genome to which each of the genome reads is aligned, (ii) A start position descriptor for each genome read, which includes a start position for the genome read alignment with respect to the beginning of the pathway in which each genome read is aligned, A step of generating a data structure for a read alignment representation, which includes the inclusion of further data components for graph-based alignment, The steps include storing the generated graph-based read alignment data structure in memory, A method having

10. The data structure further includes the inclusion of splice descriptors containing splicing information for each segment of each genome read that can be aligned to all possible locations in the reference genome. The method according to claim 9.

11. When multiple genome reads cannot be mapped to the graph reference genome, the process involves inferring one or more new edges to the graph reference genome by adding the received multiple genome reads to the genome data structure. The steps of using information from one or more new edges to add to the genome data structure a plurality of genome reads that cannot be mapped to the graph reference genome, The steps include storing one or more newly predicted edges as auxiliary edges in the graph reference genome, The method according to claim 9, further comprising:

12. The steps include receiving the genome read dataset from memory in the genome read data structure decoder, The steps include decoding the graph reference genome data structure from memory using a graph genome data structure decoder, The process involves the steps of decoding the received genome read data structure using a genome read data structure decoder in order to reconstruct at least a portion of the genome reads, The steps include providing the reconstructed genome reads via a user interface, The method according to claim 9, further comprising:

13. To construct at least a portion of the genome reads, the step of decoding the received genome read data structure includes the step of extracting spliced ​​sequences corresponding to aligned segments defined in the splice descriptor. The method according to claim 12.

14. The method further comprises the steps of decoding one or more of the auxiliary edges, and fusing the genome reads into the graph reference genome data structure for decoding. The method according to claim 12.

15. The steps include identifying the version of the graph reference genome to which the genome read dataset has been aligned, If the graph reference genome received by the decoder is a later version, the decoder includes the step of removing the edges belonging to the later version from the graph reference genome data structure, as indicated by the version number of the associated edge group, before decoding the genome reads. The method according to claim 12, further comprising:

Images