//TODO: inline Viterbi::BacktraceScore Viterbi::ScoreForBacktrace(HMMSimd* q_four, HMMSimd* t_four, int elem,Viterbi::BacktraceResult * backtraceResult, float alignmentScore[VECSIZE_FLOAT], int ss_hmm_mode) { // Allocate new space for alignment scores const HMM * q = (const HMM *) q_four->GetHMM(elem); const HMM * t = (const HMM *) t_four->GetHMM(elem); char * states=backtraceResult->states; int * i_steps=backtraceResult->i_steps; int * j_steps=backtraceResult->j_steps; int nsteps=backtraceResult->count; float * S=new float[nsteps+1]; float * S_ss=new float[nsteps+1]; if (!S_ss) MemoryError("space for HMM-HMM alignments", __FILE__, __LINE__, __func__); // Add contribution from secondary structure score, record score a long alignment, // and record template consensus sequence in master-slave-alignment to query sequence float score_ss=0.0f; float score=alignmentScore[elem]; float score_sort = 0.0f; float score_aass = 0.0f; float Pvalt = 1.0f; float logPvalt = 0.0f; for (int step=1; step<=nsteps; step++) { switch(states[step]) { case ViterbiMatrix::MM: S[step] = Score(q->p[i_steps[step]],t->p[j_steps[step]]); // printf("i=%d j=%d S=%d\n", i_steps[step], j_steps[step], Score(q->p[i_steps[step]],t->p[j_steps[step]])); S_ss[step] = ScoreSS(q,t,i_steps[step],j_steps[step], ssw, ss_hmm_mode, S73, S37, S33); score_ss += S_ss[step]; break; case ViterbiMatrix::MI: //if gap in template case ViterbiMatrix::DG: default: //if gap in T or Q S[step]=S_ss[step]=0.0f; break; } } // printf("###old score %f\t",score); if (ss_mode == Hit::SCORE_ALIGNMENT) score-=score_ss; // subtract SS score added during alignment!!!! // Add contribution from correlation of neighboring columns to score float Scorr=0; if (nsteps) { for (int step=2; step<=nsteps; step++) Scorr+=S[step]*S[step-1]; for (int step=3; step<=nsteps; step++) Scorr+=S[step]*S[step-2]; for (int step=4; step<=nsteps; step++) Scorr+=S[step]*S[step-3]; for (int step=5; step<=nsteps; step++) Scorr+=S[step]*S[step-4]; score+=correlation*Scorr; // printf("Scorr=%f\t",Scorr); // printf("correlation=%f\t",correlation); } // printf("new=%f\n",score); // Set score, P-value etc. score_sort = score_aass = -score; if (t->mu) { logPvalt=logPvalue(score,t->lamda,t->mu); Pvalt =Pvalue(score,t->lamda,t->mu); } else { logPvalt=0; Pvalt=1;} // printf("%-10.10s lamda=%-9f score=%-9f logPval=%-9g\n",name,t->lamda,score,logPvalt); //DEBUG: Print out Viterbi path Viterbi::BacktraceScore backtraceScore; backtraceScore.score_ss=score_ss; backtraceScore.score=score; backtraceScore.score_sort=score_sort; backtraceScore.score_aass=score_aass; backtraceScore.Pvalt=Pvalt; backtraceScore.logPvalt=logPvalt; backtraceScore.S=S; backtraceScore.S_ss=S_ss; if (Log::reporting_level() >= DEBUG1) { Viterbi::PrintDebug(q,t,&backtraceScore,backtraceResult, ss_mode); } return backtraceScore; }
/** * Compute deltas from bases and misses. */ ERROR_CODE recal_calc_deltas(recal_info_t* data) { double global_empirical, phred, err0; double r_empirical; int matrix_index; int i, j; //Time measures #ifdef D_TIME_DEBUG time_init_slot(D_SLOT_CALC_DELTAS, clock(), TIME_GLOBAL_STATS); #endif printf("Processing deltas...\n"); //Global delta global_empirical = (double)(data->total_miss + 1) / (double)(data->total_bases + 1); phred = 0.0; for(i = 0; i < data->num_quals; i++) { if(data->min_qual + i != 0) { //err0 = 1.0 / (10.0 * log10(data->min_qual + i + 1)); //err0 = 1.0 / ((double)(data->min_qual + i)); err0 = Pvalue((double)(data->min_qual + i)); phred += err0 * (double)data->qual_bases[i]; } } phred = phred / (double)data->total_bases; data->total_delta = Qvalue(global_empirical) - Qvalue(phred); //Delta R for(i = 0; i < data->num_quals; i++) { if(data->qual_bases[i] != 0) { data->qual_delta[i] = Qvalue(((double)(data->qual_miss[i]) / (double)(data->qual_bases[i]))) - (double)(i + data->min_qual) - data->total_delta; } } //Delta R,C for(i = 0; i < data->num_quals; i++) { for(j = 0; j < data->num_cycles; j++) { matrix_index = i * data->num_cycles + j; if(data->qual_cycle_bases[matrix_index] != 0) { data->qual_cycle_delta[matrix_index] = Qvalue((double)(data->qual_cycle_miss[matrix_index]) / (double)(data->qual_cycle_bases[matrix_index])) - (double)(i + data->min_qual) - (data->total_delta + data->qual_delta[i]); } } } //Delta R,D for(i = 0; i < data->num_quals; i++) { for(j = 0; j < data->num_dinuc; j++) { matrix_index = i * data->num_dinuc + j; if(data->qual_dinuc_bases[matrix_index] != 0) { data->qual_dinuc_delta[matrix_index] = Qvalue((double)(data->qual_dinuc_miss[matrix_index]) / (double)(data->qual_dinuc_bases[matrix_index])) - (double)(i + data->min_qual) - (data->total_delta + data->qual_delta[i]); } } } printf("Deltas processed.\n"); #ifdef D_TIME_DEBUG time_set_slot(D_SLOT_CALC_DELTAS, clock(), TIME_GLOBAL_STATS); #endif return NO_ERROR; }
void PosteriorDecoder::backtraceMAC(HMM & q, HMM & t, PosteriorMatrix & p_mm, ViterbiMatrix & backtrace_matrix, const int elem, Hit & hit, float corr) { // Trace back trough the matrix b[i][j] until STOP state is found LogLevel actual_level = Log::reporting_level(); int step; // counts steps in path through 5-layered dynamic programming matrix int i,j; // query and template match state indices initializeBacktrace(t,hit); // Make sure that backtracing stops when t:M1 or q:M1 is reached (Start state), e.g. sMM[i][1], or sIM[i][1] (M:MM, B:IM) for (i = 0; i <= q.L; ++i) backtrace_matrix.setMatMat(i, 1, elem, ViterbiMatrix::STOP); // b[i][1] = STOP; for (j = 1; j <= t.L; ++j) backtrace_matrix.setMatMat(1, j, elem, ViterbiMatrix::STOP); // b[1][j] = STOP; // Back-tracing loop // In contrast to the Viterbi-Backtracing, STOP signifies the first Match-Match state, NOT the state before the first MM state hit.matched_cols = 1; // for each MACTH (or STOP) state matched_col is incremented by 1 hit.state = ViterbiMatrix::MM; // lowest state with maximum score must be match-match state step = 0; // steps through the matrix correspond to alignment columns (from 1 to nsteps) i = hit.i2; j = hit.j2; // last aligned pair is (i2,j2) if (backtrace_matrix.getMatMat(i, j, elem) != ViterbiMatrix::MM) { // b[i][j] != MM if (Log::reporting_level() > DEBUG) fprintf(stderr,"Error: backtrace does not start in match-match state, but in state %i, (i,j)=(%i,%i)\n",backtrace_matrix.getMatMat(i, j, elem),i,j); step = 0; hit.i[step] = i; hit.j[step] = j; hit.alt_i->push_back(i); hit.alt_j->push_back(j); hit.state = ViterbiMatrix::STOP; } else { while (hit.state != ViterbiMatrix::STOP) { step++; hit.states[step] = hit.state = backtrace_matrix.getMatMat(i, j, elem); // b[i][j]; hit.i[step] = i; hit.j[step] = j; hit.alt_i->push_back(i); hit.alt_j->push_back(j); // Exclude cells in direct neighbourhood from all further alignments for (int ii = imax(i-2,1); ii <= imin(i+2, q.L); ++ii) // hit.cell_off[ii][j] = 1; backtrace_matrix.setCellOff(ii, j, elem, true); for (int jj = imax(j-2,1); jj <= imin(j+2, t.L); ++jj) backtrace_matrix.setCellOff(i, jj, elem, true); if (hit.state == ViterbiMatrix::MM) hit.matched_cols++; switch (hit.state) { case ViterbiMatrix::MM: i--; j--; break; case ViterbiMatrix::IM: j--; break; case ViterbiMatrix::MI: i--; break; case ViterbiMatrix::STOP: break; default: fprintf(stderr,"Error: unallowed state value %i occurred during backtracing at step %i, (i,j)=(%i,%i)\n", hit.state, step, i, j); hit.state = 0; actual_level = DEBUG1; break; } //end switch (state) } //end while (state) } hit.i1 = hit.i[step]; hit.j1 = hit.j[step]; hit.states[step] = ViterbiMatrix::MM; // first state (STOP state) is set to MM state hit.nsteps = step; // Allocate new space for alignment scores hit.S = new float[hit.nsteps+1]; hit.S_ss = new float[hit.nsteps+1]; hit.P_posterior = new float[hit.nsteps+1]; if (!hit.P_posterior) MemoryError("space for HMM-HMM alignments", __FILE__, __LINE__, __func__); // Add contribution from secondary structure score, record score along alignment, // and record template consensus sequence in master-slave-alignment to query sequence hit.score_ss = 0.0f; hit.sum_of_probs = 0.0; // number of identical residues in query and template sequence int ssm = hit.ssm1 + hit.ssm2; // printf("Hit=%s\n",name); ///////////////////////////////////////////////////////////// for (step = 1; step <= hit.nsteps; step++) { switch(hit.states[step]) { case ViterbiMatrix::MM: i = hit.i[step]; j = hit.j[step]; hit.S[step] = Score(q.p[i], t.p[j]); hit.S_ss[step] = Viterbi::ScoreSS(&q, &t, i, j, ssw, ssm, S73, S37, S33); hit.score_ss += hit.S_ss[step]; // hit.P_posterior[step] = powf(2, p_mm.getPosteriorValue(hit.i[step], hit.j[step], elem)); hit.P_posterior[step] = p_mm.getPosteriorValue(hit.i[step], hit.j[step]); // Add probability to sum of probs if no dssp states given or dssp states exist and state is resolved in 3D structure if (t.nss_dssp<0 || t.ss_dssp[j]>0) hit.sum_of_probs += hit.P_posterior[step]; // printf("j=%-3i P=%4.2f sum=%6.2f\n",j, hit.P_posterior[step],hit.sum_of_probs); ////////////////////////// break; case ViterbiMatrix::MI: //if gap in template case ViterbiMatrix::DG: default: //if gap in T or Q hit.S[step] = hit.S_ss[step] = hit.P_posterior[step] = 0.0; break; } } // printf("\n"); ///////////////////////////////////////////////////////////// if (hit.ssm2 >= 1) hit.score -= hit.score_ss; // subtract SS score added during alignment!!!! // Add contribution from correlation of neighboring columns to score float Scorr = 0; if (hit.nsteps) { for (step = 1; step <= hit.nsteps-1; step++) Scorr += hit.S[step] * hit.S[step+1]; for (step = 1; step <= hit.nsteps-2; step++) Scorr += hit.S[step] * hit.S[step+2]; for (step = 1; step <= hit.nsteps-3; step++) Scorr += hit.S[step] * hit.S[step+3]; for (step = 1; step <= hit.nsteps-4; step++) Scorr += hit.S[step] * hit.S[step+4]; hit.score += corr * Scorr; } // Set score, P-value etc. hit.score_sort = hit.score_aass = -hit.score; hit.logPval = 0; hit.Pval = 1; if (t.mu) { hit.logPvalt = logPvalue(hit.score, t.lamda, t.mu); hit.Pvalt = Pvalue(hit.score,t.lamda,t.mu); } else { hit.logPvalt = 0; hit.Pvalt = 1; } // printf("%-10.10s lamda=%-9f score=%-9f logPval=%-9g\n",name,t.lamda,score,logPvalt); //DEBUG: Print out MAC alignment path //TODO bad debugging code if (actual_level >= DEBUG1) { float sum_post = 0.0; printf("NAME=%7.7s score=%7.3f score_ss=%7.3f\n", hit.name, hit.score, hit.score_ss); printf("step Q T i j state score T Q cf ss-score P_post Sum_post\n"); for (step = hit.nsteps; step >= 1; step--) { switch(hit.states[step]) { case ViterbiMatrix::MM: sum_post += hit.P_posterior[step]; printf("%4i %1c %1c ",step,q.seq[q.nfirst][hit.i[step]], hit.seq[hit.nfirst][hit.j[step]]); break; case ViterbiMatrix::IM: printf("%4i - %1c ",step, hit.seq[hit.nfirst][hit.j[step]]); break; case ViterbiMatrix::MI: printf("%4i %1c - ",step,q.seq[q.nfirst][hit.i[step]]); break; } printf("%4i %4i %2i %7.1f ", hit.i[step], hit.j[step],(int)hit.states[step], hit.S[step]); printf("%c %c %1i %7.1f ", i2ss(t.ss_dssp[hit.j[step]]),i2ss(q.ss_pred[hit.i[step]]),q.ss_conf[hit.i[step]]-1, hit.S_ss[step]); printf("%7.5f %7.2f\n", hit.P_posterior[step],sum_post); } } return; }