#include <HGCalHistoClusteringImpl.h>

Public Member Functions
void	clusterizeHisto (const std::vector< edm::Ptr< l1t::HGCalCluster >> &clustersPtr, const std::vector< std::pair< GlobalPoint, double >> &seedPositionsEnergy, const HGCalTriggerGeometryBase &triggerGeometry, l1t::HGCalMulticlusterBxCollection &multiclusters, l1t::HGCalClusterBxCollection &rejected_clusters) const

float	dR (const l1t::HGCalCluster &clu, const GlobalPoint &seed) const

void	eventSetup (const edm::EventSetup &es)

	HGCalHistoClusteringImpl (const edm::ParameterSet &conf)

Private Types
enum	ClusterAssociationStrategy { NearestNeighbour, EnergySplit }

Private Member Functions
std::vector< l1t::HGCalMulticluster >	clusterSeedMulticluster (const std::vector< edm::Ptr< l1t::HGCalCluster >> &clustersPtrs, const std::vector< std::pair< GlobalPoint, double >> &seeds, std::vector< l1t::HGCalCluster > &rejected_clusters) const

void	finalizeClusters (std::vector< l1t::HGCalMulticluster > &, const std::vector< l1t::HGCalCluster > &, l1t::HGCalMulticlusterBxCollection &, l1t::HGCalClusterBxCollection &, const HGCalTriggerGeometryBase &) const

Private Attributes
std::string	cluster_association_input_

ClusterAssociationStrategy	cluster_association_strategy_

double	dr_

std::vector< double >	dr_byLayer_coefficientA_

std::vector< double >	dr_byLayer_coefficientB_

std::unique_ptr< HGCalTriggerClusterIdentificationBase >	id_

double	ptC3dThreshold_

HGCalShowerShape	shape_

HGCalTriggerTools	triggerTools_

Static Private Attributes
static constexpr double	kMidRadius_ = 2.3

Detailed Description

Definition at line 14 of file HGCalHistoClusteringImpl.h.

Member Enumeration Documentation

◆ ClusterAssociationStrategy

enum HGCalHistoClusteringImpl::ClusterAssociationStrategy

private

Enumerator
NearestNeighbour
EnergySplit

Definition at line 39 of file HGCalHistoClusteringImpl.h.

39 { NearestNeighbour, EnergySplit };

Constructor & Destructor Documentation

◆ HGCalHistoClusteringImpl()

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

Definition at line 6 of file HGCalHistoClusteringImpl.cc.

     : dr_(conf.getParameter<double>("dR_multicluster")),
       dr_byLayer_coefficientA_(conf.existsAs<std::vector<double>>("dR_multicluster_byLayer_coefficientA")
                                    ? conf.getParameter<std::vector<double>>("dR_multicluster_byLayer_coefficientA")
                                    : std::vector<double>()),
       dr_byLayer_coefficientB_(conf.existsAs<std::vector<double>>("dR_multicluster_byLayer_coefficientB")
                                    ? conf.getParameter<std::vector<double>>("dR_multicluster_byLayer_coefficientB")
                                    : std::vector<double>()),
       ptC3dThreshold_(conf.getParameter<double>("minPt_multicluster")),
       cluster_association_input_(conf.getParameter<string>("cluster_association")),
       shape_(conf) {
   if (cluster_association_input_ == "NearestNeighbour") {
     cluster_association_strategy_ = NearestNeighbour;
   } else if (cluster_association_input_ == "EnergySplit") {
     cluster_association_strategy_ = EnergySplit;
   } else {
     throw cms::Exception("HGCTriggerParameterError")
         << "Unknown cluster association strategy'" << cluster_association_strategy_;
   }
  
   edm::LogInfo("HGCalMulticlusterParameters")
       << "Multicluster dR: " << dr_ << "\nMulticluster minimum transverse-momentum: " << ptC3dThreshold_;
  
   id_ = std::unique_ptr<HGCalTriggerClusterIdentificationBase>{
       HGCalTriggerClusterIdentificationFactory::get()->create("HGCalTriggerClusterIdentificationBDT")};
   id_->initialize(conf.getParameter<edm::ParameterSet>("EGIdentification"));
 }

