to

Generate join from read alignment.

Examples

1 with (AlignmentChain) with (LocalAlignment) with (Flag)
2         {
3             auto frontExtension = ReadAlignment(
4                 SeededAlignment.from(AlignmentChain(
5                     3,
6                     Contig(1, 100),
7                     Contig(1, 10),
8                     emptyFlags,
9                     [
10                         LocalAlignment(
11                             Locus(2, 3),
12                             Locus(5, 6),
13                             0,
14                         ),
15                         LocalAlignment(
16                             Locus(5, 6),
17                             Locus(9, 10),
18                             0,
19                         ),
20                     ],
21                 )).front,
22             );
23             auto backExtension = ReadAlignment(
24                 SeededAlignment.from(AlignmentChain(
25                     5,
26                     Contig(1, 100),
27                     Contig(1, 10),
28                     emptyFlags,
29                     [
30                         LocalAlignment(
31                             Locus(94, 95),
32                             Locus(0, 1),
33                             0,
34                         ),
35                         LocalAlignment(
36                             Locus(97, 98),
37                             Locus(4, 5),
38                             0,
39                         ),
40                     ],
41                 )).front,
42             );
43             auto gap = ReadAlignment(
44                 SeededAlignment.from(AlignmentChain(
45                     11,
46                     Contig(1, 100),
47                     Contig(1, 10),
48                     Flags(complement),
49                     [
50                         LocalAlignment(
51                             Locus(94, 95),
52                             Locus(0, 1),
53                             0,
54                         ),
55                         LocalAlignment(
56                             Locus(97, 98),
57                             Locus(4, 5),
58                             0,
59                         ),
60                     ],
61                 )).front,
62                 SeededAlignment.from(AlignmentChain(
63                     12,
64                     Contig(2, 100),
65                     Contig(1, 10),
66                     emptyFlags,
67                     [
68                         LocalAlignment(
69                             Locus(94, 95),
70                             Locus(0, 1),
71                             0,
72                         ),
73                         LocalAlignment(
74                             Locus(97, 98),
75                             Locus(4, 5),
76                             0,
77                         ),
78                     ],
79                 )).front,
80             );
81 
82             auto join1 = frontExtension.to!(Join!(ReadAlignment[]));
83             auto join2 = backExtension.to!(Join!(ReadAlignment[]));
84             auto join3 = gap.to!(Join!(ReadAlignment[]));
85 
86             assert(join1.start == ContigNode(1, ContigPart.pre));
87             assert(join1.end == ContigNode(1, ContigPart.begin));
88             assert(join1.payload == [frontExtension]);
89 
90             assert(join2.start == ContigNode(1, ContigPart.end));
91             assert(join2.end == ContigNode(1, ContigPart.post));
92             assert(join2.payload == [backExtension]);
93 
94             assert(join3.start == ContigNode(1, ContigPart.end));
95             assert(join3.end == ContigNode(2, ContigPart.end));
96             assert(join3.payload == [gap]);
97         }

Meta