// This function increments the bin "pointed" to by the given [TTI, LGMD] // pair. It also increments the other bins in the row "pointed" to by the // TTI using a Gaussian weighting formula to ensure that no bin in that // row has weird likelihood values that can screw up the Bayesian TTI // estimation. Finally, it normalizes the row to ensure that each row // vector is a valid probability distribution. void SensorModel::update_row(float tti, float lgmd, float sigma) { const int N = row_size() ; const int C = column_size() ; const int I = col_index(lgmd) ; const float S = 1/(2 * sqr(sigma)) ; Table::iterator begin = m_prob.begin() + row_index(tti) ; float normalizer = 0 ; Table::iterator it = begin ; for (int i = 0; i < N; ++i, it += C) { *it += exp(-sqr(i - I) * S) ; //*it = exp(-sqr(i - I) * S) ; normalizer += *it ; } it = begin ; for (int i = 0; i < N; ++i, it += C) *it /= normalizer ; }
vector<pair<Size, Size> > PeakAlignment::getAlignmentTraceback(const PeakSpectrum& spec1, const PeakSpectrum& spec2) const { const double epsilon = (double)param_.getValue("epsilon"); //TODO gapcost dependence on distance ? const double gap = (double)param_.getValue("epsilon"); //initialize alignment matrix with 0 in (0,0) and a multiple of gapcost in the first row/col matrix(row,col,values) Matrix<double> matrix(spec1.size() + 1, spec2.size() + 1, 0); for (Size i = 1; i < matrix.rows(); i++) { matrix.setValue(i, 0, -gap * i); } for (Size i = 1; i < matrix.cols(); i++) { matrix.setValue(0, i, -gap * i); } // gives the direction of the matrix cell that originated the respective cell // e.g. matrix(i+1,j+1) could have originated from matrix(i,j), matrix(i+1,j) or matrix(i,j+1) // so traceback(i,j) represents matrix(i+1,j+1) and contains a "1"-from diagonal, a "0"-from left or a "2"-from above Matrix<Size> traceback(spec1.size(), spec2.size()); //get sigma - the standard deviation (sqrt of variance) double mid(0); for (Size i = 0; i < spec1.size(); ++i) { for (Size j = 0; j < spec2.size(); ++j) { double pos1(spec1[i].getMZ()), pos2(spec2[j].getMZ()); mid += fabs(pos1 - pos2); } } mid /= (spec1.size() * spec2.size()); /* to manually retrace cout << mid << endl; */ double var(0); for (Size i = 0; i < spec1.size(); ++i) { for (Size j = 0; j < spec2.size(); ++j) { double pos1(spec1[i].getMZ()), pos2(spec2[j].getMZ()); var += (fabs(pos1 - pos2) - mid) * (fabs(pos1 - pos2) - mid); } } var /= (spec1.size() * spec2.size()); /* to manually retrace cout << var << endl; */ const double sigma(sqrt(var)); /* to manually retrace cout << sigma << endl; */ //fill alignment matrix for (Size i = 1; i < spec1.size() + 1; ++i) { for (Size j = 1; j < spec2.size() + 1; ++j) { double pos1(spec1[i - 1].getMZ()), pos2(spec2[j - 1].getMZ()); //only if peaks are in reasonable proximity alignment is considered else only gaps if (fabs(pos1 - pos2) <= epsilon) { // actual cell = max(upper left cell+score, left cell-gap, upper cell-gap) double from_left(matrix.getValue(i, j - 1) - gap); double from_above(matrix.getValue(i - 1, j) - gap); double int1(spec1[i - 1].getIntensity()), int2(spec2[j - 1].getIntensity()); double from_diagonal(matrix.getValue(i - 1, j - 1) + peakPairScore_(pos1, int1, pos2, int2, sigma)); matrix.setValue(i, j, max(from_left, max(from_above, from_diagonal))); // TODO the cases where all or two values are equal if (from_diagonal > from_left && from_diagonal > from_above) { traceback.setValue(i - 1, j - 1, 1); } else { if (from_left > from_diagonal && from_left > from_above) { traceback.setValue(i - 1, j - 1, 0); } else { if (from_above > from_diagonal && from_above > from_left) { traceback.setValue(i - 1, j - 1, 2); } } } } else { // actual cell = max(left cell-gap, upper cell-gap) double from_left(matrix.getValue(i, j - 1) - gap); double from_above(matrix.getValue(i - 1, j) - gap); matrix.setValue(i, j, max(from_left, from_above)); if (from_left > from_above) { traceback.setValue(i - 1, j - 1, 0); } else //from_left <= from_above { traceback.setValue(i - 1, j - 1, 2); } } } } //return track from best alloverscore to 0,0 vector<pair<Size, Size> > ret_val; //get matrix coordinates from best alloverscore Size row_index(0), col_index(0); double best_score(numeric_limits<double>::min()); for (Size i = 0; i < matrix.cols(); i++) { if (best_score < matrix.getValue(matrix.rows() - 1, i)) { best_score = matrix.getValue(matrix.rows() - 1, i); row_index = matrix.rows() - 1; col_index = i; } } for (Size i = 0; i < matrix.rows(); i++) { if (best_score < matrix.getValue(i, matrix.cols() - 1)) { best_score = matrix.getValue(i, matrix.cols() - 1); row_index = i; col_index = matrix.cols() - 1; } } // TODO check the invariant! while (row_index > 0 && col_index > 0) { //from diagonal - peaks aligned if (traceback.getValue(row_index - 1, col_index - 1) == 1) { //register aligned peaks only ret_val.insert(ret_val.begin(), pair<Size, Size>(row_index - 1, col_index - 1)); row_index = row_index - 1; col_index = col_index - 1; } // gap alignment else if (traceback.getValue(row_index - 1, col_index - 1) == 0) { col_index = col_index - 1; } else { row_index = row_index - 1; } } /* to manually retrace cout << endl << matrix << endl << traceback << endl; */ return ret_val; }
void Assemble_PDE_Single_C(const AssembleParameters& p, const escript::Data& D, const escript::Data& Y) { bool expandedD = D.actsExpanded(); bool expandedY = Y.actsExpanded(); const Scalar zero = static_cast<Scalar>(0); Scalar* F_p = NULL; if (!p.F.isEmpty()) { p.F.requireWrite(); F_p = p.F.getSampleDataRW(0, zero); } const std::vector<double>& S(p.row_jac->BasisFunctions->S); #pragma omp parallel { std::vector<Scalar> EM_S(p.row_numShapesTotal*p.col_numShapesTotal); std::vector<Scalar> EM_F(p.row_numShapesTotal); IndexVector row_index(p.row_numShapesTotal); for (index_t color = p.elements->minColor; color <= p.elements->maxColor; color++) { // loop over all elements #pragma omp for for (index_t e = 0; e < p.elements->numElements; e++) { if (p.elements->Color[e] == color) { for (int isub = 0; isub < p.numSub; isub++) { const double* Vol = &(p.row_jac->volume[INDEX3(0,isub,e,p.numQuadSub,p.numSub)]); bool add_EM_F = false; bool add_EM_S = false; /////////////// // process D // /////////////// if (!D.isEmpty()) { const Scalar* D_p = D.getSampleDataRO(e, zero); add_EM_S = true; if (expandedD) { const Scalar* D_q = &D_p[INDEX2(0, isub, p.numQuadSub)]; for (int s = 0; s < p.row_numShapes; s++) { for (int r = 0; r < p.col_numShapes; r++) { Scalar val = zero; for (int q = 0; q < p.numQuadSub; q++) { val += Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*D_q[q]*S[INDEX2(r,q,p.row_numShapes)]; } EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_numShapesTotal)]= val; EM_S[INDEX4(0,0,s,r+p.col_numShapes,p.numEqu,p.numComp,p.row_numShapesTotal)]=-val; EM_S[INDEX4(0,0,s+p.row_numShapes,r,p.numEqu,p.numComp,p.row_numShapesTotal)]=-val; EM_S[INDEX4(0,0,s+p.row_numShapes,r+p.col_numShapes,p.numEqu,p.numComp,p.row_numShapesTotal)]= val; } } } else { // constant D for (int s = 0; s < p.row_numShapes; s++) { for (int r = 0; r < p.col_numShapes; r++) { Scalar f = zero; for (int q = 0; q < p.numQuadSub; q++) { f += Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*S[INDEX2(r,q,p.row_numShapes)]; } const Scalar fD = f * D_p[0]; EM_S[INDEX4(0,0,s,r,p.numEqu,p.numComp,p.row_numShapesTotal)]= fD; EM_S[INDEX4(0,0,s,r+p.col_numShapes,p.numEqu,p.numComp,p.row_numShapesTotal)]=-fD; EM_S[INDEX4(0,0,s+p.row_numShapes,r,p.numEqu,p.numComp,p.row_numShapesTotal)]=-fD; EM_S[INDEX4(0,0,s+p.row_numShapes,r+p.col_numShapes,p.numEqu,p.numComp,p.row_numShapesTotal)]= fD; } } } } /////////////// // process Y // /////////////// if (!Y.isEmpty()) { const Scalar* Y_p = Y.getSampleDataRO(e, zero); add_EM_F = true; if (expandedY) { const Scalar* Y_q = &Y_p[INDEX2(0, isub, p.numQuadSub)]; for (int s = 0; s < p.row_numShapes; s++) { Scalar val = zero; for (int q = 0; q < p.numQuadSub; q++) val += Vol[q]*S[INDEX2(s,q,p.row_numShapes)]*Y_q[q]; EM_F[INDEX2(0,s,p.numEqu)] = -val; EM_F[INDEX2(0,s+p.row_numShapes,p.numEqu)] = val; } } else { // constant Y for (int s = 0; s < p.row_numShapes; s++) { Scalar f = zero; for (int q = 0; q < p.numQuadSub; q++) { f += Vol[q] * S[INDEX2(s,q,p.row_numShapes)]; } EM_F[INDEX2(0,s,p.numEqu)] = -f * Y_p[0]; EM_F[INDEX2(0,s+p.row_numShapes,p.numEqu)] = f * Y_p[0]; } } } // add the element matrices onto the matrix and // right hand side for (int q = 0; q < p.row_numShapesTotal; q++) { row_index[q] = p.row_DOF[p.elements->Nodes[INDEX2(p.row_node[INDEX2(q,isub,p.row_numShapesTotal)],e,p.NN)]]; } if (add_EM_F) { util::addScatter(p.row_numShapesTotal, &row_index[0], p.numEqu, &EM_F[0], F_p, p.row_DOF_UpperBound); } if (add_EM_S) Assemble_addToSystemMatrix(p.S, p.row_numShapesTotal, &row_index[0], p.numEqu, p.col_numShapesTotal, &row_index[0], p.numComp, &EM_S[0]); } // end of isub } // end color check } // end element loop } // end color loop } // end parallel region }
const T& operator()( const L& row, const L& col ) const { return (*this)( row_index( row ), col_index( col ) ); }