#include <HGCalClusteringImpl.h>

Public Member Functions
void	clusterizeDR (const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &triggerCellsPtrs, l1t::HGCalClusterBxCollection &clusters)

void	clusterizeDRNN (const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &triggerCellsPtrs, l1t::HGCalClusterBxCollection &clusters, const HGCalTriggerGeometryBase &triggerGeometry)

void	clusterizeNN (const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &triggerCellsPtrs, l1t::HGCalClusterBxCollection &clusters, const HGCalTriggerGeometryBase &triggerGeometry)

	HGCalClusteringImpl (const edm::ParameterSet &conf)

bool	isPertinent (const l1t::HGCalTriggerCell &tc, const l1t::HGCalCluster &clu, double distXY) const

void	mergeClusters (l1t::HGCalCluster &main_cluster, const l1t::HGCalCluster &secondary_cluster) const

void	NNKernel (const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &reshuffledTriggerCells, l1t::HGCalClusterBxCollection &clusters, const HGCalTriggerGeometryBase &triggerGeometry)

void	setGeometry (const HGCalTriggerGeometryBase *const geom)

Private Member Functions
bool	areTCneighbour (uint32_t detIDa, uint32_t detIDb, const HGCalTriggerGeometryBase &triggerGeometry)

void	calibratePt (l1t::HGCalCluster &cluster)

void	removeUnconnectedTCinCluster (l1t::HGCalCluster &cluster, const HGCalTriggerGeometryBase &triggerGeometry)

void	triggerCellReshuffling (const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &triggerCellsPtrs, std::array< std::vector< std::vector< edm::Ptr< l1t::HGCalTriggerCell >>>, kNSides_ > &reshuffledTriggerCells)

Private Attributes
bool	applyLayerWeights_

double	calibSF_

std::string	clusteringAlgorithmType_

double	dr_

std::vector< double >	layerWeights_

double	scintillatorSeedThreshold_

double	scintillatorTriggerCellThreshold_

double	siliconSeedThreshold_

double	siliconTriggerCellThreshold_

HGCalTriggerTools	triggerTools_

Static Private Attributes
static constexpr unsigned	kNSides_ = 2

Detailed Description

Definition at line 18 of file HGCalClusteringImpl.h.

Constructor & Destructor Documentation

HGCalClusteringImpl::HGCalClusteringImpl ( const edm::ParameterSet & conf )

Definition at line 8 of file HGCalClusteringImpl.cc.

References calibSF_, clusteringAlgorithmType_, scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, siliconSeedThreshold_, and siliconTriggerCellThreshold_.

     : siliconSeedThreshold_(conf.getParameter<double>("seeding_threshold_silicon")),
       siliconTriggerCellThreshold_(conf.getParameter<double>("clustering_threshold_silicon")),
       scintillatorSeedThreshold_(conf.getParameter<double>("seeding_threshold_scintillator")),
       scintillatorTriggerCellThreshold_(conf.getParameter<double>("clustering_threshold_scintillator")),
       dr_(conf.getParameter<double>("dR_cluster")),
       clusteringAlgorithmType_(conf.getParameter<string>("clusterType")),
       calibSF_(conf.getParameter<double>("calibSF_cluster")),
       layerWeights_(conf.getParameter<std::vector<double>>("layerWeights")),
       applyLayerWeights_(conf.getParameter<bool>("applyLayerCalibration")) {
   edm::LogInfo("HGCalClusterParameters") << "C2d Clustering Algorithm selected : " << clusteringAlgorithmType_;
   edm::LogInfo("HGCalClusterParameters") << "C2d silicon seeding Thr: " << siliconSeedThreshold_;
   edm::LogInfo("HGCalClusterParameters") << "C2d silicon clustering Thr: " << siliconTriggerCellThreshold_;
   edm::LogInfo("HGCalClusterParameters") << "C2d scintillator seeding Thr: " << scintillatorSeedThreshold_;
   edm::LogInfo("HGCalClusterParameters") << "C2d scintillator clustering Thr: " << scintillatorTriggerCellThreshold_;
   edm::LogInfo("HGCalClusterParameters") << "C2d global calibration factor: " << calibSF_;
 }