References cluster_association_input_, cluster_association_strategy_, dr_, EnergySplit, Exception, get, edm::ParameterSet::getParameter(), id_, NearestNeighbour, and ptC3dThreshold_.

Member Function Documentation

◆ clusterizeHisto()

void HGCalHistoClusteringImpl::clusterizeHisto	(	const std::vector< edm::Ptr< l1t::HGCalCluster >> &	clustersPtr,
		const std::vector< std::pair< GlobalPoint, double >> &	seedPositionsEnergy,
		const HGCalTriggerGeometryBase &	triggerGeometry,
		l1t::HGCalMulticlusterBxCollection &	multiclusters,
		l1t::HGCalClusterBxCollection &	rejected_clusters
	)		const

Definition at line 110 of file HGCalHistoClusteringImpl.cc.

                                                                                                      {
   /* clusterize clusters around seeds */
   std::vector<l1t::HGCalCluster> rejected_clusters_vec;
   std::vector<l1t::HGCalMulticluster> multiclusters_vec =
       clusterSeedMulticluster(clustersPtrs, seedPositionsEnergy, rejected_clusters_vec);
   /* making the collection of multiclusters */
   finalizeClusters(multiclusters_vec, rejected_clusters_vec, multiclusters, rejected_clusters, triggerGeometry);
 }

References clusterSeedMulticluster(), and finalizeClusters().

◆ clusterSeedMulticluster()

std::vector< l1t::HGCalMulticluster > HGCalHistoClusteringImpl::clusterSeedMulticluster	(	const std::vector< edm::Ptr< l1t::HGCalCluster >> &	clustersPtrs,
		const std::vector< std::pair< GlobalPoint, double >> &	seeds,
		std::vector< l1t::HGCalCluster > &	rejected_clusters
	)		const

private

Definition at line 38 of file HGCalHistoClusteringImpl.cc.

                                                          {
   std::map<int, l1t::HGCalMulticluster> mapSeedMulticluster;
   std::vector<l1t::HGCalMulticluster> multiclustersOut;
  
   for (const auto& clu : clustersPtrs) {
     int z_side = triggerTools_.zside(clu->detId());
  
     double radiusCoefficientA =
         dr_byLayer_coefficientA_.empty() ? dr_ : dr_byLayer_coefficientA_[triggerTools_.layerWithOffset(clu->detId())];
     double radiusCoefficientB =
         dr_byLayer_coefficientB_.empty() ? 0 : dr_byLayer_coefficientB_[triggerTools_.layerWithOffset(clu->detId())];
  
     double minDist = radiusCoefficientA + radiusCoefficientB * (kMidRadius_ - std::abs(clu->eta()));
  
     std::vector<pair<int, double>> targetSeedsEnergy;
  
     for (unsigned int iseed = 0; iseed < seeds.size(); iseed++) {
       GlobalPoint seedPosition = seeds[iseed].first;
       double seedEnergy = seeds[iseed].second;
  
       if (z_side * seedPosition.z() < 0)
         continue;
       double d = this->dR(*clu, seeds[iseed].first);
  
       if (d < minDist) {
         if (cluster_association_strategy_ == EnergySplit) {
           targetSeedsEnergy.emplace_back(iseed, seedEnergy);
         } else if (cluster_association_strategy_ == NearestNeighbour) {
           minDist = d;
  
           if (targetSeedsEnergy.empty()) {
             targetSeedsEnergy.emplace_back(iseed, seedEnergy);
           } else {
             targetSeedsEnergy.at(0).first = iseed;
             targetSeedsEnergy.at(0).second = seedEnergy;
           }
         }
       }
     }
  
     if (targetSeedsEnergy.empty()) {
       rejected_clusters.emplace_back(*clu);
       continue;
     }
     //Loop over target seeds and divide up the clusters energy
     double totalTargetSeedEnergy = 0;
     for (const auto& energy : targetSeedsEnergy) {
       totalTargetSeedEnergy += energy.second;
     }
  
     for (const auto& energy : targetSeedsEnergy) {
       double seedWeight = 1;
       if (cluster_association_strategy_ == EnergySplit)
         seedWeight = energy.second / totalTargetSeedEnergy;
       if (mapSeedMulticluster[energy.first].size() == 0) {
         mapSeedMulticluster[energy.first] = l1t::HGCalMulticluster(clu, seedWeight);
       } else {
         mapSeedMulticluster[energy.first].addConstituent(clu, true, seedWeight);
       }
     }
   }
  
   multiclustersOut.reserve(mapSeedMulticluster.size());
   for (const auto& mclu : mapSeedMulticluster)
     multiclustersOut.emplace_back(mclu.second);
  
   return multiclustersOut;
 }

