JTRIGGER::clusterizeWeight Struct Reference

Anonymous struct for weighed clustering of hits. More...

#include <JAlgorithm.hh>

Public Member Functions
template<class JHitIterator_t , class JMatch_t >
JHitIterator_t	operator() (JHitIterator_t __begin, JHitIterator_t __end, const JMatch_t &match) const
	Partition data according given binary match operator.

Private Member Functions
template<class JHitIterator_t , class JMatch_t >
JHitIterator_t	operator() (JHitIterator_t buffer, const int N, const JMatch_t &match, std::random_access_iterator_tag tag) const
	Implementation of method clusterizeWeight for random access iterators.

Private Attributes
std::vector< double >	weight

Detailed Description

Anonymous struct for weighed clustering of hits.

Definition at line 300 of file JAlgorithm.hh.

Member Function Documentation

operator()() [1/2]

template<class JHitIterator_t , class JMatch_t >

JHitIterator_t JTRIGGER::clusterizeWeight::operator() ( JHitIterator_t __begin, JHitIterator_t __end, const JMatch_t & match ) const

inline

Partition data according given binary match operator.

The underlying algorithm is known in literature as reverse 'clique'. The result is (likely to be) the maximal sub-set with all elements matched to each other. The complexity is quadratic, i.e. at most (number of elements x number of elements) operations. The algorithm will sort the data such that all clusterized hits are at the front. The return value points the first non clusterized hit. Note that the weight is assumed to be positive definite and the larger the weight the better.

The hit iterator refers to a data structure which should conform with the match operator. In addition, it should have the following member method:

• double getW(); // [a.u.]

Parameters

__begin	begin of data
__end	end of data
match	binary match operator

Returns

end of data

Definition at line 322 of file JAlgorithm.hh.

    {
      return (*this)(__begin,  std::distance(__begin,__end), match, typename std::iterator_traits<JHitIterator_t>::iterator_category());
    }

operator()() [2/2]

template<class JHitIterator_t , class JMatch_t >

JHitIterator_t JTRIGGER::clusterizeWeight::operator() ( JHitIterator_t buffer, const int N, const JMatch_t & match, std::random_access_iterator_tag tag ) const

inlineprivate

Implementation of method clusterizeWeight for random access iterators.

Parameters

buffer	pointer to data
N	number of hits
match	binary match operator
tag	iterator tag

Returns

pointer to end of data

Definition at line 340 of file JAlgorithm.hh.

    {
      using namespace std;
 
      if (N != 0) {
 
        int i, j;
 
        // Determine weight of each hit.
 
        weight.resize(N);
 
        for (i = 0; i != N; ++i) {      
          weight[i] = buffer[i].getW();    // Assume always a match with itself.
        }
 
        for (i = 0; i != N; ++i) {
          for (j = i; ++j != N; ) {
            if (match(buffer[i], buffer[j])) {
              weight[i] += buffer[j].getW();
              weight[j] += buffer[i].getW();
            }
          }
        }
 
        // Remove hit with the smallest weight of associated hits.
        // This procedure stops when the weight of associated hits
        // is equal to the maximal weight of (remaining) hits.
    
        int    n = N;
        double W;
    
        for ( ; ; ) {
      
          j = 0;
          W = weight[j];
 
          for (i = 1; i != n; ++i) {
            if      (weight[i] < weight[j])
              j = i;
            else if (weight[i] > W)
              W = weight[i];
          }
      
          // Ready?
      
          if (weight[j] == W) {
            return buffer + n;
          }
      
          // Reduce effective size.
      
          --n;
      
          // Swap the selected hit to end.
 
          swap(buffer[j], buffer[n]);
          swap(weight[j], weight[n]);
 
          // Decrease weight of associated hits for each associated hit.
 
          for (i = 0; i != n && weight[n] > buffer[n].getW(); ++i) {
            if (match(buffer[i], buffer[n])) {
              weight[i] -= buffer[n].getW();
              weight[n] -= buffer[i].getW();
            }
          }
        }
      }
 
      return buffer;
    }

Member Data Documentation

weight

std::vector<double> JTRIGGER::clusterizeWeight::weight

mutableprivate

Definition at line 417 of file JAlgorithm.hh.

---

The documentation for this struct was generated from the following file:

• JAlgorithm.hh