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
|
/*++
Module Name:
ChimericPairedEndAligner.h
Abstract:
A paired-end aligner calls into a different paired-end aligner, and if
it fails to find an alignment, aligns each of the reads singly. This handles
chimeric reads that would otherwise be unalignable.
Authors:
Bill Bolosky, June, 2013
Environment:
User mode service.
Revision History:
--*/
#pragma once
#include "PairedEndAligner.h"
#include "BaseAligner.h"
#include "BigAlloc.h"
class ChimericPairedEndAligner : public PairedEndAligner {
public:
ChimericPairedEndAligner(
GenomeIndex *index_,
unsigned maxReadSize,
unsigned maxHits,
unsigned maxK,
unsigned maxSeedsFromCommandLine,
double seedCoverage,
unsigned minWeightToCheck,
bool forceSpacing_,
unsigned extraSearchDepth,
bool noUkkonen,
bool noOrderedEvaluation,
bool noTruncation,
PairedEndAligner *underlyingPairedEndAligner_,
unsigned minReadLength_,
int maxSecondaryAlignmentsPerContig,
BigAllocator *allocator);
virtual ~ChimericPairedEndAligner();
static unsigned getMaxSingleEndSecondaryResults(unsigned maxSeedsToUse, double maxSeedCoverage, unsigned maxReadSize, unsigned maxHits, unsigned seedLength)
{
return BaseAligner::getMaxSecondaryResults(maxSeedsToUse, maxSeedCoverage, maxReadSize, maxHits, seedLength) * NUM_READS_PER_PAIR;
}
static size_t getBigAllocatorReservation(GenomeIndex * index, unsigned maxReadSize, unsigned maxHits, unsigned seedLen, unsigned maxSeedsFromCommandLine,
double seedCoverage, unsigned maxEditDistanceToConsider, unsigned maxExtraSearchDepth, unsigned maxCandidatePoolSize,
int maxSecondaryAlignmentsPerContig);
void *operator new(size_t size, BigAllocator *allocator) {_ASSERT(size == sizeof(ChimericPairedEndAligner)); return allocator->allocate(size);}
void operator delete(void *ptr, BigAllocator *allocator) {/* do nothing. Memory gets cleaned up when the allocator is deleted.*/}
virtual void align(
Read *read0,
Read *read1,
PairedAlignmentResult *result,
int maxEditDistanceForSecondaryResults,
int secondaryResultBufferSize,
int *nSecondaryResults,
PairedAlignmentResult *secondaryResults, // The caller passes in a buffer of secondaryResultBufferSize and it's filled in by AlignRead()
int singleSecondaryBufferSize,
int maxSecondaryAlignmentsToReturn,
int *nSingleEndSecondaryResultsForFirstRead,
int *nSingleEndSecondaryResultsForSecondRead,
SingleAlignmentResult *singleEndSecondaryResults // Single-end secondary alignments for when the paired-end alignment didn't work properly
);
void *operator new(size_t size) {return BigAlloc(size);}
void operator delete(void *ptr) {BigDealloc(ptr);}
virtual _int64 getLocationsScored() const {
return underlyingPairedEndAligner->getLocationsScored() + singleAligner->getLocationsScored();
}
private:
bool forceSpacing;
BaseAligner *singleAligner;
PairedEndAligner *underlyingPairedEndAligner;
// avoid allocation in aligner calls
IdPairVector* singleSecondary[2];
LandauVishkin<1> lv;
LandauVishkin<-1> reverseLV;
GenomeIndex *index;
unsigned minReadLength;
};
|
