void outputSelectedAlignments(std::vector<std::vector<Chain*>>& alignment_strings,
Chain** queries, int32_t queries_length, const std::string& out_path) {
std::string out_extension = ".aligned.fasta";
for (uint32_t i = 0; i < alignment_strings.size(); ++i) {
std::ofstream out_file;
char* out_file_name = createFileName(chainGetName(queries[i]), out_path, out_extension);
int query_len = chainGetLength(queries[i]);
out_file.open(out_file_name);
out_file << ">QUERY" << std::endl;
for (int j = 1; j < query_len + 1; ++j) {
out_file << chainGetChar(queries[i], j - 1);
if (j % 60 == 0) out_file << std::endl;
}
out_file << std::endl;
for (uint32_t j = 0; j < alignment_strings[i].size(); ++j) {
out_file << ">" << chainGetName(alignment_strings[i][j]) << std::endl;
for (int k = 1; k < query_len + 1; ++k) {
out_file << chainGetChar(alignment_strings[i][j], k - 1);
if (k % 60 == 0) out_file << std::endl;
}
out_file << std::endl;
}
out_file.close();
delete[] out_file_name;
}
}
void alignmentsExtract(std::vector<Chain*>& dst, Chain* query, DbAlignment** alignments,
int alignments_length) {
int query_len = chainGetLength(query);
char* alignment_str = new char[query_len];
int query_start, length;
Chain* target = nullptr;
char* query_str = nullptr;
char* target_str = nullptr;
Alignment* alignment = nullptr;
const char gap_item = '-';
for (int i = 0; i < alignments_length; ++i) {
target = dbAlignmentGetTarget(alignments[i]);
query_start = dbAlignmentGetQueryStart(alignments[i]);
length = dbAlignmentGetPathLen(alignments[i]);
alignment = dbAlignmentToAlignment(alignments[i]);
aligmentStr(&query_str, &target_str, alignment, gap_item);
alignmentDelete(alignment);
int j = 0;
for (; j < query_start; ++j) {
alignment_str[j] = 'X';
}
for (int k = 0; k < length; ++k) {
if (query_str[k] != gap_item) {
if (target_str[k] != gap_item) {
alignment_str[j++] = target_str[k];
} else {
alignment_str[j++] = 'X';
}
}
}
for (; j < query_len; ++j) {
alignment_str[j] = 'X';
}
dst.push_back(chainCreate((char*) chainGetName(target), strlen(chainGetName(target)),
alignment_str, query_len));
delete[] query_str;
delete[] target_str;
}
delete[] alignment_str;
}
static void* alignThread(void* param) {
AlignContext* context = (AlignContext*) param;
DbAlignment** dbAlignment = context->dbAlignment;
int type = context->type;
Chain* query = context->query;
int queryIdx = context->queryIdx;
Chain* target = context->target;
int targetIdx = context->targetIdx;
double value = context->value;
int score = context->score;
Scorer* scorer = context->scorer;
int* cards = context->cards;
int cardsLen = context->cardsLen;
// align
Alignment* alignment;
alignScoredPair(&alignment, type, query, target, scorer, score, cards, cardsLen, NULL);
// check scores
int s1 = alignmentGetScore(alignment);
int s2 = score;
ASSERT(s1 == s2, "Scores don't match %d %d, (%s %s)", s1, s2,
chainGetName(query), chainGetName(target));
// extract info
int queryStart = alignmentGetQueryStart(alignment);
int queryEnd = alignmentGetQueryEnd(alignment);
int targetStart = alignmentGetTargetStart(alignment);
int targetEnd = alignmentGetTargetEnd(alignment);
int pathLen = alignmentGetPathLen(alignment);
char* path = (char*) malloc(pathLen);
alignmentCopyPath(alignment, path);
alignmentDelete(alignment);
// create db alignment
*dbAlignment = dbAlignmentCreate(query, queryStart, queryEnd, queryIdx,
target, targetStart, targetEnd, targetIdx, value, score, scorer, path,
pathLen);
return NULL;
}
static void* extractThread(void* param) {
ExtractContext* context = (ExtractContext*) param;
DbAlignmentData** dbAlignmentData = context->dbAlignmentData;
int* dbAlignmentLen = context->dbAlignmentLen;
Chain* query = context->query;
Chain** database = context->database;
int databaseLen = context->databaseLen;
int* scores = context->scores;
int maxAlignments = context->maxAlignments;
ValueFunction valueFunction = context->valueFunction;
void* valueFunctionParam = context->valueFunctionParam;
double valueThreshold = context->valueThreshold;
int* cards = context->cards;
int cardsLen = context->cardsLen;
int i;
size_t packedSize = databaseLen * sizeof(DbAlignmentData);
DbAlignmentData* packed = (DbAlignmentData*) malloc(packedSize);
double* values = (double*) malloc(databaseLen * sizeof(double));
valueFunction(values, scores, query, database, databaseLen,
cards, cardsLen, valueFunctionParam);
int thresholded = 0;
for (i = 0; i < databaseLen; ++i) {
packed[i].idx = i;
packed[i].value = values[i];
packed[i].score = scores[i];
packed[i].name = chainGetName(database[i]);
if (packed[i].value <= valueThreshold) {
thresholded++;
}
}
int k = MIN(thresholded, maxAlignments);
qselect((void*) packed, databaseLen, sizeof(DbAlignmentData), k, dbAlignmentDataCmp);
qsort((void*) packed, k, sizeof(DbAlignmentData), dbAlignmentDataCmp);
*dbAlignmentData = (DbAlignmentData*) malloc(k * sizeof(DbAlignmentData));
*dbAlignmentLen = k;
for (i = 0; i < k; ++i) {
(*dbAlignmentData)[i] = packed[i];
}
free(packed);
free(values);
return NULL;
}
