/* static */ void Module_DMAP::generic_worker_single_thr(Module_DMAP * search, int id) { Mask * sequences; int read_seq; vector<Mask> printable_solutions; Transmitting_Result received; if (search->my_rank == 0) { sequences = new Mask[SEQUENCES_FOR_BLOCK]; read_seq = read_sequences(search->input_file1, SEQUENCES_FOR_BLOCK, sequences, search->fastqformat, search->gui_output); } else { received = search->receive_from_previous(id); sequences = received.first; read_seq = received.second; } while (read_seq != 0) { Items solutions; //ItemsGapped solutions_gapped; t_errors calculated_errors; for (int i = 0; i < read_seq; i++) { Mask & s = sequences[i]; if (search->my_rank == 0 and search->trim) { // check_routine(sequences[i], 0); s.quality_trimming_MOTT(search->min_phred_value_MOTT,search->min_mean_quality,search->min_size); } if (s.status_discarded()) { if (s.status_low_complexity()) s.low_complexity =true; //s.set_type(low_complexity); else s.low_quality = true; //s.set_type(quality_discarded); printable_solutions.push_back(s); continue; } if (search->auto_errors) calculated_errors = round((double)s.get_good_length() / search->errors_rate); else calculated_errors = search->common_errors_allowed; if (search->my_rank != 0 and s.algn > 0 and s.NM < calculated_errors) calculated_errors = s.NM; t_errors count = 0; for (t_pattern_length i = s.get_good_region_start()-1; (i < s.get_good_region_stop()) and (count <= calculated_errors); i++) if (s.sequence[i] == 'N' or s.sequence[i] == 'n') count++; if (count > calculated_errors) { //s.set_type(alignments_not_found); printable_solutions.push_back(s); continue; } /** ALIGNMENT **/ solutions.clear(); if (search->my_rank == 0 and search->contamination_check) { search->CR.search(s.get_good_sequence(),solutions,calculated_errors); if (solutions.size() > 0) s.contaminated = true; } if (not s.contaminated) search->H.search(s.get_good_sequence(),solutions,calculated_errors); if (solutions.size() == 0) { /** Try gapped **/ /* solutions_gapped.clear(); if (search->gap) search->H.search_gapped(s.get_good_sequence(),solutions_gapped,search->seed_sizes,search->seed_errors,calculated_errors,search->max_gap); */ /* if (solutions_gapped.size() == 0) {// size 0 means no alignment found */ //s.set_type(alignments_not_found); printable_solutions.push_back(s); continue; /* } else { if (not search->printAll) { Random_Choice_Result r; bool improved = (s.NM + s.NM_gap) > (solutions_gapped.at(0).errors1 + solutions_gapped.at(0).errors2); if (improved) r = Search_MPI::random_choice_from_previous(0,solutions_gapped.size()); else r = Search_MPI::random_choice_from_previous(s.algn,solutions_gapped.size()); if (not improved and r.first) { // take the previous solution s.algn += solutions_gapped.size(); } else { // update solution const ResultItemGapped & HM = solutions_gapped.at(r.second); s.globalPosition = HM.GlobalPosition1; if (improved) s.algn = solutions_gapped.size(); else s.algn += solutions_gapped.size(); s.HI = 1; s.IH = 1; s.primary = true; s.strand = HM.strand; s.NM = HM.errors1; s.NM_gap = HM.errors2; s.contig = HM.contig; s.position = HM.GlobalPosition1 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.position_gap = HM.GlobalPosition2 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.length1_gap = HM.length1; s.length2_gap = HM.length2; s.contig = search->contig_conversion.convert(s.contig); } printable_solutions.push_back(s); } else { // printALL */ /* unsigned int processed=0; unsigned int alignments; (search->toBePrinted < solutions_gapped.size()) ? alignments = search->toBePrinted : alignments = solutions_gapped.size() ; while(processed < alignments) { const ResultItemGapped & HM = solutions_gapped.at(processed); s.globalPosition = HM.GlobalPosition1; s.algn = alignments; s.HI =1; s.IH =1; (processed == 0 ) ? s.primary = true : s.primary = false; s.strand = HM.strand; s.NM = HM.errors1; s.NM_gap = HM.errors2; s.contig = HM.contig ; s.position = HM.GlobalPosition1 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.position_gap = HM.GlobalPosition2 - search->H.globaltolocal.startPositions[HM.contig] + 1 ; s.length1_gap = HM.length1; s.length2_gap = HM.length2; s.contaminated = contaminated; printable_solutions.push_back(s); processed++; } */ /* ERROR_CHANNEL << "--print-all option not implemented yet!" << endl; exit(3); } } */ } else if (not search->printAll) { sort(solutions.begin(), solutions.end(), ResultItem::less()); // sort solutions solutions.erase(unique(solutions.begin(), solutions.end(), ResultItem::equal()), solutions.end()); Random_Choice_Result r; bool improved = (s.NM + s.NM_gap) > (solutions.at(0).errors); if (improved) r = Module_DMAP::random_choice_from_previous(0,solutions.size()); else { r = Module_DMAP::random_choice_from_previous(s.algn,solutions.size()); s.algn += solutions.size(); } if (not r.first) { const ResultItem & HM = solutions.at(r.second); s.HI = 1; s.IH = 1; s.primary = true; s.globalPosition = HM.globalPosition; s.strand = HM.strand; s.NM = HM.errors; s.NM_gap = 0; if ((search->my_rank == 0) and s.contaminated) { s.contig = search->CR.globalToLocal.searchContig(HM.globalPosition); // find the contig/scaffold s.position = HM.globalPosition - search->CR.globalToLocal.startPositions[s.contig] + 1; s.contig = search->contig_conversion.convert(s.contig); } else { s.contig = search->H.globalToLocal.searchContig(HM.globalPosition); // find the contig/scaffold s.position = HM.globalPosition - search->H.globalToLocal.startPositions[s.contig] + 1; s.contig = search->contig_conversion.convert(s.contig); } } printable_solutions.push_back(s); continue; } else { // printAll /* // memorize all printable solutions sort(solutions.begin(), solutions.end(), ResultItem::less()); // sort solutions solutions.erase(unique(solutions.begin(), solutions.end(), ResultItem::equal()), solutions.end()); unsigned int processed=0; unsigned int alignments; (search->toBePrinted < solutions.size()) ? alignments = search->toBePrinted : alignments = solutions.size() ; while(processed < alignments) { // while I print enough solution or there are no more solutions const ResultItem & HM = solutions.at(processed); s.globalPosition = HM.GlobalPosition; s.algn = solutions.size(); s.IH = alignments; s.HI = processed+1; (processed == 0 ) ? s.primary = true : s.primary = false; s.strand = HM.strand; s.NM = HM.errors; if (contaminated) { s.contig = search->CR.globaltolocal.searchContig(HM.GlobalPosition); // find the contig/scaffold s.position = HM.GlobalPosition - search->CR.globaltolocal.startPositions[s.contig] + 1; } else { s.contig = search->H.globaltolocal.searchContig(HM.GlobalPosition); // find the contig/scaffold s.position = HM.GlobalPosition - search->H.globaltolocal.startPositions[s.contig] + 1; } s.contaminated = contaminated; printable_solutions.push_back(s); } */ ERROR_CHANNEL << "--print-all option not implemented yet!" << endl; exit(3); } } if (search->my_rank == (search->nprocs-1)) { // now print all for(unsigned int i=0; i < printable_solutions.size(); i++) search->output_samfile.print_output(printable_solutions.at(i)); search->processed += read_seq; } else // send data to next node search->send_to_next(printable_solutions,id); delete [] sequences; printable_solutions.clear(); if (search->my_rank == 0) { sequences = new Mask[SEQUENCES_FOR_BLOCK]; read_seq = read_sequences(search->input_file1, SEQUENCES_FOR_BLOCK, sequences, search->fastqformat, search->gui_output); if (read_seq == 0) delete [] sequences; } else { received = search->receive_from_previous(id); sequences = received.first; read_seq = received.second; } } }
DecodeResults * SegmentDecoder :: decode(Instance *inst, Parameter *param) { Items *items = inst->items(); int len = items->size(); int numFeatures = m_Model->getAlphabet("FEATURES")->size(); int numLabels = m_Model->getAlphabet("LABELS")->size(); double **uniScoreCache = new double *[len]; for (int i = 0; i < len; ++ i) { uniScoreCache[i] = new double[numLabels]; Item *item = items->at(i); for (int label = 0; label < numLabels; ++ label) { uniScoreCache[i][label] = 0.0; int sz = item->size(label); for (int j = 0; j < sz; ++ j) { uniScoreCache[i][label] += param->value(item->at(j, label)); } } } double **biScoreCache = new double *[numLabels + 1]; for (int prevLabel = 0; prevLabel <= numLabels; ++ prevLabel) { biScoreCache[prevLabel] = new double[numLabels]; for (int currLabel = 0; currLabel < numLabels; ++ currLabel) { biScoreCache[prevLabel][currLabel] = param->value( numFeatures * numLabels + prevLabel * numLabels + currLabel); } } KHeap<DecodeState> **states = new KHeap<DecodeState> *[len]; for (int i = 0; i < len; ++ i) { states[i] = new KHeap<DecodeState>[numLabels]; for (int j = 0; j < numLabels; ++ j) { states[i][j].setK(m_Agenda); } } for (int i = 0; i < len; ++ i) { // fprintf(stderr, "i=%d\n", i); for (int currLabel = 0; currLabel < numLabels; ++ currLabel) { if (i == 0) { // fprintf(stderr, "!%d->%d\n", numLabels, currLabel); if (m_Legal[numLabels][currLabel] == 0) { continue; } double score = uniScoreCache[0][currLabel] + biScoreCache[numLabels][currLabel]; states[i][currLabel].insert(DecodeState(currLabel, score, NULL)); } else { for (int prevLabel = 0; prevLabel < numLabels; ++ prevLabel) { if (m_Legal[prevLabel][currLabel] == 0) continue; for (int j = 0; j < states[i - 1][prevLabel].size(); ++ j) { DecodeState *prev = states[i - 1][prevLabel].at(j); double score = prev->score + uniScoreCache[i][currLabel] + biScoreCache[prevLabel][currLabel]; // printf("#%d->%d\n", prevLabel, currLabel); states[i][currLabel].insert(DecodeState(currLabel, score, prev)); } } } } } vector<DecodeState> result_cache; for (int label = 0; label < numLabels; ++ label) { for (int i = 0; i < states[len - 1][label].size(); ++ i) { result_cache.push_back( *states[len - 1][label].at(i) ); } } sort( result_cache.begin(), result_cache.end() ); DecodeResults *ret = new CppDecodeResults(); for (int i = 0; ((i < m_Agenda) && (result_cache.size() - i > 0)); ++ i) { Labels* single = new CppLabels(len); int pos = len - 1; DecodeState *now = &result_cache[result_cache.size() - i - 1]; //DecodeState *now = result_cache.at(i); for (; pos >= 0; -- pos, now = now->prev) { single->set(now->label, pos); } ret->append( single ); } for (int i = 0; i < len; ++ i) { delete []uniScoreCache[i]; } delete []uniScoreCache; for (int i = 0; i <= numLabels; ++ i) { delete []biScoreCache[i]; } delete []biScoreCache; for (int i = 0; i < len; ++ i) { delete []states[i]; } delete []states; return ret; }