Clusterizend Class Reference

Clustering module. More...

#include <Clusterizend.h>

Classes
struct	DeletionBounds
	Struct containing the deletion bounds of a omega row. More...

Public Member Functions
	Clusterizend (const ClustererParameters &parameters)
	To set custom clustering parameters.
void	setNewPlane (c3array &houghSpace)
	Set a new Hough space for clustering and track finding.
std::vector< SimpleCluster >	makeClusters ()
	Create all the clusters in the Hough space.

Private Member Functions
std::array< c3index, 2 >	getSectionBounds (const unsigned short quadrant, const unsigned section)
	Get the phi bounds of one quadrant section.
void	iterateOverSection (const std::array< c3index, 2 > &sectionBounds, std::vector< SimpleCluster > &candidateClusters)
	Iterate m_clustererParams.iterations times over one section.
std::pair< cell_index, unsigned int >	getSectionPeak (const std::array< c3index, 2 > &sectionBounds)
	Returns the global section peak index and weight.
SimpleCluster	createCluster (const cell_index &peakCell)
	Creates the surrounding cluster (fixed shape) around the section peak index.
void	deletePeakSurroundings (const cell_index &peakCell)
	Deletes the surroundings of such a cluster.
void	clearHoughSpaceRow (const DeletionBounds &bounds)
	Method to delete a omega row for the cluster deletion in deletePeakSurroundings method.

Private Attributes
ClustererParameters	m_clustererParams
	The struct holding the cluster parameters.
c3array *	m_houghSpace {0}
	Pointer to the Hough space.

Detailed Description

Clustering module.

Definition at line 71 of file Clusterizend.h.

Constructor & Destructor Documentation

Clusterizend()

Clusterizend ( const ClustererParameters & parameters )

inlineexplicit

To set custom clustering parameters.

Definition at line 85 of file Clusterizend.h.

: m_clustererParams(parameters) {}

Member Function Documentation

clearHoughSpaceRow()

void clearHoughSpaceRow ( const DeletionBounds & bounds )

private

Method to delete a omega row for the cluster deletion in deletePeakSurroundings method.

Definition at line 163 of file Clusterizend.cc.

{
  for (c3index phiIdx = bounds.phiLowerBound; phiIdx < bounds.phiUpperBound; ++phiIdx) {
    c3index phiIdxMod = (phiIdx + m_clustererParams.nPhi) % m_clustererParams.nPhi;
    (*m_houghSpace)[bounds.omega][phiIdxMod][bounds.cot] = 0;
  }
}

createCluster()

SimpleCluster createCluster ( const cell_index & peakCell )

private

Creates the surrounding cluster (fixed shape) around the section peak index.

Definition at line 84 of file Clusterizend.cc.

{
  c3index omegaPeak = peakCell[0];
  c3index phiPeak = peakCell[1];
  c3index cotPeak = peakCell[2];
 
  c3index cotLower = cotPeak - 1;
  c3index cotUpper = cotPeak + 1;
 
  c3index phiLeft = (phiPeak - 1 + m_clustererParams.nPhi) % m_clustererParams.nPhi;
  c3index phiRight = (phiPeak + 1 + m_clustererParams.nPhi) % m_clustererParams.nPhi;
 
  c3index omegaUpperRight = omegaPeak - 1;
  c3index omegaLowerLeft = omegaPeak + 1;
 
  // Add in-bound cells to the cluster:
  SimpleCluster fixedCluster;
  fixedCluster.appendCell(peakCell);
  fixedCluster.appendCell({omegaPeak, phiLeft, cotPeak});
  fixedCluster.appendCell({omegaPeak, phiRight, cotPeak});
  if (cotLower >= 0) {
    fixedCluster.appendCell({omegaPeak, phiPeak, cotLower});
  }
  if (cotUpper < m_clustererParams.nCot) {
    fixedCluster.appendCell({omegaPeak, phiPeak, cotUpper});
  }
  if (omegaUpperRight >= 0) {
    fixedCluster.appendCell({omegaUpperRight, phiRight, cotPeak});
  }
  if (omegaLowerLeft < m_clustererParams.nOmega) {
    fixedCluster.appendCell({omegaLowerLeft, phiLeft, cotPeak});
  }
  return fixedCluster;
}

deletePeakSurroundings()

void deletePeakSurroundings ( const cell_index & peakCell )

private

Deletes the surroundings of such a cluster.

Definition at line 120 of file Clusterizend.cc.

