ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Private Member Functions | Private Attributes | List of all members
HGTD::ClusterCollection< T > Class Template Reference

#include <Clustering.h>

Collaboration diagram for HGTD::ClusterCollection< T >:

Public Member Functions

void addCluster (const 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.
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.
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 ( const Cluster< T > & vx)

Definition at line 263 of file Clustering.h.

263 {
264 m_clusters.push_back(vx);
265}
HGTD::ClusterCollection::m_clusters
std::vector< Cluster< T > > m_clusters
Definition Clustering.h:162

◆ doClustering()

template<typename T>
void HGTD::ClusterCollection< T >::doClustering ( ClusterAlgo algo)

Definition at line 357 of file Clustering.h.

357 {
358 if (algo == ClusterAlgo::Eager) {
359 for (const auto &clust : m_clusters) {
360 if (clust.containsUnknowns()) {
361 throw std::invalid_argument(
362 "[ClusterCollection::doClustering] ERROR "
363 "- eager clustering does not allow for unknown values");
364 }
365 }
366 }
367
368 // TODO case where I have 2 vertices in my collection
369 if (m_debug_level > 0) {
370 std::cout << "ClusterCollection::doTimeClustering" << std::endl;
371 }
372 double distance = 1.e30; // initial distance value, "far away"
373
374 while (m_clusters.size() > 1) {
375 int i0 = 0;
376 int j0 = 0;
377 if (m_debug_level > 0) {
378 std::cout << "using " << m_clusters.size() << " vertices" << std::endl;
379 }
380 // find the two vertices that are closest to each other
381 distance = getDistanceBetweenClusters(m_clusters.at(0), m_clusters.at(1));
382 for (size_t i = 0; i < m_clusters.size(); i++) {
383 for (size_t j = i + 1; j < m_clusters.size(); j++) {
384
385 if (algo == ClusterAlgo::Simultaneous ||
386 algo == ClusterAlgo::SimultaneousMean) {
387
388 if (m_clusters.at(i).mergeStatus() or m_clusters.at(j).mergeStatus()) {
389 continue;
390 }
391 }
392
393 double current_distance =
394 getDistanceBetweenClusters(m_clusters.at(i), m_clusters.at(j));
395 if (current_distance <= distance) {
396 distance = current_distance;
397 i0 = i;
398 j0 = j;
399 }
400 } // loop over j
401 } // loop over i
402 if (m_debug_level > 0) {
403 std::cout << "using vertex " << i0 << " and " << j0 << std::endl;
404 }
405 // now the closest two vertices are found and will be fused if cut passes
406 if (distance < m_distance_cut && i0 != j0) {
407
408 Cluster<T> new_cluster { };
409
410 if (algo == ClusterAlgo::SimultaneousMean) {
411 new_cluster = mergeClustersMean(m_clusters.at(i0), m_clusters.at(j0));
412 } else {
413 new_cluster = mergeClusters(m_clusters.at(i0), m_clusters.at(j0));
414 }
415
416 if (m_debug_level > 0) {
417 std::cout << "starting to erase" << std::endl;
418 }
419 m_clusters.erase(m_clusters.begin() + j0);
420 if (i0 < j0) {
421 m_clusters.erase(m_clusters.begin() + i0);
422 } else {
423 m_clusters.erase(m_clusters.begin() + (i0 - 1));
424 }
425 if (m_debug_level > 0) {
426 std::cout << "erase done" << std::endl;
427 }
428 m_clusters.push_back(std::move(new_cluster));
429 if (m_debug_level > 0) {
430 std::cout << "new cluster stored" << std::endl;
431 }
432 } else {
433 if (algo == ClusterAlgo::Eager) {
434 break;
435 }
436 // if there is a cluster that was merged
437 if (std::find_if(m_clusters.begin(), m_clusters.end(),
438 [](const Cluster<T> &c) { return c.mergeStatus(); }) !=
439 m_clusters.end()) {
440 // reset each status to false
441 std::for_each(m_clusters.begin(), m_clusters.end(), [](Cluster<T> &c) {
442 c.setMergeStatus(false);
443 });
444 } else {
445 // if not, this is the end of the clustering
446 break;
447 }
448 }
449 } // while loop
450}
HGTD::ClusterCollection::mergeClustersMean
Cluster< T > mergeClustersMean(const Cluster< T > &a, const Cluster< T > &b)
Definition Clustering.h:325
HGTD::ClusterCollection::getDistanceBetweenClusters
double getDistanceBetweenClusters(const Cluster< T > &a, const Cluster< T > &b)
Definition Clustering.h:268
HGTD::ClusterCollection::mergeClusters
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.
Definition Clustering.h:292

◆ getClusters()

template<typename T>
const std::vector< Cluster< T > > & HGTD::ClusterCollection< T >::getClusters ( ) const

Definition at line 495 of file Clustering.h.

495 {
496 return m_clusters;
497}

◆ getDistanceBetweenClusters()

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

Definition at line 268 of file Clustering.h.

269 {
270 std::vector<double> a_values = a.getValues();
271 std::vector<double> b_values = b.getValues();
272 std::vector<double> a_sigmas = a.getSigmas();
273 std::vector<double> b_sigmas = b.getSigmas();
274
275 std::vector<double> distances(a_values.size());
276 for (size_t i = 0; i < a_values.size(); i++) {
277 double distance_i = 0;
278 if (a_sigmas.at(i) >= 0.0 && b_sigmas.at(i) >= 0.0) {
279 distance_i = std::abs(a_values.at(i) - b_values.at(i)) /
280 std::hypot(a_sigmas.at(i), b_sigmas.at(i));
281 }
282 distances.at(i) = distance_i;
283 }
284 double distance2 = 0.;
285 for (double d : distances) {
286 distance2 += d * d;
287 }
288 return std::sqrt(distance2);
289}

◆ getMaxClusterSize_Info()

template<typename T>
int HGTD::ClusterCollection< T >::getMaxClusterSize_Info ( )

Definition at line 486 of file Clustering.h.

486 {
487 // find the vertex with a maximum amount of hits clustered in it
488 // and return thisn umber
489 const auto [max_cluster, nMaxClusters] = largestClusterInfo();
490
491 return max_cluster.getNEntries();
492}
HGTD::ClusterCollection::largestClusterInfo
std::pair< Cluster< T >, int > largestClusterInfo()
Definition Clustering.h:453

◆ getMaxEntriesCluster()

template<typename T>
Cluster< T > HGTD::ClusterCollection< T >::getMaxEntriesCluster ( )

Definition at line 475 of file Clustering.h.

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

◆ getNClusters()

template<typename T>
int HGTD::ClusterCollection< T >::getNClusters ( ) const

Definition at line 499 of file Clustering.h.

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

◆ largestClusterInfo()

template<typename T>
std::pair< Cluster< T >, int > HGTD::ClusterCollection< T >::largestClusterInfo ( )
private

Definition at line 453 of file Clustering.h.

453 {
454
455 int max_n_hits = 0;
456 int count = 0;
457 Cluster<T> max_n_vertex { };
458
459 for (const auto& vx : m_clusters) {
460 int current_n = vx.getNEntries();
461
462 if (current_n > max_n_hits) {
463 max_n_hits = current_n;
464 max_n_vertex = vx;
465 count = 1;
466 }
467 else if (current_n == max_n_hits) {
468 count++;
469 }
470 }
471
472 return std::make_pair(max_n_vertex, count);
473}

◆ 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]aA cluster that should be merged.
[in]bA cluster that should be merged.

