1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
|
.. sidebar:: ToC
.. contents::
.. _tutorial-datastructures-store-fragment-store:
Fragment Store
==============
Learning Objective
You will learn about the SeqAn FragmentStore for handling fragments.
The "fragments" are reads and the data structure is useful in the context of read mapping, genome assembly, and gene annotation.
After completing this tutorial, you will be able to use the most relevant functionality of the FragmentStore class.
Difficulty
Advanced
Duration
1 h
Prerequisites
:ref:`tutorial-getting-started`, :ref:`tutorial-datastructures-sequences`
Overview
--------
The :dox:`FragmentStore` is a data structure specifically designed for read mapping, genome assembly or gene annotation.
These tasks typically require lots of data structures that are related to each other like:
* reads, mate-pairs, reference genome
* pairwise alignments
* genome annotation
The Fragment Store subsumes all these data structures in an easy to use interface.
It represents a multiple alignment of millions of reads or mate-pairs against a reference genome consisting of multiple contigs.
Additionally, regions of the reference genome can be annotated with features like 'gene', 'mRNA', 'exon', 'intron' or custom features.
The Fragment Store supports I/O functions to read/write a read alignment in `SAM/BAM <https://samtools.sourceforge.net/>`_ or `AMOS <https://amos.sourceforge.net/wiki/index.php/AMOS>`_ format and to read/write annotations in `GFF <https://genome.ucsc.edu/FAQ/FAQformat.html#format3>`_ or `GTF <https://genome.ucsc.edu/FAQ/FAQformat.html#format4>`_ format.
The Fragment Store can be compared with a database where each table (called "store") is implemented as a :dox:`String` member of the :dox:`FragmentStore` class.
The rows of each table (implemented as structs) are referred by their ids which are their positions in the string and not stored explicitly (marked with ``*`` in the Figures 2 and 5).
The only exception is the alignedReadStore whose elements of type :dox:`AlignedReadStoreElement` contain an id-member as they may be rearranged in arbitrary order, e.g. by increasing genomic positions or by readId.
Many stores have an associated name store to store element names.
Each name store is a :dox:`StringSet` that stores the element name at the position of its id.
All stores are present in the Fragment Store and empty if unused.
The concrete types, e.g. the position types or read/contig alphabet, can be easily changed by defining a custom config struct which is a template parameter of the Fragment Store class.
Multiple Read Alignment
-----------------------
The Fragment Store can represent a multiple read alignment, i.e. is an alignment between the contigs and the set of reads, where one read can be aligned at zero, one or multiple positions of a contig.
In the multiple alignment the contig is represented by one line with gaps (``-``) and the remaining lines are to reads or read segments with gaps aligned to the contig.
The following figure shows one contig (the line at the top) and multiple reads aligned to it arranged as stairs (reads in lower-case align to the reverse strand):
::
TGAAAACTATATTTATGCTATTCAGTTCTAAATATAGAAATTGAAACAGCTGTGTTTAGTGCCTTTGTTCA-----ACCCCCTTGCAACAACCTTGAGAACCCCAGGGAATTTGTCAATGTCAGGGAAGGAGCATTTTGTCAGTTACCAAATGTGTTTATTACCAG
TGAAAACTATATT ATGCTATTCAGTTCTAAATATAGAAATTGAAACAG GTGTTTAGTGCCTTTGTTCA-----ACCCCCTTGCAACAAC aaccccagggaatttgtcaatgtcagggaaggagc ttttgtcagttaccaaatgtgtttattaccag
tgaa ctatatttatgctattcagttctaaatatagaaatt acagctgtgtttagtgcctttgttca-----acccccttg aacaaccttgagaaccccagggaatttgtcaatgt GGAAGGAGCATTTTGTCAGTTACCAAATGTGTTT TACCAG
TGAAAACTATAT TATGCTATTCAGTTCTAAATATAGAAATTGAAACA ctgtgtttagtgcctttgttca-----acccccttgcaac ACCTTGAGAACCCCAGGGAATTTGTCAATGTCAGG aggagcattttgtcagttaccaaatgtgtttatta at
TGAAAACTATATTTA gctattcagttctaaatatagaaattgaaacagct GTTTAGTGCCTTTGTTCACATAGACCCCCTTGCAA aaccttgagaaccccagggaatttgtcaatgtcag aggagcattttgtcagttaccaaatgtgtttatta AG
TGAAAACTATATTTATGCTATTCAGT GAAATTGAAACAGCTGTGTTTAGTGCCTTTGTTCA ccccttacaacaaccttgagaaccccagggaattt CAGGGAAGGAGCATTTTGTCAGTTACCAAATGTGT G
tgaaaactatatttatgctattcagt GCCTTTGTTCACATAGACCCCCTTGCAACAACCTT cagggaatttgtcaatgtcagggaaggagcatttt CAGTTACCAAATGTGTTTATTACCAG
tgaaaactatatttatgctattcagttcta AG-----ACCCCCTTGCAACAACCTTGAGAACCCCAGGGA ggaaggagcattttgtcagttaccaaatgtgttta
TGAAAACTATATTTATGCTATTCAGTTCTAA A-----ACCCCCTTGCAACAACCTTGAGAACCCCAGGGAA gaaaggagcattttgtcagttaccaaatgtgttta
TGAAAACTATATTTATGCTATTCAGTTCTAAA A-----ACCCCCTTGCAACAACCTTGAGAACCCCAGGGAA AGGAGCATTTTGTCAGTTACCAAATGTGTTTATTA
TGAAAACTATATTTATGCTATTCAGTTCTAAA TGCAACAACCTTGAGAACCCCAGGGAATTTGTCAA ggagcattttgtcagttaccaaatgtgtttattac
TGAAAACTATATTTATGCTATTCAGTTCTAAAT TGCAACAACCTTGAGAACCCCAGGGAATTTGTCAA GGAGCATTTTGTCAGTTACCAAATGTGTTTATTAC
TGAAAACTATATTTATGCTATTCAGTTCTAAAT TGCAACAACCTTGAGAACCCCAGGGAATTTGTCAA GGAGCATTTTGTCAGTTACCAAATGTGTTTATTAT
ctatatttatgctattcagttctaaatatagaaatt tgcaacaaccttgagaaccccagggaatttgtcaa GGAGCATTTTGTCAGTTACCAAATGTGTTTATTAC
ctatatttatgctattcagttctaaatatagaaatt CAACCTTGAGAACCCCAGGGAATTTGTCAATGTCA agcattttgtcagttaccaaatgtgtttattacca
TATTTATGCTATTCAGTTATAAATATAGAAATTGAAACAG CCTTGAGAACCCCAGGGAATTTGTCAATGTCAGGG agcattttgtcagttaccaaatgtgtttattacca
atttatgctattcagttctaaatatagaaattgaa CTTGAGAACCCCAGGGAATTTGTCAATGTCAGGGA GCATTTTGTCAGTTACCAAATGTGTTTATTACCAG
tttacgctattcagtactaaatatagaaattgaaa CTTGAGAACCCCAGGGAATTTGTCAATGTCAGGGA GCATTTTGTCAGTTACCAAATGTGTTTATTACCAG
ttatgctattcagttctaaatatagaaattgaaac gggaatttgtcaatgtcagggaaggagcattttgt AGTTACCAAATGTGTTTATTACCAG
* ***Figure 1:*** Multiple read alignment
The following figure shows which tables represent the multiple read alignment:
.. figure:: FragmentStore.png
:width: 600px
***Figure 2:*** Stores used to represent a multiple read alignment
The main table is the :dox:`FragmentStore::alignedReadStore` which stores :dox:`AlignedReadStoreElement AlignedReadStoreElements`.
Each entry is an alignment of a read (``readId``) and a contig (``contigId``).
Introduced gaps are stored as a string of gap anchors in the ``gaps`` member of the alignedReadStore entry and the contigStore entry.
The begin and end positions of the alignment are given by the ``beginPos`` and ``endPos`` members which are 0-based positions on the forward strand in gap space, i.e. positions in the gapped contig sequence.
If the read is aligned to the reverse strand it holds ``endPos < beginPos``.
However, the gaps are always related to the forward strand.
Additional information, e.g. the number of errors, an alignment score or additional alignment tags, are stored in the tables :dox:`FragmentStore::alignQualityStore` and :dox:`FragmentStore::alignedReadTagStore` at position ``id``, where ``id`` is a unique id of the :dox:`AlignedReadStoreElement`.
Paired-end or mate pair alignments are represented by two entries in the :dox:`FragmentStore::alignedReadStore` that have the same ``pairMatchId`` value (unequal to ``INVALID_ID``).
For orphaned read alignments holds ``pairMatchId == INVALID_ID``.
::
012345556789 sequence space
012345678901 gap space
contig ACCAC--GTTTG
read1 ACACGGT [2-9[
read2 ACGGTT-G [4-12[
The :dox:`FragmentStore::alignedReadStore` is the only store where the id (alignId in the figure) of an element is not implicitly given by its position.
The reason for this is that it is necessary in many cases to rearrange the elements of the alignedReadStore, e.g. increasingly by (contigId,beginPos), by readId or pairMatchId.
This can be done by :dox:`sortAlignedReads`.
If it is necessary to address an element by its id, the elements must be sorted by id first.
In the case that ids are not contiguously increasing, e.g. because some elements where removed, they must be renamed by a prior call of :dox:`FragmentStore#compactAlignedReads`.
Analogously the function :dox:`FragmentStore#compactPairMatchIds` renames ``pairMatchId`` values contiguously and replaces values that occur in only one alignment by ``INVALID_ID``.
Display Aligned Reads
^^^^^^^^^^^^^^^^^^^^^
The multiple read alignment can be displayed in text form or in a scalable graphics format (SVG).
Therefore first a stairs layout of the reads must be computed via :dox:`AlignedReadLayout#layoutAlignment` and stored in an :dox:`AlignedReadLayout`.
The function :dox:`AlignedReadLayout#printAlignment` can then be used to output a window (beginPos,endPos,firstLine,lastLine) of the read alignment against a contig either to a stream or ``SVGFile``.
The following small example demonstrates how to first load two contigs from a Fasta file and then import a read alignment given in SAM format:
.. includefrags:: demos/tutorial/fragment_store/display_aligned_reads.cpp
:fragment: includes
Then we create a stairs layout of the aligned reads and output a window from gapped position 0 to 150 and line 0 to 36 of the multiple alignments below contig 1 to standard out.
.. includefrags:: demos/tutorial/fragment_store/display_aligned_reads.cpp
:fragment: ascii
.. includefrags:: demos/tutorial/fragment_store/display_aligned_reads.cpp.stdout
The same window can also be exported as a scalable vector graphic in SVG format.
.. includefrags:: demos/tutorial/fragment_store/display_aligned_reads.cpp
:fragment: svg
.. figure:: ReadLayout.png
:width: 700px
'''Figure 3:''' SVG export of a multiple read alignment
Accessing Pairwise Alignments
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
In the next step, we want to access several pairwise alignments between reads and contig segments.
Therefore we first need to get the associated types that the Fragment Store uses to store contig and read sequences and gaps.
This can be done by the following typedefs:
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads.cpp
:fragment: typedefs
Now we want to extract and output the alignments from the :dox:`FragmentStore::alignedReadStore` at position 140,144,...,156.
First we store a reference of the alignedRead in ar as we need to access it multiple times.
The read sequence is neither stored in the readStore or alignedReadStore as many short sequences can more efficiently be stored in a separate :dox:`StringSet` like the readSeqStore.
We copy the read sequence into a local variable (defined outside the loop to save allocations/deallocations) as we need to compute the reverse-complement for reads that align to the reverse strand.
Then we create a :dox:`Gaps gaps` object that represent the alignment rows of the contig and the aligned read in the multiple sequence alignment.
The :dox:`Gaps` object requires references of the sequence and the gap-anchor string stored in the contigStore and the alignedReadStore.
We need to limit the view of the contig alignment row to the interval the read aligns to, i.e. the gap position interval [beginPos,endPos[.
After that we output both alignment rows.
.. tip::
The :dox:`Gaps` contains two :dox:`Holder` references to the sequence and the inserted gaps.
In our example these Holders are dependent and changes made to the Gaps object like the insertion/deletion of gaps would immediatly be persistent in the Fragment Store.
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads.cpp
:fragment: output
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads.cpp.stdout
Assignment 1
""""""""""""
.. container:: assignment
Type
Rview
Objective
Modify the example above, such that reads that align to the reverse strand are displayed in lower-case letters.
Difficulty
Easy
Hint
The Dna alphabet used in the fragment store doesn't support lower-case letters.
You have to use a string of chars for readSeq.
Solution
.. container:: foldable
As we copy the read sequence, it suffices to change the type of the target string readSeq and the sequence type of the read :dox:`Gaps` object into CharString, i.e. a :dox:`String` of ``char``.
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads2.cpp
:fragment: typedefs
Then, we not only need to reverse-complement readSeq if the read aligns to the reverse strand (``endPos < beginPos``) but also need to convert its letters into lower-case.
Therefor SeqAn provides the function :dox:`toLower`.
Alternatively, we could iterate over readSeq and add ('a'-'A') to its elements.
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads2.cpp
:fragment: output
Running this program results in the following output.
.. includefrags:: demos/tutorial/fragment_store/access_aligned_reads2.cpp.stdout
Gene Annotation
---------------
Annotations are represented as a tree that at least contains a root node where all annotations of children or grandchildren of.
A typical annotation tree looks as follows:
.. figure:: AnnotationTree.png
:width: 400px
***Figure 4:*** Annotation tree example
The following figure shows which tables represent the annotation tree:
.. figure:: AnnotationStore.png
:width: 600px
***Figure 5:*** Stores involved in gene annotation
Traversing the Annotation Tree
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The annotation tree can be traversed and accessed with the :dox:`AnnotationTreeIterator AnnotationTree Iterator`.
A new iterator can be created with :dox:`ContainerConcept#begin` given a reference to the :dox:`FragmentStore` and the tag ``AnnotationTree``:
.. includefrags:: demos/tutorial/fragment_store/base.cpp
:fragment: iterator
It starts at the root node and can be moved to adjacent tree nodes with the functions :dox:`AnnotationTreeIterator#goDown`, :dox:`AnnotationTreeIterator#goUp`, and :dox:`AnnotationTreeIterator#goRight`.
These functions return a boolean value that indicates whether the iterator could be moved.
The functions :dox:`AnnotationTreeIterator#isLeaf`, :dox:`AnnotationTreeIterator#isRoot`, :dox:`AnnotationTreeIterator#isLastChild` return the same boolean without moving the iterator.
With :dox:`AnnotationTreeIterator#goRoot` or :dox:`AnnotationTreeIterator#goTo` it can be moved to the root node or an arbitrary node given its annotationId.
If the iterator should not be moved but a new iterator at an adjacent nodes is required, the functions :dox:`AnnotationTreeIterator#nodeDown`, :dox:`AnnotationTreeIterator#nodeUp`, :dox:`AnnotationTreeIterator#nodeRight` can be used.
The AnnotationTree iterator supports a preorder DFS traversal and therefore can also be used in typical begin-end loops with the functions :dox:`RootedRandomAccessIteratorConcept#goBegin` (== :dox:`AnnotationTreeIterator#goRoot`), :dox:`RootedRandomAccessIteratorConcept#goEnd`, :dox:`InputIteratorConcept#goNext`, :dox:`RootedIteratorConcept#atBegin`, :dox:`RootedIteratorConcept#atEnd`.
During a preorder DFS, the descent into subtree can be skipped by :dox:`AnnotationTreeIterator#goNextRight`, or :dox:`AnnotationTreeIterator#goNextUp` which proceeds with the next sibling or returns to the parent node and proceeds with the next node in preorder DFS.
Accessing the Annotation Tree
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
To access or modify the node an iterator points at, the iterator returns the node's annotationId by the :dox:`IteratorAssociatedTypesConcept#value` function (== operator*).
With the annotationId the corresponding entry in the annotationStore could be modified manually or by using convenience functions.
The function :dox:`AnnotationTreeIterator#getAnnotation` returns a reference to the corresponding entry in the annotationStore.
:dox:`AnnotationTreeIterator#getName` and :dox:`AnnotationTreeIterator#setName` can be used to retrieve or change the identifier of the annotation element.
As some annotation file formats don't give every annotation a name, the function :dox:`AnnotationTreeIterator#getUniqueName` returns the name if non-empty or generates one using the type and id. The name of the parent node in the tree can be determined with :dox:`AnnotationTreeIterator#getParentName`.
The name of the annotation type, e.g. 'mRNA' or 'exon', can be determined and modified with :dox:`AnnotationTreeIterator#getType` and :dox:`AnnotationTreeIterator#setType`.
An annotation can not only reference a region of a contig but also contain additional information given as key-value pairs.
The value of a key can be retrieved or set by :dox:`AnnotationTreeIterator#getValueByKey` and :dox:`AnnotationTreeIterator#assignValueByKey assignValueByKeq`.
The values of a node can be cleared with :dox:`AnnotationTreeIterator#clearValues`.
A new node can be created as first child, last child, or right sibling of the current node with :dox:`AnnotationTreeIterator#createLeftChild createLeftChile`, :dox:`AnnotationTreeIterator#createRightChild`, or :dox:`AnnotationTreeIterator#createSibling`.
All three functions return an iterator to the newly created node.
The following tables summarizes the functions provided by the AnnotationTree iterator:
+----------------------------------------+--------------------------------------------------------+
| Function | Description |
+========================================+========================================================+
| getAnnotation, value | Return annotation object/id of current node |
+----------------------------------------+--------------------------------------------------------+
| [get/set]Name, [get/set]Type | Access name or type of current annotation object |
+----------------------------------------+--------------------------------------------------------+
| clearValues, [get/set]ValueByKey | Access associated values |
+----------------------------------------+--------------------------------------------------------+
| goBegin, goEnd, atBegin, atEnd | Go to or test for begin/end of DFS traversal |
+----------------------------------------+--------------------------------------------------------+
| goNext, goNextRight, goNextUp | go next, skip subtree or siblings during DFS traversal |
+----------------------------------------+--------------------------------------------------------+
| goRoot, goUp, goDown, goRight | Navigate through annotation tree |
+----------------------------------------+--------------------------------------------------------+
| create[Left/Right]Child, createSibling | Create new annotation nodes |
+----------------------------------------+--------------------------------------------------------+
| isRoot, isLeaf | Test for root/leaf node |
+----------------------------------------+--------------------------------------------------------+
File I/O
--------
Reads and Contigs
^^^^^^^^^^^^^^^^^
To efficiently load reads, use the function :dox:`FragmentStore#loadReads` which auto-detects the file format, supporting Fasta, Fastq, QSeq and Raw (see :dox:`AutoSeqFormat`), and uses memory mapping to efficiently load millions of reads, their names and quality values.
If not only one but two file names are given, :dox:`FragmentStore#loadReads` loads mate pairs or paired-end reads stored in two separate files.
Both files are required to contain the same number or reads and reads stored at the same line in both files are interpreted as pairs.
The function internally uses :dox:`FragmentStore#appendRead` or :dox:`FragmentStore#appendMatePair` and reads distributed over multiple files can be loaded with consecutive calls of :dox:`FragmentStore#loadReads`.
Contigs can be loaded with the function :dox:`FragmentStore#loadContigs`.
The function loads all contigs given in a single file or multiple files given a single file name or a :dox:`StringSet` of file names.
The function has an additional boolean parameter ``loadSeqs`` to load immediately load the contig sequence or if ``false`` load the sequence later with :dox:`FragmentStore#loadContig` to save memory, given the corresponding ``contigId``.
If the contig is accessed by multiple instances/threads the functions :dox:`FragmentStore#lockContig` and :dox:`FragmentStore#unlockContig` can be used to ensure that the contig is loaded and release it after use.
The function :dox:`FragmentStore#unlockAndFreeContig` can be used to clear the contig sequence and save memory if the contig is not locked by any instance.
To write all contigs to an open output stream use :dox:`FragmentStore#writeContigs`.
Multiple Read Alignments
^^^^^^^^^^^^^^^^^^^^^^^^
A multiple read alignment can be loaded from an open :dox:`BamFileIn` with :dox:`FragmentStore#readRecords`.
Similarly, it can be written to an open :dox:`BamFileOut` with :dox:`FragmentStore#writeRecords`.
As SAM supports a multiple read alignment (with padding operations in the CIGAR string) but does not enforce its use.
That means that a typical SAM file represents a set of pairwise (not multiple) alignments.
To convert all the pairwise alignments into a multiple alignments of all reads, :dox:`FragmentStore#read` internally calls the function :dox:`FragmentStore#convertPairWiseToGlobalAlignment`.
A prior call to :dox:`FragmentStore#loadReads` is not necessary (but possible) as SAM contains the read names, sequences and quality values.
Contigs can be loaded at any time.
If they are not loaded before reading a SAM file, empty sequences are created with the names referred in the SAM file.
A subsequent call of :dox:`FragmentStore#loadContigs` would load the sequences of these contigs, if they have the same identifier in the contig file.
Annotations
^^^^^^^^^^^
A annotation file can be read from an open :dox:`GffFileIn` or :dox:`UcscFileIn` with :dox:`FragmentStore#readRecords`.
Similarly, it can be written to an open :dox:`GffFileOut` with :dox:`FragmentStore#writeRecords`.
The :dox:`GffFileIn` is also able to detect and read GTF files in addition to GFF files.
As the knownGene.txt and knownIsoforms.txt files are two separate files used by the UCSC Genome Browser, they must be read by two consecutive calls of :dox:`FragmentStore#readRecords` (first knownGene.txt then knownIsoforms.txt).
An annotation can be loaded without loading the corresponding contigs.
In that case empty contigs are created in the contigStore with names given in the annonation.
A subsequent call of :dox:`FragmentStore#loadContigs` would load the sequences of these contigs, if they have the same identifier in the contig file.
Please note, that UCSC files cannot be written due to limitations of the file format.
Stores
------
The Fragment Store consists of the following tables:
Read Stores
^^^^^^^^^^^
+-------------------------------------+-----------------------------+--------------------------------------------------------------+
| Store | Description | Details |
+=====================================+=============================+==============================================================+
| :dox:`FragmentStore::readStore` | Reads | String mapping from ``readId`` to ``matePairId`` |
+-------------------------------------+-----------------------------+--------------------------------------------------------------+
| :dox:`FragmentStore::readSeqStore` | Read sequences | String mapping from ``readId`` to ``readSeq`` |
+-------------------------------------+-----------------------------+--------------------------------------------------------------+
| :dox:`FragmentStore::matePairStore` | Mate-pairs / pairs of reads | String mapping from ``matePairId`` to ``<readId[2], libId>`` |
+-------------------------------------+-----------------------------+--------------------------------------------------------------+
| :dox:`FragmentStore::libraryStore` | Mate-pair libraries | String mapping from ``libId`` to ``<mean, std>`` |
+-------------------------------------+-----------------------------+--------------------------------------------------------------+
Contig Stores
^^^^^^^^^^^^^
+---------------------------------------+--------------------------------------------------+---------------------------------------------------------------------------------+
| Store | Description | Details |
+=======================================+==================================================+=================================================================================+
| :dox:`FragmentStore::contigStore` | Contig sequences with gaps | String that maps from ``contigId`` to ``<contigSeq, contigGaps, contigFileId>`` |
+---------------------------------------+--------------------------------------------------+---------------------------------------------------------------------------------+
| :dox:`FragmentStore::contigFileStore` | Stores information how to load contigs on-demand | String that maps from ``contigFileId`` to ``<fileName, firstContigId>`` |
+---------------------------------------+--------------------------------------------------+---------------------------------------------------------------------------------+
Read Alignment Stores
^^^^^^^^^^^^^^^^^^^^^
+-------------------------------------------+-----------------------------------------+-----------------------------------------------------------------------------------------+
| Store | Description | Details |
+===========================================+=========================================+=========================================================================================+
| :dox:`FragmentStore::alignedReadStore` | Alignments of reads against contigs | String that stores ``<alignId, readId, contigId, pairMatchId, beginPos, endPos, gaps>`` |
+-------------------------------------------+-----------------------------------------+-----------------------------------------------------------------------------------------+
| :dox:`FragmentStore::alignedReadTagStore` | Additional alignment tags (used in SAM) | String that maps from ``alignId`` to ``alignTag`` |
+-------------------------------------------+-----------------------------------------+-----------------------------------------------------------------------------------------+
| :dox:`FragmentStore::alignQualityStore` | Mapping quality of read alignments | String that maps from ``alignId`` to ``<pairScore, score, errors>`` |
+-------------------------------------------+-----------------------------------------+-----------------------------------------------------------------------------------------+
Annotation Stores
^^^^^^^^^^^^^^^^^
+---------------------------------------+-------------------------------+----------------------------------------------------------------------------------------------------------------------------+
| Store | Description | Details |
+=======================================+===============================+============================================================================================================================+
| :dox:`FragmentStore::annotationStore` | Annotations of contig regions | String that maps from ``annoId`` to ``<contigId, typeId, beginPos, endPos, parentId, lastChildId, nextSiblingId, values>`` |
+---------------------------------------+-------------------------------+----------------------------------------------------------------------------------------------------------------------------+
Name Stores
^^^^^^^^^^^
+-------------------------------------------+-------------------------------+------------------------------------------------------+
| :dox:`FragmentStore::annotationNameStore` | Annotation names | String that maps from ``annoId`` to ``annoName`` |
+===========================================+===============================+======================================================+
| :dox:`FragmentStore::readNameStore` | Read identifiers (Fasta ID) | String that maps from ``readId`` to ``readName`` |
+-------------------------------------------+-------------------------------+------------------------------------------------------+
| :dox:`FragmentStore::contigNameStore` | Contig identifiers (Fasta ID) | String that maps from ``contigId`` to ``contigName`` |
+-------------------------------------------+-------------------------------+------------------------------------------------------+
| :dox:`FragmentStore::matePairNameStore` | Mate-pair identifiers | String that maps from ``contigId`` to ``contigName`` |
+-------------------------------------------+-------------------------------+------------------------------------------------------+
| :dox:`FragmentStore::libraryNameStore` | Mate-pair library identifiers | String that maps from ``libId`` to ``libName`` |
+-------------------------------------------+-------------------------------+------------------------------------------------------+
|
