HGTD::ClusterCollection< T > Class Template Reference

#include <Clustering.h>

Collaboration diagram for HGTD::ClusterCollection< T >:

Public Member Functions
void	addCluster (Cluster< T > vx)
void	doClustering (ClusterAlgo algo)
Cluster< T >	getMaxEntriesCluster ()
int	getMaxClusterSize_Info ()
const std::vector< Cluster< T > > &	getClusters () const
int	getNClusters () const
void	updateDistanceCut (double cut_value)
	Set the distance cut. More...
void	setDebugLevel (int debug_level)

Private Member Functions
double	getDistanceBetweenClusters (const Cluster< T > &a, const Cluster< T > &b)
Cluster< T >	mergeClusters (const Cluster< T > &a, const Cluster< T > &b)
	Creates a new Cluster object that is a fusion of the two clusters given in the arguments. More...
Cluster< T >	mergeClustersMean (const Cluster< T > &a, const Cluster< T > &b)
std::pair< Cluster< T >, int >	largestClusterInfo ()

Private Attributes
int	m_debug_level = 0
double	m_distance_cut = 3.0
std::vector< Cluster< T > >	m_clusters

Detailed Description

template<typename T>
class HGTD::ClusterCollection< T >

Definition at line 123 of file Clustering.h.

Member Function Documentation

addCluster()

template<typename T >

void HGTD::ClusterCollection< T >::addCluster

(

Cluster< T >

vx

)

Definition at line 274 of file Clustering.h.

                                                                         {
  m_clusters.push_back(vx);
}

doClustering()

template<typename T >

void HGTD::ClusterCollection< T >::doClustering

(

ClusterAlgo

algo

)

Definition at line 368 of file Clustering.h.

                                                        {
  if (algo == ClusterAlgo::Eager) {
    for (const auto &clust : m_clusters) {
      if (clust.containsUnknowns()) {
        throw std::invalid_argument(
            "[ClusterCollection::doClustering] ERROR "
            "- eager clustering does not allow for unknown values");
      }
    }
  }
 
  // TODO case where I have 2 vertices in my collection
  if (m_debug_level > 0) {
    std::cout << "ClusterCollection::doTimeClustering" << std::endl;
  }
  double distance = 1.e30; // initial distance value, "far away"
 
  while (m_clusters.size() > 1) {
    int i0 = 0;
    int j0 = 0;
    if (m_debug_level > 0) {
      std::cout << "using " << m_clusters.size() << " vertices" << std::endl;
    }
    // find the two vertices that are closest to each other
    distance = getDistanceBetweenClusters(m_clusters.at(0), m_clusters.at(1));
    for (size_t i = 0; i < m_clusters.size(); i++) {
      for (size_t j = i + 1; j < m_clusters.size(); j++) {
 
        if (algo == ClusterAlgo::Simultaneous ||
            algo == ClusterAlgo::SimultaneousMean) {
 
          if (m_clusters.at(i).mergeStatus() or m_clusters.at(j).mergeStatus()) {
            continue;
          }
        }
 
        double current_distance =
            getDistanceBetweenClusters(m_clusters.at(i), m_clusters.at(j));
        if (current_distance <= distance) {
          distance = current_distance;
          i0 = i;
          j0 = j;
        }
      } // loop over j
    }   // loop over i
    if (m_debug_level > 0) {
      std::cout << "using vertex " << i0 << " and " << j0 << std::endl;
    }
    // now the closest two vertices are found and will be fused if cut passes
    if (distance < m_distance_cut && i0 != j0) {
 
      Cluster<T> new_cluster { };
 
      if (algo == ClusterAlgo::SimultaneousMean) {
        new_cluster = mergeClustersMean(m_clusters.at(i0), m_clusters.at(j0));
      } else {
        new_cluster = mergeClusters(m_clusters.at(i0), m_clusters.at(j0));
      }
 
      if (m_debug_level > 0) {
        std::cout << "starting to erase" << std::endl;
      }
      m_clusters.erase(m_clusters.begin() + j0);
      if (i0 < j0) {
        m_clusters.erase(m_clusters.begin() + i0);
      } else {
        m_clusters.erase(m_clusters.begin() + (i0 - 1));
      }
      if (m_debug_level > 0) {
        std::cout << "erase done" << std::endl;
      }
      m_clusters.push_back(new_cluster);
      if (m_debug_level > 0) {
        std::cout << "new cluster stored" << std::endl;
      }
    } else {
      if (algo == ClusterAlgo::Eager) {
        break;
      }
      // if there is a cluster that was merged
      if (std::find_if(m_clusters.begin(), m_clusters.end(),
                       [](const Cluster<T> &c) { return c.mergeStatus(); }) !=
          m_clusters.end()) {
        // reset each status to false
        std::for_each(m_clusters.begin(), m_clusters.end(), [](Cluster<T> &c) {
          c.setMergeStatus(false);
        });
      } else {
        // if not, this is the end of the clustering
        break;
      }
    }
  } // while loop
}