References funct::abs(), cluster_association_strategy_, ztail::d, dR(), dr_, dr_byLayer_coefficientA_, dr_byLayer_coefficientB_, HCALHighEnergyHPDFilter_cfi::energy, EnergySplit, first, iseed, kMidRadius_, HGCalTriggerTools::layerWithOffset(), NearestNeighbour, DetachedQuadStep_cff::seeds, triggerTools_, PV3DBase< T, PVType, FrameType >::z(), and HGCalTriggerTools::zside().

Referenced by clusterizeHisto().

◆ dR()

float HGCalHistoClusteringImpl::dR	(	const l1t::HGCalCluster &	clu,
		const GlobalPoint &	seed
	)		const

Definition at line 34 of file HGCalHistoClusteringImpl.cc.

                                                                                             {
   return (seed - clu.centreProj()).mag();
 }

References l1t::HGCalClusterT< C >::centreProj(), mag(), and fileCollector::seed.

Referenced by clusterSeedMulticluster().

◆ eventSetup()

void HGCalHistoClusteringImpl::eventSetup ( const edm::EventSetup & es )

inline

Definition at line 18 of file HGCalHistoClusteringImpl.h.

                                            {
     triggerTools_.eventSetup(es);
     shape_.eventSetup(es);
     if ((!dr_byLayer_coefficientA_.empty() && (dr_byLayer_coefficientA_.size() - 1) < triggerTools_.lastLayerBH()) ||
         (!dr_byLayer_coefficientB_.empty() && (dr_byLayer_coefficientB_.size() - 1) < triggerTools_.lastLayerBH())) {
       throw cms::Exception("Configuration")
           << "The per-layer dR values go up to " << (dr_byLayer_coefficientA_.size() - 1) << "(A) and "
           << (dr_byLayer_coefficientB_.size() - 1) << "(B), while layers go up to " << triggerTools_.lastLayerBH()
           << "\n";
     }
   }

References dr_byLayer_coefficientA_, dr_byLayer_coefficientB_, HGCalShowerShape::eventSetup(), HGCalTriggerTools::eventSetup(), Exception, HGCalTriggerTools::lastLayerBH(), shape_, and triggerTools_.

◆ finalizeClusters()

void HGCalHistoClusteringImpl::finalizeClusters	(	std::vector< l1t::HGCalMulticluster > &	multiclusters_in,
		const std::vector< l1t::HGCalCluster > &	rejected_clusters_in,
		l1t::HGCalMulticlusterBxCollection &	multiclusters_out,
		l1t::HGCalClusterBxCollection &	rejected_clusters_out,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)		const

private

Definition at line 123 of file HGCalHistoClusteringImpl.cc.

                                                                                                        {
   for (const auto& tc : rejected_clusters_in) {
     rejected_clusters_out.push_back(0, tc);
   }
  
   for (auto& multicluster : multiclusters_in) {
     // compute the eta, phi from its barycenter
     // + pT as scalar sum of pT of constituents
     double sumPt = multicluster.sumPt();
  
     math::PtEtaPhiMLorentzVector multiclusterP4(sumPt, multicluster.centre().eta(), multicluster.centre().phi(), 0.);
     multicluster.setP4(multiclusterP4);
  
     if (multicluster.pt() > ptC3dThreshold_) {
       //compute shower shapes
       shape_.fillShapes(multicluster, triggerGeometry);
       // fill quality flag
       multicluster.setHwQual(id_->decision(multicluster));
       // fill H/E
       multicluster.saveHOverE();
  
       multiclusters_out.push_back(0, multicluster);
     } else {
       for (const auto& tc : multicluster.constituents()) {
         rejected_clusters_out.push_back(0, *(tc.second));
       }
     }
   }
 }