HGCalClusteringImpl Class Reference

#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::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

areTCneighbour()

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;
}

calibratePt()

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);
}

clusterizeDR()

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

Definition at line 42 of file HGCalClusteringImpl.cc.

References calibratePt(), bsc_activity_cfg::clusters, ztail::d, dr_, HGCHEB, mps_fire::i, createfilelist::int, isPertinent(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, siliconSeedThreshold_, siliconTriggerCellThreshold_, remoteMonitoring_LASER_era2018_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));
  }
}

clusterizeDRNN()

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(), bsc_activity_cfg::clusters, dr_, HGCHEB, mps_fire::i, isPertinent(), mag(), removeUnconnectedTCinCluster(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, siliconSeedThreshold_, siliconTriggerCellThreshold_, remoteMonitoring_LASER_era2018_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));
  }
}

clusterizeNN()

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 bsc_activity_cfg::clusters, ForwardEmpty, kNSides_, hgcalTBTopologyTester_cfi::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);
    }
  }
}

isPertinent()

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;
}

mergeClusters()

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);
  }
}

NNKernel()

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(), bsc_activity_cfg::clusters, Exception, HGCalTriggerGeometryBase::getNeighborsFromTriggerCell(), HGCHEB, mergeClusters(), scintillatorSeedThreshold_, scintillatorTriggerCellThreshold_, siliconSeedThreshold_, siliconTriggerCellThreshold_, and remoteMonitoring_LASER_era2018_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);
    }
  }
}

removeUnconnectedTCinCluster()

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::HGCalTriggerCell::detId(), l1t::HGCalClusterT< C >::detId(), HLT_2023v12_cff::distance, distanceSorter(), mps_fire::i, mag(), position, l1t::HGCalClusterT< C >::removeConstituent(), and jetUpdater_cfi::sort.

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);
  }
}

setGeometry()

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

inline

Definition at line 25 of file HGCalClusteringImpl.h.

References relativeConstraints::geom, HGCalTriggerTools::setGeometry(), and triggerTools_.

{ triggerTools_.setGeometry(geom); }

triggerCellReshuffling()

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 makeMuonMisalignmentScenario::endcap, pixelTopology::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);
  }
}

Member Data Documentation

applyLayerWeights_

bool HGCalClusteringImpl::applyLayerWeights_

private

Definition at line 58 of file HGCalClusteringImpl.h.

Referenced by calibratePt().

calibSF_

double HGCalClusteringImpl::calibSF_

private

Definition at line 56 of file HGCalClusteringImpl.h.

Referenced by calibratePt(), and HGCalClusteringImpl().

clusteringAlgorithmType_

std::string HGCalClusteringImpl::clusteringAlgorithmType_

private

Definition at line 55 of file HGCalClusteringImpl.h.

Referenced by HGCalClusteringImpl().

dr_

double HGCalClusteringImpl::dr_

private

Definition at line 54 of file HGCalClusteringImpl.h.

Referenced by clusterizeDR(), and clusterizeDRNN().

kNSides_

constexpr unsigned HGCalClusteringImpl::kNSides_ = 2

staticprivate

Definition at line 20 of file HGCalClusteringImpl.h.

Referenced by clusterizeNN().

layerWeights_

std::vector<double> HGCalClusteringImpl::layerWeights_

private

Definition at line 57 of file HGCalClusteringImpl.h.

Referenced by calibratePt().

scintillatorSeedThreshold_

double HGCalClusteringImpl::scintillatorSeedThreshold_

private

Definition at line 52 of file HGCalClusteringImpl.h.

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

scintillatorTriggerCellThreshold_

double HGCalClusteringImpl::scintillatorTriggerCellThreshold_

private

Definition at line 53 of file HGCalClusteringImpl.h.

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

siliconSeedThreshold_

double HGCalClusteringImpl::siliconSeedThreshold_

private

Definition at line 50 of file HGCalClusteringImpl.h.

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

siliconTriggerCellThreshold_

double HGCalClusteringImpl::siliconTriggerCellThreshold_

private

Definition at line 51 of file HGCalClusteringImpl.h.

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

triggerTools_

HGCalTriggerTools HGCalClusteringImpl::triggerTools_

private

Definition at line 59 of file HGCalClusteringImpl.h.

Referenced by calibratePt(), clusterizeNN(), isPertinent(), setGeometry(), and triggerCellReshuffling().