getClusters()

template<typename T >

const std::vector< Cluster< T > > & HGTD::ClusterCollection< T >::getClusters

Definition at line 506 of file Clustering.h.

                                                                     {
  return m_clusters;
}

getDistanceBetweenClusters()

template<typename T >

double HGTD::ClusterCollection< T >::getDistanceBetweenClusters ( const Cluster< T > &  a, const Cluster< T > &  b  )

private

Definition at line 279 of file Clustering.h.

                                                                             {
  std::vector<double> a_values = a.getValues();
  std::vector<double> b_values = b.getValues();
  std::vector<double> a_sigmas = a.getSigmas();
  std::vector<double> b_sigmas = b.getSigmas();
 
  std::vector<double> distances(a_values.size());
  for (size_t i = 0; i < a_values.size(); i++) {
    double distance_i = 0;
    if (a_sigmas.at(i) >= 0.0 && b_sigmas.at(i) >= 0.0) {
      distance_i = std::abs(a_values.at(i) - b_values.at(i)) /
                   std::hypot(a_sigmas.at(i), b_sigmas.at(i));
    }
    distances.at(i) = distance_i;
  }
  double distance2 = 0.;
  for (double d : distances) {
    distance2 += d * d;
  }
  return std::sqrt(distance2);
}

getMaxClusterSize_Info()

template<typename T >

int HGTD::ClusterCollection< T >::getMaxClusterSize_Info

Definition at line 497 of file Clustering.h.

                                                                       {
  // find the vertex with a maximum amount of hits clustered in it
  // and return thisn umber
  const auto [max_cluster, nMaxClusters] = largestClusterInfo();
 
  return max_cluster.getNEntries();
}

getMaxEntriesCluster()

template<typename T >

Cluster< T > HGTD::ClusterCollection< T >::getMaxEntriesCluster

Definition at line 486 of file Clustering.h.

                                                                            {
 
  const auto [max_cluster, nMaxClusters] = largestClusterInfo();
  // If two or more clusters have the same maximum number of entries, I can't
  // decide, so return default
  if (nMaxClusters > 1) {
    return Cluster<T> { };
  }
  return max_cluster;
}

getNClusters()

template<typename T >

int HGTD::ClusterCollection< T >::getNClusters

Definition at line 510 of file Clustering.h.

                                                                   {
  return static_cast<int>(m_clusters.size());
}

largestClusterInfo()

template<typename T >

std::pair< Cluster< T >, int > HGTD::ClusterCollection< T >::largestClusterInfo

private

Definition at line 464 of file Clustering.h.

                                                                  {
 
  int max_n_hits = 0;
  int count = 0;
  Cluster<T> max_n_vertex { };
 
  for (const auto& vx : m_clusters) {
    int current_n = vx.getNEntries();
 
    if (current_n > max_n_hits) {
      max_n_hits = current_n;
      max_n_vertex = vx;
      count = 1;
    }
    else if (current_n == max_n_hits) {
      count++;
    }
  }
 
  return std::make_pair(max_n_vertex, count);
}

mergeClusters()

template<class T >

Cluster< T > HGTD::ClusterCollection< T >::mergeClusters ( const Cluster< T > &  a, const Cluster< T > &  b  )

private

Creates a new Cluster object that is a fusion of the two clusters given in the arguments.

Parameters

[in]	a	A cluster that should be merged.
[in]	b	A cluster that should be merged.

