// Align the haplotype to the reference genome represented by the BWT/SSA pair
void HapgenUtil::alignHaplotypeToReferenceBWASW(const std::string& haplotype,
const BWTIndexSet& referenceIndex,
HapgenAlignmentVector& outAlignments)
{
PROFILE_FUNC("HapgenUtil::alignHaplotypesToReferenceBWASW")
LRAlignment::LRParams params;
params.zBest = 20;
for(size_t i = 0; i <= 1; ++i)
{
LRAlignment::LRHitVector hits;
std::string query = (i == 0) ? haplotype : reverseComplement(haplotype);
LRAlignment::bwaswAlignment(query, referenceIndex.pBWT, referenceIndex.pSSA, params, hits);
// Convert the hits into alignments
for(size_t j = 0; j < hits.size(); ++j)
{
int q_alignment_length = hits[j].q_end - hits[j].q_start;
// Skip non-complete alignments
if((int)haplotype.length() == q_alignment_length)
{
HapgenAlignment aln(hits[j].targetID, hits[j].t_start, hits[j].length, hits[j].G, i == 1);
outAlignments.push_back(aln);
}
}
}
}
// Coalesce a set of alignments into distinct locations
void HapgenUtil::coalesceAlignments(HapgenAlignmentVector& alignments)
{
if(alignments.empty())
return;
// Sort the alignments by reference id, then position
std::sort(alignments.begin(), alignments.end());
HapgenAlignmentVector outAlignments;
// Iterate over the alignments in sorted order
// If an alignment is distinct (=does not overlap) from the
// previous alignment, add it to the output collection.
// First alignment is always ok
outAlignments.push_back(alignments[alignments.size()-1]);
// Kees: start from back because alignments are sorted in order of increasing score
for(size_t i = alignments.size()-1; i-- > 0;)
{
// Check this alignment against the last alignment added to the output set
HapgenAlignment& prevAlign = outAlignments.back();
const HapgenAlignment& currAlign = alignments[i];
int s1 = prevAlign.position;
int e1 = s1 + prevAlign.length;
int s2 = currAlign.position;
int e2 = s2 + currAlign.length;
bool intersecting = Interval::isIntersecting(s1, e1, s2, e2);
if(prevAlign.referenceID != currAlign.referenceID || !intersecting)
{
outAlignments.push_back(currAlign);
}
else
{
// merge the intersecting alignment into a window that covers both
prevAlign.position = std::min(s1, s2);
prevAlign.length = std::max(e1, e2) - prevAlign.position;
}
}
alignments = outAlignments;
}
// Align the haplotype to the reference genome represented by the BWT/SSA pair
void HapgenUtil::alignHaplotypeToReferenceKmer(size_t k,
const std::string& haplotype,
const BWTIndexSet& referenceIndex,
const ReadTable* pReferenceTable,
HapgenAlignmentVector& outAlignments)
{
PROFILE_FUNC("HapgenUtil::alignHaplotypesToReferenceKmer")
int64_t max_interval_size = 4;
if(haplotype.size() < k)
return;
std::vector<int> event_count_vector;
std::vector<HapgenAlignment> tmp_alignments;
int min_events = std::numeric_limits<int>::max();
// Align forward and reverse haplotype to reference
for(size_t i = 0; i <= 1; ++i)
{
bool is_reverse = i == 1;
std::string query = is_reverse ? reverseComplement(haplotype) : haplotype;
// Find shared kmers between the haplotype and the reference
CandidateVector candidates;
size_t nqk = query.size() - k + 1;
for(size_t j = 0; j < nqk; ++j)
{
std::string kmer = query.substr(j, k);
// Find the interval of this kmer in the reference
BWTInterval interval = BWTAlgorithms::findInterval(referenceIndex, kmer);
if(!interval.isValid() || interval.size() >= max_interval_size)
continue; // not found or too repetitive
// Extract the reference location of these hits
for(int64_t k = interval.lower; k <= interval.upper; ++k)
{
SAElem elem = referenceIndex.pSSA->calcSA(k, referenceIndex.pBWT);
// Make a candidate alignment
CandidateKmerAlignment candidate;
candidate.query_index = j;
candidate.target_index = elem.getPos();
candidate.target_extrapolated_start = candidate.target_index - candidate.query_index;
candidate.target_extrapolated_end = candidate.target_extrapolated_start + query.size();
candidate.target_sequence_id = elem.getID();
candidates.push_back(candidate);
}
}
// Remove duplicate candidates
std::sort(candidates.begin(), candidates.end(), CandidateKmerAlignment::sortByStart);
CandidateVector::iterator new_end = std::unique(candidates.begin(), candidates.end(), CandidateKmerAlignment::equalByStart);
candidates.resize(new_end - candidates.begin());
for(size_t j = 0; j < candidates.size(); ++j)
{
// Extract window around reference
size_t window_size = 200;
int ref_start = candidates[j].target_extrapolated_start - window_size;
int ref_end = candidates[j].target_extrapolated_end + window_size;
const SeqItem& ref_record = pReferenceTable->getRead(candidates[j].target_sequence_id);
const DNAString& ref_sequence = ref_record.seq;
if(ref_start < 0)
ref_start = 0;
if(ref_end > (int)ref_sequence.length())
ref_end = ref_sequence.length();
std::string ref_substring = ref_sequence.substr(ref_start, ref_end - ref_start);
// Align haplotype to the reference
SequenceOverlap overlap = alignHaplotypeToReference(ref_substring, query);
if(overlap.score < 0 || !overlap.isValid())
continue;
int alignment_start = ref_start + overlap.match[0].start;
int alignment_end = ref_start + overlap.match[0].end; // inclusive
int alignment_length = alignment_end - alignment_start + 1;
// Crude count of the number of distinct variation events
bool has_indel = false;
int num_events = overlap.edit_distance;
std::stringstream c_parser(overlap.cigar);
int len;
char t;
while(c_parser >> len >> t)
{
assert(len > 0);
// Only count one event per insertion/deletion
if(t == 'D' || t == 'I')
{
num_events -= (len - 1);
has_indel = true;
}
}
// Skip poor alignments
double mismatch_rate = 1.0f - (overlap.getPercentIdentity() / 100.f);
if(mismatch_rate > 0.05f || overlap.total_columns < 50)
{
if(Verbosity::Instance().getPrintLevel() > 4)
{
printf("Haplotype Alignment - Ignoring low quality alignment (%.3lf, %dbp, %d events) to %s:%d\n",
1.0f - mismatch_rate, overlap.total_columns, num_events, ref_record.id.c_str(), ref_start);
}
continue;
}
bool is_snp = !has_indel && overlap.edit_distance == 1;
HapgenAlignment aln(candidates[j].target_sequence_id,
alignment_start,
alignment_length,
overlap.score,
num_events,
is_reverse,
is_snp);
tmp_alignments.push_back(aln);
event_count_vector.push_back(num_events);
if(Verbosity::Instance().getPrintLevel() > 4)
{
printf("Haplotype Alignment - Accepting alignment (%.3lf, %dbp, %d events) to %s:%d\n",
1.0f - mismatch_rate, overlap.total_columns, num_events, ref_record.id.c_str(), ref_start);
}
// Record the best edit distance
if(num_events < min_events)
min_events = num_events;
}
}
// Copy the best alignments into the output
int MAX_DIFF_TO_BEST = 10;
int MAX_EVENTS = 8;
assert(event_count_vector.size() == tmp_alignments.size());
for(size_t i = 0; i < event_count_vector.size(); ++i)
{
if(event_count_vector[i] <= MAX_EVENTS && event_count_vector[i] - min_events <= MAX_DIFF_TO_BEST)
outAlignments.push_back(tmp_alignments[i]);
else if(Verbosity::Instance().getPrintLevel() > 3)
printf("Haplotype Alignment - Ignoring alignment with too many events (%d)\n", event_count_vector[i]);
}
}
// Align the haplotype to the reference genome represented by the BWT/SSA pair
void HapgenUtil::alignHaplotypeToReferenceKmer(size_t k,
const std::string& haplotype,
const BWTIndexSet& referenceIndex,
const ReadTable* pReferenceTable,
HapgenAlignmentVector& outAlignments)
{
PROFILE_FUNC("HapgenUtil::alignHaplotypesToReferenceKmer")
int64_t max_interval_size = 4;
if(haplotype.size() < k)
return;
std::vector<int> event_count_vector;
std::vector<HapgenAlignment> tmp_alignments;
int min_events = std::numeric_limits<int>::max();
// Align forward and reverse haplotype to reference
for(size_t i = 0; i <= 1; ++i)
{
bool is_reverse = i == 1;
std::string query = is_reverse ? reverseComplement(haplotype) : haplotype;
// Find shared kmers between the haplotype and the reference
CandidateVector candidates;
size_t nqk = query.size() - k + 1;
for(size_t j = 0; j < nqk; ++j)
{
std::string kmer = query.substr(j, k);
// Find the interval of this kmer in the reference
BWTInterval interval = BWTAlgorithms::findInterval(referenceIndex, kmer);
if(!interval.isValid() || interval.size() >= max_interval_size)
continue; // not found or too repetitive
// Extract the reference location of these hits
for(int64_t k = interval.lower; k <= interval.upper; ++k)
{
SAElem elem = referenceIndex.pSSA->calcSA(k, referenceIndex.pBWT);
// Make a candidate alignment
CandidateKmerAlignment candidate;
candidate.query_index = j;
candidate.target_index = elem.getPos();
candidate.target_extrapolated_start = candidate.target_index - candidate.query_index;
candidate.target_extrapolated_end = candidate.target_extrapolated_start + query.size();
candidate.target_sequence_id = elem.getID();
candidates.push_back(candidate);
}
}
// Remove duplicate candidates
std::sort(candidates.begin(), candidates.end(), CandidateKmerAlignment::sortByStart);
CandidateVector::iterator new_end = std::unique(candidates.begin(), candidates.end(), CandidateKmerAlignment::equalByStart);
candidates.resize(new_end - candidates.begin());
for(size_t j = 0; j < candidates.size(); ++j)
{
// Extract window around reference
size_t window_size = 200;
int ref_start = candidates[j].target_extrapolated_start - window_size;
int ref_end = candidates[j].target_extrapolated_end + window_size;
const DNAString& ref_sequence = pReferenceTable->getRead(candidates[j].target_sequence_id).seq;
if(ref_start < 0)
ref_start = 0;
if(ref_end > (int)ref_sequence.length())
ref_end = ref_sequence.length();
std::string ref_substring = ref_sequence.substr(ref_start, ref_end - ref_start);
// Align haplotype to the reference
SequenceOverlap overlap = Overlapper::computeOverlap(query, ref_substring);
// Skip terrible alignments
double percent_aligned = (double)overlap.getOverlapLength() / query.size();
if(percent_aligned < 0.95f)
continue;
/*
// Skip alignments that are not full-length matches of the haplotype
if(overlap.match[0].start != 0 || overlap.match[0].end != (int)haplotype.size() - 1)
continue;
*/
int alignment_start = ref_start + overlap.match[1].start;
int alignment_end = ref_start + overlap.match[1].end; // inclusive
int alignment_length = alignment_end - alignment_start + 1;
// Crude count of the number of distinct variation events
int num_events = overlap.edit_distance;
std::stringstream c_parser(overlap.cigar);
int len;
char t;
while(c_parser >> len >> t)
{
assert(len > 0);
// Only count one event per insertion/deletion
if(t == 'D' || t == 'I')
num_events -= (len - 1);
}
HapgenAlignment aln(candidates[j].target_sequence_id, alignment_start, alignment_length, overlap.score, is_reverse);
tmp_alignments.push_back(aln);
event_count_vector.push_back(num_events);
// Record the best edit distance
if(num_events < min_events)
min_events = num_events;
}
}
// Copy the best alignments into the output
int MAX_DIFF_TO_BEST = 10;
int MAX_EVENTS = 8;
assert(event_count_vector.size() == tmp_alignments.size());
for(size_t i = 0; i < event_count_vector.size(); ++i)
{
if(event_count_vector[i] <= MAX_EVENTS && event_count_vector[i] - min_events <= MAX_DIFF_TO_BEST)
outAlignments.push_back(tmp_alignments[i]);
}
}
