Gep::BasicGepClusterMaker Class Reference

#include <BasicGepClusterMaker.h>

Inheritance diagram for Gep::BasicGepClusterMaker:

Collaboration diagram for Gep::BasicGepClusterMaker:

Public Member Functions
	BasicGepClusterMaker ()=default
	~BasicGepClusterMaker ()=default
std::vector< Gep::Cluster >	makeClusters (const pGepCellMap &) const override
std::string	getName () const override

Private Member Functions
bool	isSeedCell (const Gep::GepCaloCell &cell, const std::vector< unsigned int > &seenSeedCells) const
bool	isInAllowedSampling (int sampling, const std::vector< int > &list_of_samplings) const
bool	isNewCell (unsigned int id, const std::vector< unsigned int > &seenCells) const
std::vector< Gep::GepCaloCell >	clusterFromCells (const Gep::GepCaloCell &seed, const pGepCellMap &, std::vector< unsigned int > &seenSeedCells) const
Gep::Cluster	getClusterFromListOfCells (const std::vector< Gep::GepCaloCell > &cells) const

Private Attributes
const float	m_seed_threshold = 4.0
const float	m_clustering_threshold = 2.0
const int	m_max_shells = 9999
const std::vector< int >	m_disallowed_seed_samplings = {}
const std::vector< int >	m_disallowed_clustering_samplings = {}

Detailed Description

Definition at line 14 of file BasicGepClusterMaker.h.

Constructor & Destructor Documentation

BasicGepClusterMaker()

Gep::BasicGepClusterMaker::BasicGepClusterMaker ( )

default

~BasicGepClusterMaker()

Gep::BasicGepClusterMaker::~BasicGepClusterMaker ( )

default

Member Function Documentation

clusterFromCells()

std::vector< Gep::GepCaloCell > Gep::BasicGepClusterMaker::clusterFromCells ( const Gep::GepCaloCell &  seed, const pGepCellMap &  caloCellsMap, std::vector< unsigned int > &  seenSeedCells  ) const

private

Definition at line 64 of file BasicGepClusterMaker.cxx.

                                                                                                     {
 
  std::vector<Gep::GepCaloCell> v_clusterCells;
 
  std::vector<Gep::GepCaloCell> cellsNextLayer, cellsThisLayer;
  std::vector<unsigned int> seenCells;
 
  // Fill seed into supporting vectors
  v_clusterCells.push_back(seed);
  cellsNextLayer.push_back(seed);
  seenCells.push_back(seed.id);
  seenSeedCells.push_back(seed.id);
 
  int i_shell = 1;
 
  while (!cellsNextLayer.empty() && i_shell <= m_max_shells) {
 
        cellsThisLayer.swap(cellsNextLayer);
        cellsNextLayer.clear();
        ++i_shell;
 
        // Loop over all cells in this shell
        for (unsigned int i_cell = 0; i_cell < cellsThisLayer.size(); ++i_cell) {
 
                // Go through list of neighbouring cells and check whether they are part of the cluster
                for (unsigned int i_neighbour = 0; i_neighbour < (cellsThisLayer[i_cell]).neighbours.size(); ++i_neighbour) {
 
            // Check whether this neighbouring cell was sent to the GEP
            auto const& nghbr_itr = caloCellsMap->find((cellsThisLayer[i_cell]).neighbours[i_neighbour]);
            if (nghbr_itr == caloCellsMap->end()) continue;
 
            Gep::GepCaloCell neighbour = nghbr_itr->second;
 
                        // reject if bad cell
                        if (neighbour.isBadCell()) continue;
 
                        // Reject if cell is not above clustering threshold
                        if (neighbour.sigma < m_clustering_threshold) continue;
 
                        // Reject if cell was already considered
                        if (!isNewCell(neighbour.id, seenCells)) continue;
 
                        // Ignore cells in disallowed samplings
                        if (!isInAllowedSampling(neighbour.sampling, m_disallowed_clustering_samplings)) continue;
 
                        seenCells.push_back(neighbour.id);
                        cellsNextLayer.push_back(neighbour);
                        v_clusterCells.push_back(neighbour);
 
            // If the cell is another seed cell, we write it into the list of seen seed cells to not reconstruct this cluster again
                        if (neighbour.sigma > m_seed_threshold) seenSeedCells.push_back(neighbour.id);
                }
        }
        cellsThisLayer.clear();
  }
 
  return v_clusterCells;
}

getClusterFromListOfCells()

Gep::Cluster Gep::BasicGepClusterMaker::getClusterFromListOfCells ( const std::vector< Gep::GepCaloCell > &  cells ) const

private

