void CPDRigid<T, D>::correspondences() { _corres.setZero(_M, _N); for (size_t n = 0; n < _N; n ++) { typename std::vector<T> t_exp; T sum_exp = 0; T c = pow((2*M_PI*_paras._sigma2), 0.5*D) * (_w/(1-_w)) * (T(_M)/_N); for (size_t m = 0; m < _M; m ++) { T m_exp = computeGaussianExp(m, n); t_exp.push_back(m_exp); sum_exp += m_exp; } for (size_t m = 0; m < _M; m ++) { _corres(m, n) = t_exp.at(m) / (sum_exp + c); } } }
void CPDNRigid<Scalar, Dim>::correspondences() { this->corres_.setZero(this->M_, this->N_); for (size_t n = 0; n < this->N_; n ++) { typename std::vector<Scalar> t_exp; Scalar sum_exp = 0; Scalar c = pow((2*M_PI*paras_.sigma2_), 0.5*Dim) * (this->w_/(1-this->w_)) * (Scalar(this->M_)/this->N_); for (size_t m = 0; m < this->M_; m ++) { Scalar m_exp = computeGaussianExp(m, n); t_exp.push_back(m_exp); sum_exp += m_exp; } for (size_t m = 0; m < this->M_; m ++) { this->corres_(m, n) = t_exp.at(m) / (sum_exp + c); } } }
void OrderDownwindForDofDist(SmartPtr<DoFDistribution> dd, ConstSmartPtr<TDomain> domain, SmartPtr<UserData<MathVector<TDomain::dim>, TDomain::dim> > spVelocity, number time, int si, number threshold) { static const int dim = TDomain::dim; const size_t num_ind = dd->num_indices(); typedef typename std::pair<MathVector<dim>, size_t> pos_type; typedef typename std::vector<std::vector<size_t> > adjacency_type; // get positions of indices typename std::vector<pos_type> vPositions; ExtractPositions(domain, dd, vPositions); // get adjacency vector of vectors adjacency_type vvConnections; dd->get_connections(vvConnections); // Check vector sizes match if (vvConnections.size() != num_ind) UG_THROW("OrderDownstreamForDofDist: " "Adjacency list of dimension " << num_ind << " expected, got "<< vvConnections.size()); if (vPositions.size() != num_ind) UG_THROW("OrderDownstreamForDofDist: " "Position list of dimension " << num_ind << " expected, got "<< vPositions.size()); // init helper structures std::vector<size_t> vNewIndex(num_ind, 0); std::vector<size_t> vAncestorsCount(num_ind, 0); std::vector<bool> vVisited(num_ind, false); // remove connections that are not in stream direction adjacency_type::iterator VertexIter; std::vector<size_t>::iterator AdjIter; std::vector<size_t> vAdjacency; // count how many vertex were kept / removed per adjacency vector size_t initialcount, kept, removed = 0; MathVector<TDomain::dim> vVel1, vPos1, vPos2, vDir1_2; size_t i; for (VertexIter = vvConnections.begin(), i=0; VertexIter != vvConnections.end(); VertexIter++, i++) { UG_DLOG(LIB_DISC_ORDER, 2, "Filtering vertex " << i << " adjacency vector." <<std::endl); initialcount = VertexIter->size(); kept = 0; removed = 0; // get position and velocity of first trait vPos1 = vPositions.at(i).first; (*spVelocity)(vVel1, vPos1, time, si); if (VecLengthSq(vVel1) == 0 ) { // if the velocity is zero at this trait it does not interfere with others // NOTE: otherwise this trait would be downwind-connected to all of it's neighbors // NOTE: VertexIter-> will access inner vector functions (*VertexIter) is the inner vector. removed = VertexIter->size(); VertexIter->clear(); } else { AdjIter = VertexIter->begin(); while (AdjIter != VertexIter->end()) { // get position of second trait vPos2 = vPositions.at(*AdjIter).first; // get difference vector as direction vector VecSubtract(vDir1_2, vPos2, vPos1); // compute angle between velocity and direction vector number anglex1_2 = VecAngle(vDir1_2, vVel1); // if angle is smaller then threshold continue else remove connection if (anglex1_2 <= threshold && i != *AdjIter) { vAncestorsCount.at(*AdjIter) += 1; ++AdjIter; kept++; } else { AdjIter = VertexIter->erase(AdjIter); removed++; } } } UG_DLOG(LIB_DISC_ORDER, 2, "Kept: " << kept << ", removed: " << removed << " of " << initialcount << " entries in adjacency matrix." << std::endl << std::endl); } // calculate downwindorder // Find vertexes without any ancestors and start NumeriereKnoten on them. size_t v,N; for (v=0, N=0; v < vvConnections.size(); v++) { if (vAncestorsCount[v] == 0 && !vVisited[v]) { NumeriereKnoten(vvConnections, vVisited, vAncestorsCount, vNewIndex, N, v); } } // sanity check if (N < vvConnections.size()){ size_t fails = 0; for (v=0; v < vvConnections.size(); v++) { if (!vVisited[v]) { UG_DLOG(LIB_DISC_ORDER, 2, v << "was not visited, has unresolved ancestors: " << vAncestorsCount[v] << std::endl); fails ++; } } UG_THROW("OrderDownwindForDist failed, " << fails << " traits unvisited." << std::endl); } // reorder traits dd->permute_indices(vNewIndex); }
T get(int v) const { return m_int2name.at(v); }