Definition at line 303 of file Clustering.h.

                                                                    {
  Cluster<T> merged_cluster;
  merged_cluster.addEntryVector(a.getEntries());
  merged_cluster.addEntryVector(b.getEntries());
 
  std::vector<double> a_values = a.getValues();
  std::vector<double> b_values = b.getValues();
  std::vector<double> a_sigmas = a.getSigmas();
  std::vector<double> b_sigmas = b.getSigmas();
 
  std::vector<double> new_cluster_values(a_values.size());
  std::vector<double> new_cluster_sigmas(a_values.size());
 
  for (size_t i = 0; i < a_values.size(); i++) {
    double value1 = a_values.at(i);
    double value2 = b_values.at(i);
    double var1 = std::pow(a_sigmas.at(i), 2.0);
    double var2 = std::pow(b_sigmas.at(i), 2.0);
    double new_cluster_value =
        (value1 / var1 + value2 / var2) / (1.0 / var1 + 1.0 / var2);
    double new_cluster_sigma = std::sqrt(var1 * var2 / (var1 + var2));
    new_cluster_values.at(i) = new_cluster_value;
    new_cluster_sigmas.at(i) = new_cluster_sigma;
  }
  int new_merge_iteration = a.getMergeIteration() + b.getMergeIteration() + 1;
  merged_cluster.setClusterValue(new_cluster_values, new_cluster_sigmas);
  merged_cluster.setMergeStatus(true);
  merged_cluster.setMergeIteration(new_merge_iteration);
  return merged_cluster;
}

mergeClustersMean()

template<class T >

Cluster< T > HGTD::ClusterCollection< T >::mergeClustersMean ( const Cluster< T > &  a, const Cluster< T > &  b  )

private

Definition at line 336 of file Clustering.h.

                                                                        {
  Cluster<T> merged_cluster;
  merged_cluster.addEntryVector(a.getEntries());
  merged_cluster.addEntryVector(b.getEntries());
 
  std::vector<double> a_values = a.getValues();
  std::vector<double> b_values = b.getValues();
  std::vector<double> a_sigmas = a.getSigmas();
  std::vector<double> b_sigmas = b.getSigmas();
 
  std::vector<double> new_cluster_values(a_values.size());
  std::vector<double> new_cluster_sigmas(a_values.size());
 
  for (size_t i = 0; i < a_values.size(); i++) {
    double value1 = a_values.at(i);
    double value2 = b_values.at(i);
    double sigma1 = a_sigmas.at(i);
    double sigma2 = b_sigmas.at(i);
    double new_cluster_value = (value1 + value2) / 2.;
    double new_cluster_sigma = std::hypot(sigma1, sigma2);
    new_cluster_values.at(i) = new_cluster_value;
    new_cluster_sigmas.at(i) = new_cluster_sigma;
  }
  int new_merge_iteration = a.getMergeIteration() + b.getMergeIteration() + 1;
  merged_cluster.setClusterValue(new_cluster_values, new_cluster_sigmas);
  merged_cluster.setMergeStatus(true);
  merged_cluster.setMergeIteration(new_merge_iteration);
  return merged_cluster;
}

setDebugLevel()

template<typename T >

void HGTD::ClusterCollection< T >::setDebugLevel ( int  debug_level )

inline

Definition at line 157 of file Clustering.h.

{ m_debug_level = debug_level; }

updateDistanceCut()

template<class T >

void HGTD::ClusterCollection< T >::updateDistanceCut

(

double

cut_value

)

Set the distance cut.

This allows an update and rerunning of the vertexing then no vertex that fulfills the selection criteria is found.

Parameters

[in]

cut_value

Given in units of resolution.

Definition at line 270 of file Clustering.h.

                                                             {
  m_distance_cut = cut_value;
}

Member Data Documentation

m_clusters

template<typename T >

std::vector<Cluster<T> > HGTD::ClusterCollection< T >::m_clusters

private

Definition at line 162 of file Clustering.h.

m_debug_level

template<typename T >

int HGTD::ClusterCollection< T >::m_debug_level = 0

private

Definition at line 160 of file Clustering.h.

m_distance_cut

template<typename T >

double HGTD::ClusterCollection< T >::m_distance_cut = 3.0

private

Definition at line 161 of file Clustering.h.

---

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

• Clustering.h