void RegionCoverage::TrackReadsOnRegion( const BamTools::BamAlignment &aread, uint32_t endPos )
{
// track total and on-target reads
uint32_t readEnd = endPos ? endPos : aread.GetEndPosition();
uint32_t covType = ReadOnRegion( aread.RefID, aread.Position + 1, readEnd );
TargetContig *contig = m_contigList[m_rcovContigIdx];
if( aread.IsReverseStrand() ) {
++contig->fwdReads;
if( covType & 1 ) ++contig->fwdTrgReads;
} else {
++contig->revReads;
if( covType & 1 ) ++contig->revTrgReads;
}
}
bool ReadContainer::ParseRead(const BamTools::BamAlignment& aln,
AlignedRead* aligned_read,
map<pair<string,int>, string>& ref_ext_nucleotides) {
// get read ID
aligned_read->ID = aln.Name;
// get nucleotides
aligned_read->nucleotides = aln.QueryBases;
// get qualities
aligned_read->qualities = aln.Qualities;
// get strand
aligned_read->strand = aln.IsReverseStrand();
// get chrom
aligned_read->chrom = references.at(aln.RefID).RefName;
// get read start
aligned_read->read_start = aln.Position;
// get cigar
aligned_read->cigar_ops = aln.CigarData;
// get if mate pair
if (aln.IsSecondMate()) {
aligned_read->mate = 1;
} else {
aligned_read->mate = 0;
}
// Only process if it is the primary alignment
if (aligned_read->mate) {
return false;
}
// Get all the tag data
// don't process if partially spanning (from old lobSTR)
int partial = 0;
if (GetIntBamTag(aln, "XP", &partial)) {
if (partial == 1) return false;
}
// get read group
if (!GetStringBamTag(aln, "RG", &aligned_read->read_group)) {
stringstream msg;
msg << aln.Name << " Could not get read group.";
PrintMessageDieOnError(msg.str(), ERROR);
}
// get msStart
if (!GetIntBamTag(aln, "XS", &aligned_read->msStart)) {
stringstream msg;
msg << aln.Name << " from group " << aligned_read->read_group << " Could not get STR start coordinate. Did this bam file come from lobSTR?";
PrintMessageDieOnError(msg.str(), ERROR);
}
// get msEnd
if (!GetIntBamTag(aln, "XE", &aligned_read->msEnd)) {
stringstream msg;
msg << aln.Name << " from group " << aligned_read->read_group << " Could not get STR end coordinate. Did this bam file come from lobSTR?";
PrintMessageDieOnError(msg.str(), ERROR);
}
// get mapq. Try unsigned/signed
if (!GetIntBamTag(aln, "XQ", &aligned_read->mapq)) {
stringstream msg;
aligned_read->mapq = 0;
}
// get diff
if (!GetIntBamTag(aln, "XD", &aligned_read->diffFromRef)) {
return false;
}
// get mate dist
if (!GetIntBamTag(aln, "XM", &aligned_read->matedist)) {
aligned_read->matedist = 0;
}
// get STR seq
if (!GetStringBamTag(aln, "XR", &aligned_read->repseq)) {
stringstream msg;
msg << aln.Name << " from group " << aligned_read->read_group << " Could not get repseq.";
PrintMessageDieOnError(msg.str(), ERROR);
}
// get if stitched
if (!GetIntBamTag(aln, "XX", &aligned_read->stitched)) {
aligned_read->stitched = 0;
}
// get ref copy num
if (!GetFloatBamTag(aln, "XC", &aligned_read->refCopyNum)) {
stringstream msg;
msg << aln.Name << " from group " << aligned_read->read_group << " Could not get reference copy number.";
PrintMessageDieOnError(msg.str(), ERROR);
}
// get period
aligned_read->period = aligned_read->repseq.length();
if (include_flank) { // diff is just sum of differences in cigar
CIGAR_LIST cigar_list;
for (vector<BamTools::CigarOp>::const_iterator
it = aligned_read->cigar_ops.begin();
it != aligned_read->cigar_ops.end(); it++) {
CIGAR cig;
cig.num = (*it).Length;
cig.cigar_type = (*it).Type;
cigar_list.cigars.push_back(cig);
}
bool added_s;
bool cigar_had_s;
cigar_list.ResetString();
GenerateCorrectCigar(&cigar_list, aln.QueryBases,
&added_s, &cigar_had_s);
aligned_read->diffFromRef = GetSTRAllele(cigar_list);
}
// apply filters
if (unit) {
if (aligned_read->diffFromRef % aligned_read->period != 0){
filter_counter.increment(FilterCounter::NOT_UNIT);
return false;
}
}
if (abs(aligned_read->diffFromRef) > max_diff_ref) {
filter_counter.increment(FilterCounter::DIFF_FROM_REF);
return false;
}
if (aligned_read->mapq > max_mapq) {
filter_counter.increment(FilterCounter::MAPPING_QUALITY);
return false;
}
if (aligned_read->matedist > max_matedist) {
filter_counter.increment(FilterCounter::MATE_DIST);
return false;
}
// Check if the allele length is valid
if (aligned_read->diffFromRef + (aligned_read->refCopyNum*aligned_read->period) < MIN_ALLELE_SIZE) {
filter_counter.increment(FilterCounter::ALLELE_SIZE);
return false;
}
// check that read sufficiently spans STR
int max_read_start = aligned_read->msStart - min_border;
int min_read_stop = aligned_read->msEnd + min_border;
if (aln.Position > max_read_start || aln.GetEndPosition() < min_read_stop){
filter_counter.increment(FilterCounter::SPANNING_AMOUNT);
return false;
}
// check that both ends of the read contain sufficient perfect matches
if (min_read_end_match > 0){
map<pair<string,int>, string>::iterator loc_iter = ref_ext_nucleotides.find(pair<string,int>(aligned_read->chrom, aligned_read->msStart));
if (loc_iter == ref_ext_nucleotides.end())
PrintMessageDieOnError("No extended reference sequence found for locus", ERROR);
string ref_ext_seq = loc_iter->second;
pair<int,int> num_end_matches = AlignmentFilters::GetNumEndMatches(aligned_read, ref_ext_seq, aligned_read->msStart-extend);
if (num_end_matches.first < min_read_end_match || num_end_matches.second < min_read_end_match){
filter_counter.increment(FilterCounter::NUM_END_MATCHES);
return false;
}
}
// check that the prefix and suffix of the read match maximally compared to proximal reference locations
if (maximal_end_match_window > 0){
map<pair<string,int>, string>::iterator loc_iter = ref_ext_nucleotides.find(pair<string,int>(aligned_read->chrom, aligned_read->msStart));
if (loc_iter == ref_ext_nucleotides.end())
PrintMessageDieOnError("No extended reference sequence found for locus", ERROR);
string ref_ext_seq = loc_iter->second;
bool maximum_end_matches = AlignmentFilters::HasLargestEndMatches(aligned_read, ref_ext_seq, aligned_read->msStart-extend, maximal_end_match_window, maximal_end_match_window);
if (!maximum_end_matches){
filter_counter.increment(FilterCounter::NOT_MAXIMAL_END);
return false;
}
}
// check that both ends of the aligned read have sufficient bases before the first indel
if (min_bp_before_indel > 0){
pair<int, int> num_bps = AlignmentFilters::GetEndDistToIndel(aligned_read);
if (num_bps.first != -1 && num_bps.first < min_bp_before_indel){
filter_counter.increment(FilterCounter::BP_BEFORE_INDEL);
return false;
}
if (num_bps.second != -1 && num_bps.second < min_bp_before_indel){
filter_counter.increment(FilterCounter::BP_BEFORE_INDEL);
return false;
}
}
filter_counter.increment(FilterCounter::UNFILTERED);
return true;
}
void AmpliconRegionStatistics::TrackReadsOnRegion( const BamTools::BamAlignment &aread, uint32_t endPos )
{
// pseudo-random number generator 'seed' for resolving equivalent read assignments
static uint16_t clockSeed = 0;
// check/set first region read overlaps
uint32_t readSrt = aread.Position + 1;
uint32_t readEnd = endPos ? endPos : aread.GetEndPosition();
uint32_t covType = ReadOnRegion( aread.RefID, readSrt, readEnd );
// maintain base method of tracking total reads
TargetContig *contig = m_contigList[m_rcovContigIdx];
bool isRev = aread.IsReverseStrand();
if( isRev ) {
++contig->revReads;
} else {
++contig->fwdReads;
}
// Tracking of reads on target
if( covType & 1 ) {
// iterate over all regions overlapping read...
int32_t bestEndDist = -m_maxUpstreamPrimerStart;
int32_t bestOverlap = 0;
uint32_t numBestRegions = 0;
bool haveBestEnd = false;
for( TargetRegion *cur = m_rcovRegion; cur; cur = cur->next ) {
if( readEnd < cur->trgSrt ) break;
if( readSrt > m_rcovRegion->trgEnd ) continue;
// save stats for all overlapped reads
++(GetStats(cur)->overlaps);
// find most likely AmpliSeq primed region of those overlapped
// NOTE: can still be wrong for regions starting very close together, given 5' digestion uncertainty,
// coupled with read length and digestion uncertainty at 3'
int32_t dSrt = readSrt - cur->trgSrt;
int32_t dEnd = cur->trgEnd - readEnd;
int32_t endDist5p = isRev ? dEnd : dSrt;
// for non-amplicon reads, ends are ignored and only maximum overlap is employed to distinguish target region
if( m_ampliconReads ) {
// always select region that is closest start before 5p primer
if( endDist5p < 0 && endDist5p > bestEndDist ) {
haveBestEnd = true;
bestEndDist = endDist5p;
bestOverlap = 0; // force record best below
} else if( haveBestEnd && endDist5p != bestEndDist ) {
// region is not closer primed or same distance from false priming site
continue;
}
}
// save region based on max overlap for equivalent regions
if( dSrt < 0 ) dSrt = 0;
if( dEnd < 0 ) dEnd = 0;
int32_t overlap = cur->trgEnd - cur->trgSrt - dSrt - dEnd; // +1
if( overlap >= bestOverlap ) {
// if overlaps also match then default to region starting most 3'
// - cannot do better w/o knowing exact priming location, or possibly using ZA tag value
if( overlap == bestOverlap ) {
// stack multiple equivalent solutions
if( numBestRegions >= m_regionStackSize ) {
// safety code - only triggered if many targets overlapping read
m_regionStackSize <<= 1; // *2
m_regionStack = (TargetRegion **)realloc(
m_regionStack, m_regionStackSize * sizeof(TargetRegion *) );
}
} else {
// save new best solution - these values are the same for all equivalent solutions
bestOverlap = overlap;
numBestRegions = 0;
}
m_regionStack[numBestRegions++] = cur;
}
}
// pseudo-randomly choose best region of equivalent best regions
TargetRegion *bestRegion = m_regionStack[ clockSeed % numBestRegions ];
bool e2e_or_cov;
if( m_sigFacCoverage ) {
int32_t trgLen = bestRegion->trgEnd - bestRegion->trgSrt + 1;
e2e_or_cov = (double(bestOverlap+1)/trgLen >= m_sigFacCoverage);
} else {
int32_t dSrt = readSrt - bestRegion->trgSrt;
int32_t dEnd = bestRegion->trgEnd - readEnd;
if( dSrt < 0 ) dSrt = 0;
if( dEnd < 0 ) dEnd = 0;
e2e_or_cov = ((dSrt > dEnd ? dSrt : dEnd) <= m_maxE2eEndDist);
}
StatsData *stats = GetStats(bestRegion);
if( isRev ) {
++contig->revTrgReads;
++stats->revReads;
if( e2e_or_cov ) ++stats->rev_e2e;
} else {
++contig->fwdTrgReads;
++stats->fwdReads;
if( e2e_or_cov ) ++stats->fwd_e2e;
}
}
++clockSeed;
}
// Returns true if the paired reads are a short-insert pair
bool filterByGraph(StringGraph* pGraph,
const BamTools::RefVector& referenceVector,
BamTools::BamAlignment& record1,
BamTools::BamAlignment& record2)
{
std::string vertexID1 = referenceVector[record1.RefID].RefName;
std::string vertexID2 = referenceVector[record2.RefID].RefName;
// Get the vertices for this pair using the mapped IDs
Vertex* pX = pGraph->getVertex(vertexID1);
Vertex* pY = pGraph->getVertex(vertexID2);
// Ensure that the vertices are found
assert(pX != NULL && pY != NULL);
#ifdef DEBUG_CONNECT
std::cout << "Finding path from " << vertexID1 << " to " << vertexID2 << "\n";
#endif
EdgeDir walkDirectionXOut = ED_SENSE;
EdgeDir walkDirectionYIn = ED_SENSE;
// Flip walk directions if the alignment is to the reverse strand
if(record1.IsReverseStrand())
walkDirectionXOut = !walkDirectionXOut;
if(record2.IsReverseStrand())
walkDirectionYIn = !walkDirectionYIn;
int fromX = walkDirectionXOut == ED_SENSE ? record1.Position : record1.GetEndPosition();
int toY = walkDirectionYIn == ED_SENSE ? record2.Position : record2.GetEndPosition();
// Calculate the amount of contig X that already covers the fragment
// Using this number, we calculate how far we should search
int coveredX = walkDirectionXOut == ED_SENSE ? pX->getSeqLen() - fromX : fromX;
int maxWalkDistance = opt::maxDistance - coveredX;
bool bShortInsertPair = false;
if(pX == pY)
{
if(abs(record1.InsertSize) < opt::maxDistance)
bShortInsertPair = true;
}
else
{
SGWalkVector walks;
SGSearch::findWalks(pX, pY, walkDirectionXOut, maxWalkDistance, 10000, true, walks);
if(!walks.empty())
{
for(size_t i = 0; i < walks.size(); ++i)
{
std::string fragment = walks[i].getFragmentString(pX,
pY,
fromX,
toY,
walkDirectionXOut,
walkDirectionYIn);
if((int)fragment.size() < opt::maxDistance)
{
bShortInsertPair = true;
//std::cout << "Found completing fragment (" << pX->getID() << " -> " << pY->getID() << ": " << fragment.size() << "\n";
break;
}
}
}
}
return bShortInsertPair;
}