// 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 ) ); }