Definition at line 292 of file Clustering.h.

293 {
294 Cluster<T> merged_cluster;
295 merged_cluster.addEntryVector(a.getEntries());
296 merged_cluster.addEntryVector(b.getEntries());
297
298 std::vector<double> a_values = a.getValues();
299 std::vector<double> b_values = b.getValues();
300 std::vector<double> a_sigmas = a.getSigmas();
301 std::vector<double> b_sigmas = b.getSigmas();
302
303 std::vector<double> new_cluster_values(a_values.size());
304 std::vector<double> new_cluster_sigmas(a_values.size());
305
306 for (size_t i = 0; i < a_values.size(); i++) {
307 double value1 = a_values.at(i);
308 double value2 = b_values.at(i);
309 double var1 = std::pow(a_sigmas.at(i), 2.0);
310 double var2 = std::pow(b_sigmas.at(i), 2.0);
311 double new_cluster_value =
312 (value1 / var1 + value2 / var2) / (1.0 / var1 + 1.0 / var2);
313 double new_cluster_sigma = std::sqrt(var1 * var2 / (var1 + var2));
314 new_cluster_values.at(i) = new_cluster_value;
315 new_cluster_sigmas.at(i) = new_cluster_sigma;
316 }
317 int new_merge_iteration = a.getMergeIteration() + b.getMergeIteration() + 1;
318 merged_cluster.setClusterValue(new_cluster_values, new_cluster_sigmas);
319 merged_cluster.setMergeStatus(true);
320 merged_cluster.setMergeIteration(new_merge_iteration);
321 return merged_cluster;
322}

◆ mergeClustersMean()

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

Definition at line 325 of file Clustering.h.

326 {
327 Cluster<T> merged_cluster;
328 merged_cluster.addEntryVector(a.getEntries());
329 merged_cluster.addEntryVector(b.getEntries());
330
331 std::vector<double> a_values = a.getValues();
332 std::vector<double> b_values = b.getValues();
333 std::vector<double> a_sigmas = a.getSigmas();
334 std::vector<double> b_sigmas = b.getSigmas();
335
336 std::vector<double> new_cluster_values(a_values.size());
337 std::vector<double> new_cluster_sigmas(a_values.size());
338
339 for (size_t i = 0; i < a_values.size(); i++) {
340 double value1 = a_values.at(i);
341 double value2 = b_values.at(i);
342 double sigma1 = a_sigmas.at(i);
343 double sigma2 = b_sigmas.at(i);
344 double new_cluster_value = (value1 + value2) / 2.;
345 double new_cluster_sigma = std::hypot(sigma1, sigma2);
346 new_cluster_values.at(i) = new_cluster_value;
347 new_cluster_sigmas.at(i) = new_cluster_sigma;
348 }
349 int new_merge_iteration = a.getMergeIteration() + b.getMergeIteration() + 1;
350 merged_cluster.setClusterValue(new_cluster_values, new_cluster_sigmas);
351 merged_cluster.setMergeStatus(true);
352 merged_cluster.setMergeIteration(new_merge_iteration);
353 return merged_cluster;
354}

◆ setDebugLevel()

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

Definition at line 157 of file Clustering.h.

157{ 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_valueGiven in units of resolution.

Definition at line 259 of file Clustering.h.

259 {
260 m_distance_cut = cut_value;
261}

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:
Generated on for ATLAS Offline Software by doxygen 1.17.0