// Saves an alignment into a file in fasta format.
void save_alignment(Alignment &al, std::string const &fname) {
std::ofstream ffile;
ffile.open(fname.c_str(), std::ios::out);
if (!ffile.is_open()) {
std::cout << "Could not open file: " << fname << std::endl;
}
print_alignment(al, ffile);
ffile.close();
}
void merge_both_alignments(vector<reference_index>& refindex, string sam_output_name, fragment_alignment& alignment_first,
fragment_alignment& alignment_second, ofstream& fp_sam, ofstream& fp_detail,
ofstream& fp_fastq, unordered_map<string, int>& umap)
{
if(alignment_first.gaps != 0 || alignment_second.gaps != 0)
{
if(DEBUG == 99)
fp_detail << "\n****************************************GAPS FOUND****************************************" << endl << endl;
return;
}
fragment_alignment pointer_first;
fragment_alignment pointer_second;
int first_start_index, second_start_index;
int first_last_index, second_last_index;
if(alignment_first.ref_start < alignment_second.ref_start)
{
first_start_index = alignment_first.ref_start;
first_last_index = alignment_second.ref_start;
second_start_index = alignment_first.ref_end;
second_last_index = alignment_second.ref_end;
pointer_first = alignment_first;
pointer_second = alignment_second;
}
else
{
first_start_index = alignment_second.ref_start;
first_last_index = alignment_first.ref_start;
second_start_index = alignment_second.ref_end;
second_last_index = alignment_first.ref_end;
pointer_first = alignment_second;
pointer_second = alignment_first;
}
if(first_last_index > second_start_index)
return;
if(second_last_index < second_start_index)
return;
/*
cout << "\nFind Problems in Merging" << endl;
cout << "First start index = " << first_start_index << endl;
cout << "First last index = " << first_last_index << endl;
cout << "Second start index = " << second_start_index << endl;
cout << "Second last index = " << second_last_index << endl;
*/
//linking reference base
int ref_start = 0, read_start = 0;
consensus *head_node = new consensus;
head_node->ref_ind = 0;
head_node->refch = refindex[0].ref.at(0);
head_node->read_ind = -1;
head_node->readch = '\0';
head_node->quality = 0;
head_node->next = NULL;
head_node->up = NULL;
head_node->down = NULL;
consensus *current_node = head_node;
for(int i = 1; i < refindex[0].ref.length(); i++)
{
consensus *next_node = new consensus;
next_node->ref_ind = i;
next_node->refch = refindex[0].ref.at(i);
next_node->read_ind = -1;
next_node->readch = '\0';
next_node->quality = 0;
next_node->next = NULL;
next_node->up = NULL;
next_node->down = NULL;
current_node->next = next_node;
current_node->up = next_node;
current_node = current_node->next;
}
fp_detail << endl << "Testing Reference Linked List" << endl;
current_node = head_node;
while(current_node != NULL)
{
fp_detail << "" << current_node->refch;
current_node = current_node->next;
}
fp_detail << endl << "Reference Linked List Printed" << endl << endl;
//first read alignment
consensus *previous_node = NULL;
int current_ref_ind = -1;
int current_read_ind = -1;
current_node = head_node;
for(int i = 0; i < pointer_first.alignment.size(); i++)
{
if(pointer_first.alignment[i].first != '-')
current_ref_ind += 1;
if(pointer_first.alignment[i].second != '-')
current_read_ind += 1;
if(current_ref_ind == current_node->ref_ind)
{
current_node->read_ind = current_read_ind;
current_node->readch = '-';
if(pointer_first.alignment[i].second != '-')
{
current_node->readch = pointer_first.alignment[i].second;
current_node->quality = pointer_first.quality.at(i);
}
previous_node = current_node;
current_node = current_node->next;
}
else
{
consensus *next_node = new consensus;
next_node->ref_ind = current_ref_ind;
next_node->refch = '-';
next_node->read_ind = current_read_ind;
next_node->readch = pointer_first.alignment[i].second;
current_node->quality = pointer_first.quality.at(i);
next_node->next = NULL;
next_node->up = NULL;
next_node->down = NULL;
next_node->next = current_node;
if(previous_node != NULL)
previous_node->next = next_node;
previous_node = next_node;
}
}
fp_detail << endl << "Testing Read_One Linked List" << endl;
current_node = head_node;
while(current_node != NULL)
{
fp_detail << "" << current_node->readch;
current_node = current_node->next;
}
fp_detail << endl << "Read_One Linked List Printed" << endl << endl;
//second read alignment
current_node = head_node;
while(current_node->ref_ind < first_last_index)
{
previous_node = current_node;
current_node = current_node->next;
}
current_ref_ind = first_last_index - 1;
current_read_ind = -1;
for(int i = 0; i < pointer_second.alignment.size(); i++)
{
if(pointer_second.alignment[i].first != '-')
current_ref_ind += 1;
if(pointer_second.alignment[i].second != '-')
current_read_ind += 1;
if(current_ref_ind == current_node->ref_ind)
{
if(current_node->quality < pointer_second.quality.at(i))
{
current_node->read_ind = current_read_ind;
current_node->readch = pointer_second.alignment[i].second;
current_node->quality = pointer_second.quality.at(i);
}
else
{
if(current_node->readch == '\0')
{
current_node->read_ind = current_read_ind;
current_node->readch = '-';
}
}
previous_node = current_node;
current_node = current_node->next;
}
else
{
consensus *next_node = new consensus;
next_node->ref_ind = current_ref_ind;
next_node->refch = '-';
next_node->read_ind = current_read_ind;
next_node->readch = pointer_second.alignment[i].second;
current_node->quality = pointer_second.quality.at(i);
next_node->next = NULL;
next_node->up = NULL;
next_node->down = NULL;
next_node->next = current_node;
previous_node->up = next_node;
previous_node = next_node;
}
}
fp_detail << endl << "Testing Read_Two Linked List" << endl;
current_node = head_node;
while(current_node != NULL)
{
fp_detail << "" << current_node->readch;
current_node = current_node->next;
}
fp_detail << endl << "Read_Two Linked List Printed" << endl << endl;
/*
consensus *head_node = new consensus;
ref_start = head_node->ref_ind = pointer_first.ref_start;
head_node->refch = pointer_first.alignment[0].first;
read_start = head_node->read_ind = pointer_first.read_start;
head_node->readch = pointer_first.alignment[0].second;
head_node->next = NULL;
head_node->up = NULL;
head_node->down = NULL;
consensus *current_node = head_node;
for(int i = 1; i < pointer_first.alignment.size(); i++)
{
consensus *next_node = new consensus;
if(pointer_first.alignment[i].first != '-')
ref_start += 1;
if(pointer_first.alignment[i].second != '-')
read_start += 1;
next_node->ref_ind = ref_start;
next_node->refch = pointer_first.alignment[0].first;
next_node->read_ind = read_start;
next_node->readch = pointer_first.alignment[0].second;
next_node->next = NULL;
next_node->up = NULL;
next_node->down = NULL;
current_node->next = next_node;
current_node = current_node->next;
}
*/
vector<pair<char, char> > alignment;
vector<char> quality;
int read_index_first, read_index_second;
int ref_index_first, ref_index_second;
int i, k, l, x;
int read_end, ref_end;
int match = 0, gaps = 0, mismatch = 0;
read_index_first = pointer_first.read_start;
ref_index_first = pointer_first.ref_start;
read_index_second = pointer_second.read_start;
ref_index_second = pointer_second.ref_start;
read_start = read_index_first;
ref_start = ref_index_first;
for(i = 0; ref_index_first < first_last_index && i < pointer_first.alignment.size(); i++)
{
alignment.push_back(pointer_first.alignment[i]);
//if(pointer_first.alignment[i].second != '-')
{
quality.push_back(pointer_first.quality.at(read_index_first));
read_index_first += 1;
}
//if(pointer_first.alignment[i].first != '-')
{
ref_index_first += 1;
}
}
//print_vector_alignment(alignment);
for(k = i, l = 0; ref_index_first < second_start_index && k < pointer_first.alignment.size(); k++, l++)
{
assert(ref_index_first == ref_index_second);
assert(pointer_first.alignment[k].first == pointer_second.alignment[l].first);
{
if(pointer_first.quality.at(read_index_first) >
pointer_second.quality.at(read_index_second))
{
alignment.push_back(pointer_first.alignment[k]);
quality.push_back(pointer_first.quality.at(read_index_first));
}
else
{
alignment.push_back(pointer_second.alignment[l]);
quality.push_back(pointer_second.quality.at(read_index_second));
}
}
ref_index_first += 1;
ref_index_second += 1;
read_index_first += 1;
read_index_second += 1;
}
//cout << endl << endl;
//print_vector_alignment(alignment);
for(x = l; ref_index_second < second_last_index && x < pointer_second.alignment.size(); x++)
{
alignment.push_back(pointer_second.alignment[x]);
//if(pointer_first.alignment[i].second != '-')
{
quality.push_back(pointer_second.quality.at(read_index_second));
read_index_second += 1;
}
//if(pointer_first.alignment[i].first != '-')
{
ref_index_second += 1;
}
}
read_end = read_index_second;
ref_end = ref_index_second;
string alignment_quality(quality.begin(), quality.end());
fragment_alignment final_alignment_info;
vector<string> final_result;
vector<char> read;
for(int k = 0; k < alignment.size(); k++)
{
final_alignment_info.alignment.push_back(alignment[k]);
if(alignment[k].first == alignment[k].second && alignment[k].first != '-')
match += 1;
if(alignment[k].first != alignment[k].second && alignment[k].first != '-')
mismatch += 1;
if(alignment[k].first == '-' || alignment[k].second == '-')
gaps += 1;
read.push_back(alignment[k].second);
}
//cout << endl << endl;
string readseq(read.begin(), read.end());
//print_vector_alignment(alignment);
final_alignment_info.total_len = alignment.size();
final_alignment_info.identity_match = match;
final_alignment_info.ref_start = ref_start;
final_alignment_info.read_start = read_start;
final_alignment_info.ref_end = ref_end;//total_ref_ind
final_alignment_info.read_end = read_end;//total_read_ind
final_alignment_info.ref_ind = 0;
final_alignment_info.read_dir = 1;
final_alignment_info.gaps = gaps;
final_alignment_info.mismatches = mismatch;
final_alignment_info.quality = alignment_quality;
sam_format(final_alignment_info, refindex, readseq, sam_output_name, final_result, fp_detail);
fp_sam << final_result[0];
for(int k = 1; k < final_result.size(); k++)
{
fp_sam << "\t" << final_result[k];
//cout << i << ": " << output[k] << endl;
}
fp_sam << endl;
/*
fp_fastq << "> " << final_result[0] << endl;
fp_fastq << final_result[9] << endl;
fp_fastq << "+" << endl;
fp_fastq << final_result[10] << endl;
*/
if(umap.find(final_result[5]) == umap.end())
{
umap[final_result[5]] = 1;
}
else
{
umap[final_result[5]] += 1;
return;
}
//fp_fastq << ">" << final_result[0] << "|CIGAR=" << final_result[5] << endl;
//fp_fastq << final_result[9] << endl;
fp_fastq << final_result[0] << endl;
fp_fastq << final_result[5] << endl;
fp_fastq << final_result[9] << endl;
print_alignment(final_alignment_info.alignment, refindex[0].ref, readseq, final_alignment_info.ref_start,
0, 1, final_alignment_info, true, fp_detail);
if(DEBUG == 99)
{
fp_detail << "reference = " << refindex[0].ref.substr(final_alignment_info.ref_start, 80) << endl;
fp_detail << "for_read = " << readseq.substr(0, 80) << endl << endl;
}
assert(alignment_quality.length() == readseq.length());
return;
}
void debug_sequence(const std::string& name, uint32_t seq_id, uint32_t read_id, const HMMInputSequence& sequence, const HMMInputData& data)
{
std::vector<HMMAlignmentState> alignment = profile_hmm_align(sequence, data);
print_alignment(name, seq_id, read_id, sequence, data, alignment);
}
/* Creates the output file with the alignment */
unsigned int results ( const char * filename, /* output filename */
struct TSeq * t, /* text */
unsigned int n, /* length of t */
struct TSeq * p, /* pattern */
unsigned int m, /* length of p */
double max_score,
unsigned int min_gap,
unsigned int where,
unsigned int gap_pos,
unsigned int swap,
unsigned int matrix,
double gap_penalty,
double ext_penalty )
{
FILE * output;
unsigned int min_mis = 0; //the number of mismatches in the alignment
char * seq_gap; //the sequence with the inserted gap
char * mark_mis; //a string with the mismatches marked as '|' (and the matches as ' ')
/* dynamic memory allocation for seq_gap */
if ( ! ( seq_gap = ( char * ) calloc ( n + 1 + min_gap + 1, sizeof ( char ) ) ) )
{
fprintf ( stderr, "Error: seq_gap could not be allocated!!!\n" );
return ( 0 );
}
/* dynamic memory allocation for mark_mis */
if ( ! ( mark_mis = ( char* ) calloc ( n + min_gap + 1, sizeof( char ) ) ) )
{
fprintf ( stderr, "Error: mark_mis could not be allocated!!!\n" );
return ( 0 );
}
if ( ! ( output = fopen ( filename, "w" ) ) )
{
fprintf ( stderr, "Error: cannot open file %s!!!\n", filename );
return ( 0 );
}
print_header ( output, filename, matrix, gap_penalty, ext_penalty );
if ( where == 1 ) //gap is in the text
{
print_alignment ( t -> data, n, p -> data, m, min_gap, gap_pos, seq_gap, mark_mis, &min_mis );
free ( t -> data );
t -> data = seq_gap;
if ( ! swap )
{
wrap ( t, p, mark_mis, LINE_LNG, output );
}
else
{
wrap ( p, t, mark_mis, LINE_LNG, output );
}
}
else //gap is in the pattern
{
print_alignment ( p -> data, m, t -> data, n, min_gap, gap_pos, seq_gap, mark_mis, &min_mis );
free ( p -> data );
p -> data = seq_gap;
if ( ! swap )
{
wrap ( t, p, mark_mis, LINE_LNG, output );
}
else
{
wrap ( p, t, mark_mis, LINE_LNG, output );
}
}
fprintf ( output, "\n" );
fprintf ( output, "Alignment score: %lf\n", max_score );
fprintf ( output, "Number of mismatches: %d\n", min_mis );
fprintf ( output, "Length of gap: %d\n", min_gap );
if( min_gap > 0 )
{
fprintf ( output, "The gap was inserted in %.13s after position %d\n", ( where == 1 ) ? t -> header : p -> header, gap_pos );
}
if ( fclose ( output ) )
fprintf ( stderr, "Error: cannot close file %s!!!\n", filename );
free ( mark_mis );
return ( 1 );
}
int main(int argc, char* argv[])
{
if(argc < 3)
{
std::cout
<< "Error: no se especificaron suficientes archivos de entrada."
<< std::endl;
return 1;
}
std::string filename1 = argv[1];
std::string filename2 = argv[2];
FASTAReader reader1(filename1);
FASTAReader reader2(filename2);
reader1.setDefault(0);
reader2.setDefault(1);
//matriz de sustitucion
int smatrix[]{ 5, -4, -4, -4,
-4, 5, -4, -4,
-4, -4, 5, -4,
-4, -4, -4, 5};
int gap_open = 10;
int gap_extend = 1;
int match = 5;
int mismatch = -4;
#pragma omp parallel
{
int seq_len = DEFAULT_SEQ_LEN;
//container vectors for sequences
Buffer<int16_t> seqs1(seq_len * VSIZE, ALNSIZE);
Buffer<int16_t> seqs2(seq_len * VSIZE, ALNSIZE);
//containers for ids
std::vector<std::string> seqs1_ids(VSIZE);
std::vector<std::string> seqs2_ids(VSIZE);
//legths of sequences
int seqs1_len[VSIZE];
int seqs2_len[VSIZE];
//containter for flags
Buffer<int8_t> flags(seq_len * seq_len * VSIZE, ALNSIZE);
int16_t __attribute((aligned(ALNSIZE))) scores[VSIZE];
int16_t __attribute((aligned(ALNSIZE))) ipos[VSIZE];
int16_t __attribute((aligned(ALNSIZE))) jpos[VSIZE];
//containers for arrays
int16_t inf = gap_open + gap_extend + 1;
//int16_t aF[256 * VSIZE] __attribute((aligned(ALNSIZE))) = {(int16_t)(-inf)};
//int16_t aH[256 * VSIZE] __attribute((aligned(ALNSIZE))) = {0};
int bsize = 128 * VSIZE;
//Buffer<int16_t> E(bsize, ALNSIZE);
Buffer<int16_t> F(bsize, ALNSIZE);
Buffer<int16_t> H(bsize, ALNSIZE);
//int16_t __attribute((aligned(ALNSIZE))) H[128 * VSIZE];
//alignments
char aln1[256];
char aln2[256];
//max sizes
int max_x, max_y;
//alignment start position
int x0, y0;
while(read_seqs(reader1, reader2, &seqs1, &seqs2, seqs1_len, seqs2_len,
&seqs1_ids, &seqs2_ids))
{
max_x = *std::max_element(seqs1_len, seqs1_len + VSIZE) + 1;
max_y = *std::max_element(seqs2_len, seqs2_len + VSIZE) + 1;
//E.clear(-inf);
F.clear(-inf);
H.clear(0);
//flags.clear(0);
smith_waterman(seqs1.data(), seqs2.data(), match, mismatch, gap_open, gap_extend,
flags.data(), scores, ipos, jpos, max_x, max_y, F.data(), H.data());
for(int i = 0; i < VSIZE; i++)
{
//std::cout << scores[i] << std::endl;
//std::cout << ipos[i] << std::endl;
//std::cout << jpos[i] << std::endl;
sw_backtrack(i, flags.data(), seqs1.data(), seqs2.data(), max_x, max_y,
aln1, aln2, ipos[i], jpos[i], x0, y0);
//puts(aln1);
//puts(aln2);
print_alignment (stdout, seqs1_ids, seqs2_ids, scores,
aln1, aln2, strlen(aln1), i);
}
}
}
return 0;
}
void align_read_to_reference(string& readseq, string& read_name, fragment_alignment& final_alignment_info, string& quality,
vector<string>& final_result, vector<reference_index>& refindex, meta_data& meta_details,
cell **matrix, ofstream& fp_sam, ofstream &fp_detail)
{
int match_info, global_match = -1, indpos, find;
int match = 0, gaps = 0, mismatch = 0, match_index;
int ref_start, read_start, ref_end, read_end;
int str1_end, str2_end, direction;
int primer_length, except_primer;
int ref_pointer, read_pointer;
//vector<string> final_result;
vector<pair<char, char> > alignment;
//fragment_alignment final_alignment_info;
bool flag;
string refgenome;
char first, second;
string final_read;
for(int i = 0; i < refindex.size(); i++)
{
primer_length = meta_details.fprimer.length();
except_primer = refindex[i].ref.length() - meta_details.rprimer.length();
match = mismatch = gaps = str1_end = str2_end = 0;
flag = find_alignment_direction(readseq, refindex[i], fp_detail);
if(flag == false)
{
readseq = reverse_complement(readseq);
reverse_str(quality);
}
if(refindex[i].ref.length() > readseq.length())
refgenome = refindex[i].ref.substr(0, readseq.length());
else
{
refgenome = refindex[i].ref;
readseq = readseq.substr(0, refgenome.length());
quality = quality.substr(0, refgenome.length());
}
fp_detail << "Reference length = " << refgenome.length() << endl;
fp_detail << "Reference = " << refgenome << endl;//.substr(0, 80) << endl;
fp_detail << "Readseq length = " << readseq.length() << endl;
fp_detail << "Readseq = " << readseq << endl;//.substr(0, 80) << endl;
find_kband_similarity(refgenome, readseq, alignment, str1_end, str2_end, matrix);
fp_detail << "Reference alignment length = " << str1_end << endl;
fp_detail << "Read alignment length = " << str2_end << endl;
fp_detail << "Quality string length = " << quality.length() << endl;
///////////////////////////////////////////////////////////////////////////////
final_alignment_info.alignment.clear();
final_alignment_info.quality = "";
final_read = "";
ref_pointer = read_pointer = 0;
for(int k = alignment.size() - 1; k >= 0 && ref_pointer < except_primer; k--)
{
assert(ref_pointer <= str1_end);
assert(read_pointer <= str2_end);
if(ref_pointer < primer_length)
{
if(alignment[k].first != '-')
ref_pointer += 1;
if(alignment[k].second != '-')
read_pointer += 1;
continue;
}
final_alignment_info.alignment.push_back(alignment[k]);
if(alignment[k].first == alignment[k].second && alignment[k].first != '-')
match += 1;
if(alignment[k].first != alignment[k].second && alignment[k].first != '-')
mismatch += 1;
if(alignment[k].first == '-' || alignment[k].second == '-')
gaps += 1;
if(alignment[k].first != '-')
ref_pointer += 1;
if(alignment[k].second != '-')
{
final_read += readseq.at(read_pointer);
final_alignment_info.quality += quality.at(read_pointer);
read_pointer += 1;
}
}
read_start = 0;
read_end = final_read.length();
direction = 1;
ref_start = primer_length;
ref_end = ref_pointer;
//////////////////////////////////////////////////////////////////////////////////
final_alignment_info.total_len = alignment.size();
final_alignment_info.identity_match = match;
final_alignment_info.ref_start = ref_start;
final_alignment_info.read_start = read_start;
final_alignment_info.ref_end = ref_end;//total_ref_ind
final_alignment_info.read_end = read_end;//total_read_ind
final_alignment_info.ref_ind = i;
final_alignment_info.read_dir = direction;
final_alignment_info.gaps = gaps;
final_alignment_info.mismatches = mismatch;
/*
if(flag == true)
final_alignment_info.quality = quality;
else
{
//cout << "Quality = " << quality << endl;
reverse(quality.begin(), quality.end());
final_alignment_info.quality = quality;
//cout << "Quality = " << quality << endl << endl;
}
*/
sam_format(final_alignment_info, refindex, final_read, read_name, final_result, fp_detail);
fp_sam << final_result[0];
for(int k = 1; k < final_result.size(); k++)
{
fp_sam << "\t" << final_result[k];
//cout << i << ": " << output[k] << endl;
}
fp_sam << endl;
if(DEBUG == 99)
{
fp_detail << read_name << "," << refindex[i].name << "," << KMER << ",";
fp_detail << final_alignment_info.read_start << "," << final_alignment_info.read_end << ",";
fp_detail << final_alignment_info.ref_start << "," << final_alignment_info.ref_end << ",";
fp_detail << final_alignment_info.gaps << "," << final_alignment_info.mismatches << ",";
fp_detail << final_alignment_info.identity_match << "," << final_alignment_info.total_len << ",";
fp_detail << (100.00 * final_alignment_info.identity_match / final_alignment_info.total_len) << ",";
fp_detail << final_alignment_info.read_dir << "," << readseq.length() << ",";
fp_detail << (100.00 * final_alignment_info.total_len / readseq.length()) << endl << endl << endl;
}
/*
for(int k = 0; k < 80; k++)
cout << complement(alignment[k].first);
cout << endl;
for(int k = 0; k < 80; k++)
cout << complement(alignment[k].second);
cout << endl << endl;
cout << "Reference = " << refindex[i].ref << endl;
cout << "Input ===== " << readseq << endl << endl;
for(int k = 0; k < 80; k++)
cout << final_alignment_info.alignment[k].first;
cout << endl;
for(int k = 0; k < 80; k++)
cout << final_alignment_info.alignment[k].second;
cout << endl << endl;
cout << "Reference = " << refindex[i].ref << endl;
cout << "Input ===== " << readseq <<endl << endl;
*/
if(direction == 1)
{
print_alignment(final_alignment_info.alignment, refindex[i].ref, final_read, ref_start,
read_start, 1, final_alignment_info, true, fp_detail);
if(DEBUG == 99)
{
fp_detail << "reference = " << refindex[i].ref.substr(final_alignment_info.ref_start, 80) << endl;
fp_detail << "for_read = " << readseq.substr(0, 80) << endl << endl;
}
}
else
assert(false);
/*else
{
readseq = reverse_complement(readseq);
print_alignment(final_alignment_info.alignment, refindex[i].ref, readseq, final_alignment_info.ref_start,
0, 1, final_alignment_info, true, fp_detail);
if(DEBUG == 99)
{
fp_detail << "reference = " << refindex[i].ref.substr(final_alignment_info.ref_start, 80) << endl;
fp_detail << "for_read = " << readseq.substr(0, 80) << endl << endl;
}
}
*/
alignment.clear();
//final_result.clear();
//final_alignment_info.alignment.clear();
return;
}
}
void align_read_to_reference(string& readseq, string& read_name, fragment_alignment& final_alignment_info, string& quality,
vector<string>& final_result, vector<reference_index>& refindex, cell **matrix, ofstream& fp_sam, ofstream &fp_detail)
{
int match_info, global_match = -1, indpos, find;
int match = 0, gaps = 0, mismatch = 0, match_index;
int ref_start, read_start, ref_end, read_end;
int str1_end, str2_end, direction;
//vector<string> final_result;
vector<pair<char, char> > alignment;
//fragment_alignment final_alignment_info;
bool flag;
string refgenome;
char first, second;
for(int i = 0; i < refindex.size(); i++)
{
match = mismatch = gaps = str1_end = str2_end = 0;
flag = find_alignment_direction(readseq, refindex[i], fp_detail);
if(flag == true)
{
if(refindex[i].ref.length() > readseq.length())
refgenome = refindex[i].ref.substr(0, readseq.length());
else
{
refgenome = refindex[i].ref;
readseq = readseq.substr(0, refgenome.length());
}
find_kband_similarity(refgenome, readseq, alignment, str1_end, str2_end, matrix);
direction = 1;
ref_start = 0;
read_start = 0;
ref_end = str1_end;
read_end = str2_end;
}
else
{
if(refindex[i].rev.length() > readseq.length())
refgenome = refindex[i].rev.substr(0, readseq.length());
else
{
refgenome = refindex[i].rev;
readseq = readseq.substr(0, refgenome.length());
}
find_kband_similarity(refgenome, readseq, alignment, str1_end, str2_end, matrix);
direction = 2;
ref_start = refindex[i].rev.length() - str1_end;
read_start = 0;
ref_end = refindex[i].rev.length();
read_end = str2_end;
}
for(int k = alignment.size() - 1; k >= 0 && flag == true; k--)
{
final_alignment_info.alignment.push_back(alignment[k]);
if(alignment[k].first == alignment[k].second && alignment[k].first != '-')
match += 1;
if(alignment[k].first != alignment[k].second && alignment[k].first != '-')
mismatch += 1;
if(alignment[k].first == '-' || alignment[k].second == '-')
gaps += 1;
}
for(int k = 0; k < alignment.size() && flag == false; k++)
{
first = complement(alignment[k].first);
second = complement(alignment[k].second);
final_alignment_info.alignment.push_back(make_pair(first, second));
if(alignment[k].first == alignment[k].second && alignment[k].first != '-')
match += 1;
if(alignment[k].first != alignment[k].second && alignment[k].first != '-')
mismatch += 1;
if(alignment[k].first == '-' || alignment[k].second == '-')
gaps += 1;
}
final_alignment_info.total_len = alignment.size();
final_alignment_info.identity_match = match;
final_alignment_info.ref_start = ref_start;
final_alignment_info.read_start = read_start;
final_alignment_info.ref_end = ref_end;//total_ref_ind
final_alignment_info.read_end = read_end;//total_read_ind
final_alignment_info.ref_ind = i;
final_alignment_info.read_dir = direction;
final_alignment_info.gaps = gaps;
final_alignment_info.mismatches = mismatch;
if(flag == true)
final_alignment_info.quality = quality;
else
{
//cout << "Quality = " << quality << endl;
reverse(quality.begin(), quality.end());
final_alignment_info.quality = quality;
//cout << "Quality = " << quality << endl << endl;
}
sam_format(final_alignment_info, refindex, readseq, read_name, final_result, fp_detail);
fp_sam << final_result[0];
for(int k = 1; k < final_result.size(); k++)
{
fp_sam << "\t" << final_result[k];
//cout << i << ": " << output[k] << endl;
}
fp_sam << endl;
if(DEBUG == 99)
{
fp_detail << read_name << "," << refindex[i].name << "," << KMER << ",";
fp_detail << final_alignment_info.read_start << "," << final_alignment_info.read_end << ",";
fp_detail << final_alignment_info.ref_start << "," << final_alignment_info.ref_end << ",";
fp_detail << final_alignment_info.gaps << "," << final_alignment_info.mismatches << ",";
fp_detail << final_alignment_info.identity_match << "," << final_alignment_info.total_len << ",";
fp_detail << (100.00 * final_alignment_info.identity_match / final_alignment_info.total_len) << ",";
fp_detail << final_alignment_info.read_dir << "," << readseq.length() << ",";
fp_detail << (100.00 * final_alignment_info.total_len / readseq.length()) << endl << endl << endl;
}
/*
for(int k = 0; k < 80; k++)
cout << complement(alignment[k].first);
cout << endl;
for(int k = 0; k < 80; k++)
cout << complement(alignment[k].second);
cout << endl << endl;
cout << "Reference = " << refindex[i].ref << endl;
cout << "Input ===== " << readseq << endl << endl;
for(int k = 0; k < 80; k++)
cout << final_alignment_info.alignment[k].first;
cout << endl;
for(int k = 0; k < 80; k++)
cout << final_alignment_info.alignment[k].second;
cout << endl << endl;
cout << "Reference = " << refindex[i].ref << endl;
cout << "Input ===== " << readseq <<endl << endl;
*/
if(direction == 1)
{
print_alignment(final_alignment_info.alignment, refindex[i].ref, readseq, 0,
0, 1, final_alignment_info, true, fp_detail);
if(DEBUG == 99)
{
fp_detail << "reference = " << refindex[i].ref.substr(final_alignment_info.ref_start, 80) << endl;
fp_detail << "for_read = " << readseq.substr(0, 80) << endl << endl;
}
}
else
{
readseq = reverse_complement(readseq);
print_alignment(final_alignment_info.alignment, refindex[i].ref, readseq, final_alignment_info.ref_start,
0, 1, final_alignment_info, true, fp_detail);
if(DEBUG == 99)
{
fp_detail << "reference = " << refindex[i].ref.substr(final_alignment_info.ref_start, 80) << endl;
fp_detail << "for_read = " << readseq.substr(0, 80) << endl << endl;
}
}
alignment.clear();
//final_result.clear();
//final_alignment_info.alignment.clear();
return;
}
}