Member Function Documentation

bool HGCalClusteringImpl::areTCneighbour	(	uint32_t	detIDa,
		uint32_t	detIDb,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

private

Definition at line 342 of file HGCalClusteringImpl.cc.

References HGCalTriggerGeometryBase::getNeighborsFromTriggerCell().

Referenced by clusterizeDRNN(), and removeUnconnectedTCinCluster().

                                                                                           {
   const auto neighbors = triggerGeometry.getNeighborsFromTriggerCell(detIDa);
 
   if (neighbors.find(detIDb) != neighbors.end())
     return true;
 
   return false;
 }

void HGCalClusteringImpl::calibratePt ( l1t::HGCalCluster & cluster )

private

Definition at line 397 of file HGCalClusteringImpl.cc.

References applyLayerWeights_, calibSF_, l1t::HGCalClusterT< C >::detId(), reco::LeafCandidate::eta(), Exception, layerWeights_, HGCalTriggerTools::layerWithOffset(), l1t::HGCalClusterT< C >::mipPt(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), reco::LeafCandidate::setP4(), and triggerTools_.

Referenced by clusterizeDR(), clusterizeDRNN(), and NNKernel().

                                                               {
   double calibPt = 0.;
 
   if (applyLayerWeights_) {
     unsigned layerN = triggerTools_.layerWithOffset(cluster.detId());
 
     if (layerWeights_.at(layerN) == 0.) {
       throw cms::Exception("BadConfiguration")
           << "2D cluster energy forced to 0 by calibration coefficients.\n"
           << "The configuration should be changed. "
           << "Discarded layers should be defined in hgcalTriggerGeometryESProducer.TriggerGeometry.DisconnectedLayers "
              "and not with calibration coefficients = 0\n";
     }
 
     calibPt = layerWeights_.at(layerN) * cluster.mipPt();
 
   }
 
   else {
     calibPt = cluster.pt() * calibSF_;
   }
 
   math::PtEtaPhiMLorentzVector calibP4(calibPt, cluster.eta(), cluster.phi(), 0.);
 
   cluster.setP4(calibP4);
 }

void HGCalClusteringImpl::clusterizeDR	(	const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &	triggerCellsPtrs,
		l1t::HGCalClusterBxCollection &	clusters
	)

Definition at line 42 of file HGCalClusteringImpl.cc.

References calibratePt(), ztail::d, dr_, HGCHEB, mps_fire::i, isPertinent(), BXVector< T >::resize(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, BXVector< T >::set(), siliconSeedThreshold_, siliconTriggerCellThreshold_, dtDQMClient_cfg::threshold, and trackerHitRTTI::vector.

                                                                               {
   bool isSeed[triggerCellsPtrs.size()];
 
   /* search for cluster seeds */
   int itc(0);
   for (std::vector<edm::Ptr<l1t::HGCalTriggerCell>>::const_iterator tc = triggerCellsPtrs.begin();
        tc != triggerCellsPtrs.end();
        ++tc, ++itc) {
     double seedThreshold = ((*tc)->subdetId() == HGCHEB ? scintillatorSeedThreshold_ : siliconSeedThreshold_);
     isSeed[itc] = ((*tc)->mipPt() > seedThreshold) ? true : false;
   }
 
   /* clustering the TCs */
   std::vector<l1t::HGCalCluster> clustersTmp;
 
   itc = 0;
   for (std::vector<edm::Ptr<l1t::HGCalTriggerCell>>::const_iterator tc = triggerCellsPtrs.begin();
        tc != triggerCellsPtrs.end();
        ++tc, ++itc) {
     double threshold = ((*tc)->subdetId() == HGCHEB ? scintillatorTriggerCellThreshold_ : siliconTriggerCellThreshold_);
     if ((*tc)->mipPt() < threshold) {
       continue;
     }
 
     /* 
            searching for TC near the center of the cluster  
            ToBeFixed: if a tc is not a seed, but could be potencially be part of a cluster generated by a late seed, 
                       the tc will not be clusterized  
         */
 
     double minDist = dr_;
     int targetClu = -1;
 
     for (unsigned iclu = 0; iclu < clustersTmp.size(); iclu++) {
       if (!this->isPertinent(**tc, clustersTmp.at(iclu), dr_))
         continue;
 
       double d = clustersTmp.at(iclu).distance(**tc);
       if (d < minDist) {
         minDist = d;
         targetClu = int(iclu);
       }
     }
 
     if (targetClu < 0 && isSeed[itc])
       clustersTmp.emplace_back(*tc);
     else if (targetClu >= 0)
       clustersTmp.at(targetClu).addConstituent(*tc);
   }
 
   /* store clusters in the persistent collection */
   clusters.resize(0, clustersTmp.size());
   for (unsigned i(0); i < clustersTmp.size(); ++i) {
     calibratePt(clustersTmp.at(i));
     clusters.set(0, i, clustersTmp.at(i));
   }
 }

void HGCalClusteringImpl::clusterizeDRNN	(	const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &	triggerCellsPtrs,
		l1t::HGCalClusterBxCollection &	clusters,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

Definition at line 250 of file HGCalClusteringImpl.cc.

References areTCneighbour(), calibratePt(), dr_, HGCHEB, mps_fire::i, isPertinent(), mag(), removeUnconnectedTCinCluster(), BXVector< T >::resize(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, BXVector< T >::set(), siliconSeedThreshold_, siliconTriggerCellThreshold_, dtDQMClient_cfg::threshold, and trackerHitRTTI::vector.

                                                                                           {
   bool isSeed[triggerCellsPtrs.size()];
   std::vector<unsigned> seedPositions;
   seedPositions.reserve(triggerCellsPtrs.size());
 
   /* search for cluster seeds */
   int itc(0);
   for (std::vector<edm::Ptr<l1t::HGCalTriggerCell>>::const_iterator tc = triggerCellsPtrs.begin();
        tc != triggerCellsPtrs.end();
        ++tc, ++itc) {
     double seedThreshold = ((*tc)->subdetId() == HGCHEB ? scintillatorSeedThreshold_ : siliconSeedThreshold_);
 
     /* decide if is a seed, if yes store the position into of triggerCellsPtrs */
     isSeed[itc] = ((*tc)->mipPt() > seedThreshold) ? true : false;
     if (isSeed[itc]) {
       seedPositions.push_back(itc);
 
       /* remove tc from the seed vector if is a NN of an other seed*/
       for (auto pos : seedPositions) {
         if (((*tc)->position() - triggerCellsPtrs[pos]->position()).mag() < dr_) {
           if (this->areTCneighbour((*tc)->detId(), triggerCellsPtrs[pos]->detId(), triggerGeometry)) {
             isSeed[itc] = false;
             seedPositions.pop_back();
           }
         }
       }
     }
   }
 
   /* clustering the TCs */
   std::vector<l1t::HGCalCluster> clustersTmp;
 
   // every seed generates a cluster
   clustersTmp.reserve(seedPositions.size());
   for (auto pos : seedPositions) {
     clustersTmp.emplace_back(triggerCellsPtrs[pos]);
   }
 
   /* add the tc to the clusters */
   itc = 0;
   for (std::vector<edm::Ptr<l1t::HGCalTriggerCell>>::const_iterator tc = triggerCellsPtrs.begin();
        tc != triggerCellsPtrs.end();
        ++tc, ++itc) {
     /* get the correct threshold for the different part of the detector */
     double threshold = ((*tc)->subdetId() == HGCHEB ? scintillatorTriggerCellThreshold_ : siliconTriggerCellThreshold_);
 
     /* continue if not passing the threshold */
     if ((*tc)->mipPt() < threshold)
       continue;
     if (isSeed[itc])
       continue;  //No sharing of seeds between clusters (TBC)
 
     /* searching for TC near the centre of the cluster  */
     std::vector<unsigned> tcPertinentClusters;
     unsigned iclu(0);
 
     for (const auto& clu : clustersTmp) {
       if (this->isPertinent(**tc, clu, dr_)) {
         tcPertinentClusters.push_back(iclu);
       }
       ++iclu;
     }
 
     if (tcPertinentClusters.empty()) {
       continue;
     } else if (tcPertinentClusters.size() == 1) {
       clustersTmp.at(tcPertinentClusters.at(0)).addConstituent(*tc);
     } else {
       /* calculate the fractions */
       double totMipt = 0;
       for (auto clu : tcPertinentClusters) {
         totMipt += clustersTmp.at(clu).seedMipPt();
       }
 
       for (auto clu : tcPertinentClusters) {
         double seedMipt = clustersTmp.at(clu).seedMipPt();
         clustersTmp.at(clu).addConstituent(*tc, true, seedMipt / totMipt);
       }
     }
   }
 
   /* store clusters in the persistent collection */
   clusters.resize(0, clustersTmp.size());
   for (unsigned i(0); i < clustersTmp.size(); ++i) {
     this->removeUnconnectedTCinCluster(clustersTmp.at(i), triggerGeometry);
     calibratePt(clustersTmp.at(i));
     clusters.set(0, i, clustersTmp.at(i));
   }
 }

void HGCalClusteringImpl::clusterizeNN	(	const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &	triggerCellsPtrs,
		l1t::HGCalClusterBxCollection &	clusters,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

Definition at line 232 of file HGCalClusteringImpl.cc.

References ForwardEmpty, kNSides_, LayerTriplets::layers(), HGCalTriggerTools::layers(), NNKernel(), triggerCellReshuffling(), and triggerTools_.

                                                                                         {
   std::array<std::vector<std::vector<edm::Ptr<l1t::HGCalTriggerCell>>>, kNSides_> reshuffledTriggerCells;
   unsigned layers = triggerTools_.layers(ForwardSubdetector::ForwardEmpty);
   for (unsigned side = 0; side < kNSides_; side++) {
     reshuffledTriggerCells[side].resize(layers);
   }
   triggerCellReshuffling(triggerCellsPtrs, reshuffledTriggerCells);
 
   for (unsigned iec = 0; iec < kNSides_; ++iec) {
     for (unsigned il = 0; il < layers; ++il) {
       NNKernel(reshuffledTriggerCells[iec][il], clusters, triggerGeometry);
     }
   }
 }

bool HGCalClusteringImpl::isPertinent	(	const l1t::HGCalTriggerCell &	tc,
		const l1t::HGCalCluster &	clu,
		double	distXY
	)		const

Definition at line 27 of file HGCalClusteringImpl.cc.

References l1t::HGCalTriggerCell::detId(), l1t::HGCalClusterT< C >::detId(), l1t::HGCalClusterT< C >::distance(), HGCalTriggerTools::layer(), triggerTools_, and HGCalTriggerTools::zside().

Referenced by clusterizeDR(), and clusterizeDRNN().

                                                            {
   DetId tcDetId(tc.detId());
   DetId cluDetId(clu.detId());
   if ((triggerTools_.layer(tcDetId) != triggerTools_.layer(cluDetId)) || (tcDetId.subdetId() != cluDetId.subdetId()) ||
       (triggerTools_.zside(tcDetId) != triggerTools_.zside(cluDetId))) {
     return false;
   }
   if (clu.distance((tc)) < distXY) {
     return true;
   }
   return false;
 }

void HGCalClusteringImpl::mergeClusters	(	l1t::HGCalCluster &	main_cluster,
		const l1t::HGCalCluster &	secondary_cluster
	)		const

Definition at line 117 of file HGCalClusteringImpl.cc.

References l1t::HGCalClusterT< C >::addConstituent(), and l1t::HGCalClusterT< C >::constituents().

Referenced by NNKernel().

                                                                                         {
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& pertinentTC = secondary_cluster.constituents();
 
   for (const auto& id_tc : pertinentTC) {
     main_cluster.addConstituent(id_tc.second);
   }
 }

void HGCalClusteringImpl::NNKernel	(	const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &	reshuffledTriggerCells,
		l1t::HGCalClusterBxCollection &	clusters,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

Definition at line 126 of file HGCalClusteringImpl.cc.

References calibratePt(), Exception, HGCalTriggerGeometryBase::getNeighborsFromTriggerCell(), HGCHEB, mergeClusters(), BXVector< T >::push_back(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, siliconSeedThreshold_, siliconTriggerCellThreshold_, and dtDQMClient_cfg::threshold.

Referenced by clusterizeNN().

                                                                                     {
   /* declaring the clusters vector */
   std::vector<l1t::HGCalCluster> clustersTmp;
 
   // map TC id -> cluster index in clustersTmp
   std::unordered_map<uint32_t, unsigned> cluNNmap;
 
   /* loop over the trigger-cells */
   for (const auto& tc_ptr : reshuffledTriggerCells) {
     double threshold =
         (tc_ptr->subdetId() == HGCHEB ? scintillatorTriggerCellThreshold_ : siliconTriggerCellThreshold_);
     if (tc_ptr->mipPt() < threshold) {
       continue;
     }
 
     // Check if the neighbors of that TC are already included in a cluster
     // If this is the case, add the TC to the first (arbitrary) neighbor cluster
     // Otherwise create a new cluster
     bool createNewC2d(true);
     const auto neighbors = triggerGeometry.getNeighborsFromTriggerCell(tc_ptr->detId());
     for (const auto neighbor : neighbors) {
       auto tc_cluster_itr = cluNNmap.find(neighbor);
       if (tc_cluster_itr != cluNNmap.end()) {
         createNewC2d = false;
         if (tc_cluster_itr->second < clustersTmp.size()) {
           clustersTmp.at(tc_cluster_itr->second).addConstituent(tc_ptr);
           // map TC id to the existing cluster
           cluNNmap.emplace(tc_ptr->detId(), tc_cluster_itr->second);
         } else {
           throw cms::Exception("HGCTriggerUnexpected")
               << "Trying to access a non-existing cluster. But it should exist...\n";
         }
         break;
       }
     }
     if (createNewC2d) {
       clustersTmp.emplace_back(tc_ptr);
       clustersTmp.back().setValid(true);
       // map TC id to the cluster index (size - 1)
       cluNNmap.emplace(tc_ptr->detId(), clustersTmp.size() - 1);
     }
   }
 
   /* declaring the vector with possible clusters merged */
   // Merge neighbor clusters together
   for (auto& cluster1 : clustersTmp) {
     // If the cluster has been merged into another one, skip it
     if (!cluster1.valid())
       continue;
     // Fill a set containing all TC included in the clusters
     // as well as all neighbor TC
     std::unordered_set<uint32_t> cluTcSet;
     for (const auto& tc_clu1 : cluster1.constituents()) {
       cluTcSet.insert(tc_clu1.second->detId());
       const auto neighbors = triggerGeometry.getNeighborsFromTriggerCell(tc_clu1.second->detId());
       for (const auto neighbor : neighbors) {
         cluTcSet.insert(neighbor);
       }
     }
 
     for (auto& cluster2 : clustersTmp) {
       // If the cluster has been merged into another one, skip it
       if (cluster1.detId() == cluster2.detId())
         continue;
       if (!cluster2.valid())
         continue;
       // Check if the TC in clu2 are in clu1 or its neighbors
       // If yes, merge the second cluster into the first one
       for (const auto& tc_clu2 : cluster2.constituents()) {
         if (cluTcSet.find(tc_clu2.second->detId()) != cluTcSet.end()) {
           mergeClusters(cluster1, cluster2);
           cluTcSet.insert(tc_clu2.second->detId());
           const auto neighbors = triggerGeometry.getNeighborsFromTriggerCell(tc_clu2.second->detId());
           for (const auto neighbor : neighbors) {
             cluTcSet.insert(neighbor);
           }
           cluster2.setValid(false);
           break;
         }
       }
     }
   }
 
   /* store clusters in the persistent collection */
   // only if the cluster contain a TC above the seed threshold
   for (auto& cluster : clustersTmp) {
     if (!cluster.valid())
       continue;
     bool saveInCollection(false);
     for (const auto& id_tc : cluster.constituents()) {
       /* threshold in transverse-mip */
       double seedThreshold = (id_tc.second->subdetId() == HGCHEB ? scintillatorSeedThreshold_ : siliconSeedThreshold_);
       if (id_tc.second->mipPt() > seedThreshold) {
         saveInCollection = true;
         break;
       }
     }
     if (saveInCollection) {
       calibratePt(cluster);
       clusters.push_back(0, cluster);
     }
   }
 }

void HGCalClusteringImpl::removeUnconnectedTCinCluster	(	l1t::HGCalCluster &	cluster,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

private

Definition at line 353 of file HGCalClusteringImpl.cc.

References areTCneighbour(), l1t::HGCalClusterT< C >::constituents(), l1t::HGCalClusterT< C >::detId(), HLT_FULL_cff::distance, distanceSorter(), mps_fire::i, mag(), position, and l1t::HGCalClusterT< C >::removeConstituent().

Referenced by clusterizeDRNN().

                                                                                                         {
   /* get the constituents and the centre of the seed tc (considered as the first of the constituents) */
   const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalTriggerCell>>& constituents = cluster.constituents();
   Basic3DVector<float> seedCentre(constituents.at(cluster.detId())->position());
 
   /* distances from the seed */
   vector<pair<edm::Ptr<l1t::HGCalTriggerCell>, float>> distances;
   for (const auto& id_tc : constituents) {
     Basic3DVector<float> tcCentre(id_tc.second->position());
     float distance = (seedCentre - tcCentre).mag();
     distances.push_back(pair<edm::Ptr<l1t::HGCalTriggerCell>, float>(id_tc.second, distance));
   }
 
   /* sorting (needed in order to be sure that we are skipping any tc) */
   /* FIXME: better sorting needed!!! */
   std::sort(distances.begin(), distances.end(), distanceSorter);
 
   /* checking if the tc is connected to the seed */
   bool toRemove[constituents.size()];
   toRemove[0] = false;  // this is the seed
   for (unsigned itc = 1; itc < distances.size(); itc++) {
     /* get the tc under study */
     toRemove[itc] = true;
     const edm::Ptr<l1t::HGCalTriggerCell>& tcToStudy = distances[itc].first;
 
     /* compare with the tc in the cluster */
     for (unsigned itc_ref = 0; itc_ref < itc; itc_ref++) {
       if (!toRemove[itc_ref]) {
         if (areTCneighbour(tcToStudy->detId(), distances.at(itc_ref).first->detId(), triggerGeometry)) {
           toRemove[itc] = false;
           break;
         }
       }
     }
   }
 
   /* remove the unconnected TCs */
   for (unsigned i = 0; i < distances.size(); i++) {
     if (toRemove[i])
       cluster.removeConstituent(distances.at(i).first);
   }
 }

void HGCalClusteringImpl::setGeometry ( const HGCalTriggerGeometryBase *const geom )

inline

Definition at line 25 of file HGCalClusteringImpl.h.

References HGCalTriggerTools::setGeometry(), and triggerTools_.

25 { triggerTools_.setGeometry(geom); }

HGCalTriggerTools::setGeometry

void setGeometry(const HGCalTriggerGeometryBase *const)

Definition: HGCalTriggerTools.cc:40

HGCalClusteringImpl::triggerTools_

HGCalTriggerTools triggerTools_

Definition: HGCalClusteringImpl.h:59

void HGCalClusteringImpl::triggerCellReshuffling	(	const std::vector< edm::Ptr< l1t::HGCalTriggerCell >> &	triggerCellsPtrs,
		std::array< std::vector< std::vector< edm::Ptr< l1t::HGCalTriggerCell >>>, kNSides_ > &	reshuffledTriggerCells
	)

private

Definition at line 104 of file HGCalClusteringImpl.cc.

References Reference_intrackfit_cff::endcap, phase1PixelTopology::layer, HGCalTriggerTools::layerWithOffset(), triggerTools_, and HGCalTriggerTools::zside().

Referenced by clusterizeNN().

                                                                                                    {
   for (const auto& tc : triggerCellsPtrs) {
     DetId tcDetId(tc->detId());
     int endcap = triggerTools_.zside(tcDetId) == -1 ? 0 : 1;
     unsigned layer = triggerTools_.layerWithOffset(tc->detId());
 
     reshuffledTriggerCells[endcap][layer - 1].emplace_back(tc);
   }
 }