{
  c3index omegaPeak = peakCell[0];
  c3index phiPeak = peakCell[1];
 
  c3index omegaLowerBound = std::max<unsigned short>(0, omegaPeak - m_clustererParams.omegaTrim);
  c3index omegaUpperBound = std::min<unsigned short>(m_clustererParams.nOmega, omegaPeak + m_clustererParams.omegaTrim + 1);
 
  for (c3index cotIdx = 0; cotIdx < m_clustererParams.nCot; ++cotIdx) {
    for (c3index omegaIdx = omegaLowerBound; omegaIdx < omegaUpperBound; ++omegaIdx) {
      c3index phiCell = phiPeak + omegaPeak - omegaIdx;
      c3index relativePhi = phiCell - phiPeak;
 
      if (relativePhi > 0) {
        DeletionBounds firstBounds = {
          phiCell - m_clustererParams.phiTrim,
          static_cast<c3index>(phiCell + m_clustererParams.phiTrim + std::floor(2.4 * relativePhi)),
          omegaIdx,
          cotIdx
        };
        clearHoughSpaceRow(firstBounds);
      } else if (relativePhi < 0) {
        DeletionBounds secondBounds = {
          static_cast<c3index>(phiCell - m_clustererParams.phiTrim + std::ceil(2.4 * relativePhi)),
          phiCell + m_clustererParams.phiTrim + 1,
          omegaIdx,
          cotIdx
        };
        clearHoughSpaceRow(secondBounds);
      } else {
        DeletionBounds thirdBounds = {
          phiCell - m_clustererParams.phiTrim,
          phiCell + m_clustererParams.phiTrim + 1,
          omegaIdx,
          cotIdx
        };
        clearHoughSpaceRow(thirdBounds);
      }
    }
  }
}

getSectionBounds()

std::array< c3index, 2 > getSectionBounds ( const unsigned short quadrant, const unsigned section )

private

Get the phi bounds of one quadrant section.

Definition at line 34 of file Clusterizend.cc.

{
  c3index quadrantSize = m_clustererParams.nPhi / 4;
  c3index quadrantOffset = m_clustererParams.nPhi / 8;
  c3index sectionSize = quadrantSize / 4;
 
  c3index quadrantStart = quadrant * quadrantSize + quadrantOffset;
  c3index sectionStart = quadrantStart + section * sectionSize;
  c3index sectionEnd = sectionStart + sectionSize;
 
  return {sectionStart, sectionEnd};
}

getSectionPeak()

std::pair< cell_index, unsigned int > getSectionPeak ( const std::array< c3index, 2 > & sectionBounds )

private

Returns the global section peak index and weight.

Definition at line 65 of file Clusterizend.cc.

{
  unsigned int peakValue = 0;
  cell_index peakCell = {0, 0, 0};
  for (c3index omegaIdx = 0; omegaIdx < m_clustererParams.nOmega; ++omegaIdx) {
    for (c3index phiIdx = sectionBounds[0]; phiIdx < sectionBounds[1]; ++phiIdx) {
      c3index phiIdxMod = phiIdx % m_clustererParams.nPhi;
      for (c3index cotIdx = 0; cotIdx < m_clustererParams.nCot; ++cotIdx) {
        if ((*m_houghSpace)[omegaIdx][phiIdxMod][cotIdx] > peakValue) {
          peakValue = (*m_houghSpace)[omegaIdx][phiIdxMod][cotIdx];
          peakCell = {omegaIdx, phiIdxMod, cotIdx};
        }
      }
    }
  }
  return {peakCell, peakValue};
}

iterateOverSection()

void iterateOverSection ( const std::array< c3index, 2 > & sectionBounds, std::vector< SimpleCluster > & candidateClusters )

private

Iterate m_clustererParams.iterations times over one section.

Definition at line 48 of file Clusterizend.cc.

{
  for (unsigned short _ = 0; _ < m_clustererParams.iterations; ++_) {
    auto [sectionPeak, peakWeight] = getSectionPeak(sectionBounds);
    // Ignore the cluster if the peak  weight is below 10 (reduces processing)
    if (peakWeight < 10) {
      break;
    }
    SimpleCluster newCluster = createCluster(sectionPeak);
    newCluster.setPeakCell(sectionPeak);
    newCluster.setPeakWeight(peakWeight);
    candidateClusters.push_back(newCluster);
    if (m_clustererParams.iterations > 1) deletePeakSurroundings(sectionPeak);
  }
}

makeClusters()

std::vector< SimpleCluster > makeClusters

(

)

Create all the clusters in the Hough space.

Definition at line 19 of file Clusterizend.cc.

{
  std::vector<SimpleCluster> candidateClusters;
  c3array houghSpaceBackup = *m_houghSpace;
  for (unsigned short quadrant = 0; quadrant < 4; ++quadrant) {
    for (unsigned short section = 0; section < 4; ++section) {
      std::array<c3index, 2> sectionBounds = getSectionBounds(quadrant, section);
      iterateOverSection(sectionBounds, candidateClusters);
      if (m_clustererParams.iterations > 1) *m_houghSpace = houghSpaceBackup;
    }
  }
  return candidateClusters;
}

setNewPlane()

void setNewPlane ( c3array & houghSpace )

inline

Set a new Hough space for clustering and track finding.

Definition at line 88 of file Clusterizend.h.

{ m_houghSpace = &houghSpace; }

Member Data Documentation

m_clustererParams

ClustererParameters m_clustererParams

private

The struct holding the cluster parameters.

Definition at line 106 of file Clusterizend.h.

m_houghSpace

c3array* m_houghSpace {0}

private

Pointer to the Hough space.

Definition at line 108 of file Clusterizend.h.

{0};

---

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

• trg/cdc/include/Clusterizend.h
• trg/cdc/src/Clusterizend.cc