void AlleleIdentity::PredictSequenceMotifSSE(const LocalReferenceContext &reference_context,
const TIonMotifSet & ErrorMotifs,
const ReferenceReader &ref_reader, int chr_idx) {
//cout << "Hello from PredictSequenceMotifSSE" << endl;
sse_prob_positive_strand = 0;
sse_prob_negative_strand = 0;
//long vcf_position = reference_context.position0+1;
long var_position = reference_context.position0 + left_anchor; // This points to the first deleted base
string seqContext;
// status.isHPIndel && status.isDeletion implies reference_context.my_hp_length.at(left_anchor) > 1
if (status.isHPIndel && status.isDeletion) {
// cout << start_pos << "\t" << variant_context.refBaseAtCandidatePosition << variant_context.ref_hp_length << "\t" << variant_context.refBaseLeft << variant_context.left_hp_length << "\t" << variant_context.refBaseRight << variant_context.right_hp_length << "\t";
unsigned context_left = var_position >= 10 ? 10 : var_position;
//if (var_position + reference_context.my_hp_length.at(left_anchor) + 10 < ref_reader.chr_size(chr_idx))
seqContext = ref_reader.substr(chr_idx, var_position - context_left, context_left + (unsigned int)reference_context.my_hp_length[left_anchor] + 10);
// else
// seqContext = ref_reader.substr(chr_idx, var_position - context_left);
if (seqContext.length() > 0 && context_left < seqContext.length()) {
sse_prob_positive_strand = ErrorMotifs.get_sse_probability(seqContext, context_left);
//cout << seqContext << "\t" << context_left << "\t" << sse_prob_positive_strand << "\t";
context_left = seqContext.length() - context_left - 1;
string reverse_seqContext;
ReverseComplement(seqContext, reverse_seqContext);
sse_prob_negative_strand = ErrorMotifs.get_sse_probability(reverse_seqContext, context_left);
// cout << reverse_seqContext << "\t" << context_left << "\t" << sse_prob_negative_strand << "\t";
}
}
}
string SpliceDoRealignement (PersistingThreadObjects &thread_objects, const Alignment ¤t_read, long variant_position,
bool &changed_alignment, int DEBUG, const ReferenceReader &ref_reader, int chr_idx) {
// We do not allow any clipping since we align a short substring
thread_objects.realigner.SetClipping(0, true);
string new_alignment;
// --- Get index positions at snp variant position
int read_idx = current_read.left_sc;
int ref_idx = current_read.alignment.Position;
unsigned int pretty_idx = 0;
while (pretty_idx < current_read.pretty_aln.length() and ref_idx < variant_position) {
IncrementAlignmentIndices(current_read.pretty_aln[pretty_idx], ref_idx, read_idx);
pretty_idx++;
}
if (DEBUG > 1)
cout << "Computed variant position as (red, ref, pretty) " << read_idx << " " << ref_idx << " " << pretty_idx << endl;
if (pretty_idx >= current_read.pretty_aln.length()
or ref_idx >= ref_reader.chr_size(chr_idx)
or read_idx >= (int)current_read.alignment.QueryBases.length() - current_read.right_sc)
return new_alignment;
// --- Get small sequence context for very local realignment ------------------------
int min_bases = 5;
// Looking at alignment to the left of variant position to find right place to cut sequence
int read_left = read_idx;
int ref_left = ref_idx;
unsigned int pretty_left = pretty_idx;
bool continue_looking = pretty_idx > 0;
while (continue_looking) {
pretty_left--;
DecrementAlignmentIndices(current_read.pretty_aln[pretty_left], ref_left, read_left);
// Stopping criterion
if (pretty_left < 1) {
continue_looking = false;
break;
}
if (ref_idx - ref_left < min_bases)
continue_looking = true;
else {
// make sure to start with a matching base and don't split large HPs
if (current_read.pretty_aln[pretty_left] != '|'
or (ref_reader.base(chr_idx,ref_left+1) == ref_reader.base(chr_idx,ref_left)))
continue_looking = true;
else
continue_looking = false;
}
}
if (DEBUG > 1)
cout << "Computed left realignment window as (red, ref, pretty) " << read_left << " " << ref_left << " " << pretty_left << endl;
// Looking at alignment to the right to find right place to cut sequence
int read_right = read_idx;
int ref_right = ref_idx;
unsigned int pretty_right = pretty_idx;
continue_looking = pretty_idx < current_read.pretty_aln.length()-1;
while (continue_looking) {
IncrementAlignmentIndices(current_read.pretty_aln[pretty_right], ref_right, read_right);
pretty_right++;
// Stopping criterion (half open interval)
if (pretty_right >= current_read.pretty_aln.length()
or ref_right >= ref_reader.chr_size(chr_idx)) {
continue_looking = false;
break;
}
if (ref_right - ref_idx < min_bases)
continue_looking = true;
else {
// make sure to stop with a matching base and don't split large HPs
if (current_read.pretty_aln[pretty_right-1] != '|'
or (ref_reader.base(chr_idx,ref_right-1) == ref_reader.base(chr_idx,ref_right)))
continue_looking = true;
else
continue_looking = false;
}
}
if (DEBUG > 1)
cout << "Computed right realignment window as (red, ref, pretty) " << read_right << " " << ref_right << " " << pretty_right << endl;
// Put in some sanity checks for alignment boundaries found...
// --- Realign -------------------------
unsigned int start_position_shift;
vector<CigarOp> new_cigar_data;
vector<MDelement> new_md_data;
// printouts
if (DEBUG > 1) {
thread_objects.realigner.verbose_ = true;
cout << "Realigned " << current_read.alignment.Name << " from " << endl;
}
if (read_left >= read_right and ref_left >= ref_right) {
if (DEBUG > 1)
cout << "ERROR: realignment window has zero size! " << endl;
return new_alignment;
}
string old_alignment = current_read.pretty_aln.substr(pretty_left, pretty_right-pretty_left);
thread_objects.realigner.SetSequences(current_read.alignment.QueryBases.substr(read_left, read_right-read_left),
ref_reader.substr(chr_idx, ref_left, ref_right-ref_left), old_alignment, true);
if (!thread_objects.realigner.computeSWalignment(new_cigar_data, new_md_data, start_position_shift)) {
if (DEBUG > 1)
cout << "ERROR: realignment failed! " << endl;
return new_alignment;
}
// --- Fuse realigned partial sequence back into pretty_aln string
new_alignment = current_read.pretty_aln;
if (old_alignment == thread_objects.realigner.pretty_aln()) {
changed_alignment = false;
}
else {
new_alignment.replace(pretty_left, (pretty_right-pretty_left), thread_objects.realigner.pretty_aln());
changed_alignment = true;
}
return new_alignment;
}