Definition at line 125 of file BasicGepClusterMaker.cxx.

                                                                                                          {
 
  Gep::Cluster cluster;
  std::vector<unsigned int> v_cellIDs;
 
  TLorentzVector tlv_cluster;
  for (unsigned int i_cell = 0; i_cell < cells.size(); ++i_cell) {
    TLorentzVector cell;
    cell.SetPtEtaPhiE(cells[i_cell].et, cells[i_cell].eta, cells[i_cell].phi, cells[i_cell].et*std::cosh(cells[i_cell].eta));
 
    tlv_cluster += cell;
 
    v_cellIDs.push_back(cells[i_cell].id);
  }
 
  cluster.ncells = cells.size();
  cluster.time = cells[0].time; // Take time of seed cell
  cluster.cell_id = std::move(v_cellIDs);
  cluster.setEtEtaPhi(tlv_cluster.Et(), tlv_cluster.Eta(), tlv_cluster.Phi());
 
  return cluster;
}

getName()

std::string Gep::BasicGepClusterMaker::getName ( ) const

overridevirtual

Implements Gep::IClusterMaker.

Definition at line 149 of file BasicGepClusterMaker.cxx.

                                                 {
  return "GEPBasic";
}

isInAllowedSampling()

bool Gep::BasicGepClusterMaker::isInAllowedSampling ( int  sampling, const std::vector< int > &  list_of_samplings  ) const

private

Definition at line 44 of file BasicGepClusterMaker.cxx.

                                                                                                             {
 
  for (unsigned int i = 0; i < list_of_samplings.size(); ++i) {
    if (list_of_samplings[i] == sampling) return false;
  }
  return true;
}

isNewCell()

bool Gep::BasicGepClusterMaker::isNewCell ( unsigned int  id, const std::vector< unsigned int > &  seenCells  ) const

private

Definition at line 53 of file BasicGepClusterMaker.cxx.

                                                                                                       {
 
  for (unsigned int i = 0; i < seenCells.size(); ++i) {
        if (id == seenCells[i]) return false;
  }
 
  return true;
}

isSeedCell()

bool Gep::BasicGepClusterMaker::isSeedCell ( const Gep::GepCaloCell &  cell, const std::vector< unsigned int > &  seenSeedCells  ) const

private

Definition at line 33 of file BasicGepClusterMaker.cxx.

                                                                                                                        {
 
  if (cell.isBadCell()) return false;
  if (cell.sigma < m_seed_threshold) return false;
  if (!isNewCell(cell.id, seenSeedCells)) return false;
  if (!isInAllowedSampling(cell.sampling, m_disallowed_seed_samplings)) return false;
 
  return true;
}

makeClusters()

std::vector< Gep::Cluster > Gep::BasicGepClusterMaker::makeClusters ( const pGepCellMap &  caloCellsMap ) const

overridevirtual

Implements Gep::IClusterMaker.

Definition at line 8 of file BasicGepClusterMaker.cxx.

                                                                           {
 
  std::vector<Gep::Cluster> clusters;
 
  // Loop over all cells
  std::vector<unsigned int> seenSeedCells;
  for (auto const& cell_itr : *caloCellsMap) {
 
    // Select only seed cells
    if (!isSeedCell(cell_itr.second, seenSeedCells)) continue;
 
    // Clustering
        std::vector<Gep::GepCaloCell> cluster_cells = clusterFromCells(cell_itr.second, caloCellsMap, seenSeedCells);
    
        Gep::Cluster cluster = getClusterFromListOfCells(cluster_cells);
        clusters.push_back(cluster);
  }
 
  // Order topo clusters according to their Et
  std::sort(clusters.begin(), clusters.end(),[](const auto &c1, const auto &c2) {return c1.et() > c2.et();});
 
  return clusters;
}

Member Data Documentation

m_clustering_threshold

const float Gep::BasicGepClusterMaker::m_clustering_threshold = 2.0

private

Definition at line 29 of file BasicGepClusterMaker.h.

m_disallowed_clustering_samplings

const std::vector<int> Gep::BasicGepClusterMaker::m_disallowed_clustering_samplings = {}

private

Definition at line 33 of file BasicGepClusterMaker.h.

m_disallowed_seed_samplings

const std::vector<int> Gep::BasicGepClusterMaker::m_disallowed_seed_samplings = {}

private

Definition at line 32 of file BasicGepClusterMaker.h.

m_max_shells

const int Gep::BasicGepClusterMaker::m_max_shells = 9999

private

Definition at line 30 of file BasicGepClusterMaker.h.

m_seed_threshold

const float Gep::BasicGepClusterMaker::m_seed_threshold = 4.0

private

Definition at line 28 of file BasicGepClusterMaker.h.

---

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

• BasicGepClusterMaker.h
• BasicGepClusterMaker.cxx