#include <HGCalMulticlusteringImpl.h>

Public Member Functions
void	clusterizeDBSCAN (const std::vector< edm::Ptr< l1t::HGCalCluster >> &clustersPtr, l1t::HGCalMulticlusterBxCollection &multiclusters, const HGCalTriggerGeometryBase &triggerGeometry)

void	clusterizeDR (const std::vector< edm::Ptr< l1t::HGCalCluster >> &clustersPtr, l1t::HGCalMulticlusterBxCollection &multiclusters, const HGCalTriggerGeometryBase &triggerGeometry)

void	eventSetup (const edm::EventSetup &es)

	HGCalMulticlusteringImpl (const edm::ParameterSet &conf)

bool	isPertinent (const l1t::HGCalCluster &clu, const l1t::HGCalMulticluster &mclu, double dR) const

Private Member Functions
void	finalizeClusters (std::vector< l1t::HGCalMulticluster > &, l1t::HGCalMulticlusterBxCollection &, const HGCalTriggerGeometryBase &)

void	findNeighbor (const std::vector< std::pair< unsigned int, double >> &rankedList, unsigned int searchInd, const std::vector< edm::Ptr< l1t::HGCalCluster >> &clustersPtr, std::vector< unsigned int > &neigbors)

Private Attributes
double	distDbscan_ = 0.005

double	dr_

std::unique_ptr< HGCalTriggerClusterIdentificationBase >	id_

unsigned	minNDbscan_ = 3

std::string	multiclusterAlgoType_

double	ptC3dThreshold_

HGCalShowerShape	shape_

HGCalTriggerTools	triggerTools_

Detailed Description

Definition at line 15 of file HGCalMulticlusteringImpl.h.

Constructor & Destructor Documentation

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

Definition at line 8 of file HGCalMulticlusteringImpl.cc.

References beamerCreator::create(), distDbscan_, dr_, reco::get(), edm::ParameterSet::getParameter(), id_, minNDbscan_, multiclusterAlgoType_, and ptC3dThreshold_.

                                                                                 :
     dr_(conf.getParameter<double>("dR_multicluster")),
     ptC3dThreshold_(conf.getParameter<double>("minPt_multicluster")),
     multiclusterAlgoType_(conf.getParameter<string>("type_multicluster")),
     distDbscan_(conf.getParameter<double>("dist_dbscan_multicluster")),
     minNDbscan_(conf.getParameter<unsigned>("minN_dbscan_multicluster"))
 {    
     edm::LogInfo("HGCalMulticlusterParameters") << "Multicluster dR for Near Neighbour search: " << dr_;  
     edm::LogInfo("HGCalMulticlusterParameters") << "Multicluster minimum transverse-momentum: " << ptC3dThreshold_;
     edm::LogInfo("HGCalMulticlusterParameters") << "Multicluster DBSCAN Clustering distance: " << distDbscan_;
     edm::LogInfo("HGCalMulticlusterParameters") << "Multicluster clustering min number of subclusters: " << minNDbscan_;
     edm::LogInfo("HGCalMulticlusterParameters") << "Multicluster type of multiclustering algortihm: " << multiclusterAlgoType_;
     id_.reset( HGCalTriggerClusterIdentificationFactory::get()->create("HGCalTriggerClusterIdentificationBDT") );
     id_->initialize(conf.getParameter<edm::ParameterSet>("EGIdentification")); 
 }

Member Function Documentation

void HGCalMulticlusteringImpl::clusterizeDBSCAN	(	const std::vector< edm::Ptr< l1t::HGCalCluster >> &	clustersPtr,
		l1t::HGCalMulticlusterBxCollection &	multiclusters,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

Definition at line 116 of file HGCalMulticlusteringImpl.cc.

References finalizeClusters(), findNeighbor(), minNDbscan_, eostools::move(), class-composition::visited, and ecaldqm::zside().

Referenced by eventSetup().

 {
 
     std::vector<l1t::HGCalMulticluster> multiclustersTmp;
     l1t::HGCalMulticluster mcluTmp;
     std::vector<bool> visited(clustersPtrs.size(),false);
     std::vector<bool> merged (clustersPtrs.size(),false);
     std::vector<std::pair<unsigned int,double>>  rankedList;
     rankedList.reserve(clustersPtrs.size());
     std::vector<std::vector<unsigned int>> neighborList;
     neighborList.reserve(clustersPtrs.size());
 
     int iclu = 0, imclu = 0, neighNo;
     double dist = 0.;
 
     for(std::vector<edm::Ptr<l1t::HGCalCluster>>::const_iterator clu = clustersPtrs.begin(); clu != clustersPtrs.end(); ++clu, ++iclu){
         dist = (*clu)->centreProj().mag()*HGCalDetId((*clu)->detId()).zside();
         rankedList.push_back(std::make_pair(iclu,dist));
     }  
     iclu = 0;
     std::sort(rankedList.begin(), rankedList.end(), [](auto &left, auto &right) {
             return left.second < right.second;
             });
 
     for(const auto& cluRanked: rankedList){
         std::vector<unsigned int> neighbors;      
 
         if(!visited.at(iclu)){
             visited.at(iclu) = true;
             findNeighbor(rankedList, iclu, clustersPtrs, neighbors);
             neighborList.push_back(std::move(neighbors));
 
             if(neighborList.at(iclu).size() >= minNDbscan_) {
                 multiclustersTmp.emplace_back( clustersPtrs[cluRanked.first] );
                 merged.at(iclu) = true;
                 /* dynamic range loop: range-based loop syntax cannot be employed */
                 for(unsigned int neighInd = 0; neighInd < neighborList.at(iclu).size(); neighInd++){
                     neighNo = neighborList.at(iclu).at(neighInd);
                     /* This condition also ensures merging of clusters visited by other clusters but not merged. */
                     if(!merged.at(neighNo) ){
                         merged.at(neighNo) = true;          
                         multiclustersTmp.at(imclu).addConstituent( clustersPtrs[rankedList.at(neighNo).first] );
 
                         if(!visited.at(neighNo)){
                             visited.at(neighNo) = true;
                             std::vector<unsigned int> secNeighbors;
                             findNeighbor(rankedList, neighNo,clustersPtrs, secNeighbors);
 
                             if(secNeighbors.size() >= minNDbscan_){
                                 neighborList.at(iclu).insert(neighborList.at(iclu).end(), secNeighbors.begin(), secNeighbors.end());
                             }
                         }
                     }
                 }
                 imclu++;
             }
         }
         else neighborList.push_back(std::move(neighbors));
         iclu++;    
     }
     /* making the collection of multiclusters */
     finalizeClusters(multiclustersTmp, multiclusters, triggerGeometry);
 }

void HGCalMulticlusteringImpl::clusterizeDR	(	const std::vector< edm::Ptr< l1t::HGCalCluster >> &	clustersPtr,
		l1t::HGCalMulticlusterBxCollection &	multiclusters,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

Definition at line 75 of file HGCalMulticlusteringImpl.cc.

References edmIntegrityCheck::d, dr_, finalizeClusters(), isPertinent(), and mag().

Referenced by eventSetup().

 {
 
     std::vector<l1t::HGCalMulticluster> multiclustersTmp;
 
     int iclu = 0;
     for(std::vector<edm::Ptr<l1t::HGCalCluster>>::const_iterator clu = clustersPtrs.begin(); clu != clustersPtrs.end(); ++clu, ++iclu){
         
         int imclu=0;
         vector<int> tcPertinentMulticlusters;
         for( const auto& mclu : multiclustersTmp ){
             if( this->isPertinent(**clu, mclu, dr_) ){
                 tcPertinentMulticlusters.push_back(imclu);
             }
             ++imclu;
         }
         if( tcPertinentMulticlusters.empty() ){
             multiclustersTmp.emplace_back( *clu );
         }
         else{
             unsigned minDist = 1;
             unsigned targetMulticlu = 0; 
             for( int imclu : tcPertinentMulticlusters ){
                 double d = ( multiclustersTmp.at(imclu).centreProj() - (*clu)->centreProj() ).mag() ;
                 if( d < minDist ){
                     minDist = d;
                     targetMulticlu = imclu;
                 }
             } 
 
             multiclustersTmp.at( targetMulticlu ).addConstituent( *clu );
             
         }        
     }
 
     /* making the collection of multiclusters */
     finalizeClusters(multiclustersTmp, multiclusters, triggerGeometry);
     
 }

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

inline

Definition at line 21 of file HGCalMulticlusteringImpl.h.

References clusterizeDBSCAN(), clusterizeDR(), PATTauDiscriminationAgainstElectronDeadECAL_cfi::dR, HGCalShowerShape::eventSetup(), HGCalTriggerTools::eventSetup(), finalizeClusters(), findNeighbor(), isPertinent(), shape_, and triggerTools_.

     {
         triggerTools_.eventSetup(es);
         shape_.eventSetup(es);
     }

void HGCalMulticlusteringImpl::finalizeClusters	(	std::vector< l1t::HGCalMulticluster > &	multiclusters_in,
		l1t::HGCalMulticlusterBxCollection &	multiclusters_out,
		const HGCalTriggerGeometryBase &	triggerGeometry
	)

private

Definition at line 185 of file HGCalMulticlusteringImpl.cc.

Referenced by clusterizeDBSCAN(), clusterizeDR(), and eventSetup().

                                                              {
     for(auto& multicluster : multiclusters_in) {
         // compute the eta, phi from its barycenter
         // + pT as scalar sum of pT of constituents
         double sumPt=0.;
         const std::unordered_map<uint32_t, edm::Ptr<l1t::HGCalCluster>>& clusters = multicluster.constituents();
         for(const auto& id_cluster : clusters) sumPt += id_cluster.second->pt();
 
         math::PtEtaPhiMLorentzVector multiclusterP4(  sumPt,
                 multicluster.centre().eta(),
                 multicluster.centre().phi(),
                 0. );
         multicluster.setP4( multiclusterP4 );
 
         if( multicluster.pt() > ptC3dThreshold_ ){
             //compute shower shapes
             multicluster.showerLength(shape_.showerLength(multicluster));
             multicluster.coreShowerLength(shape_.coreShowerLength(multicluster, triggerGeometry));
             multicluster.firstLayer(shape_.firstLayer(multicluster));
             multicluster.maxLayer(shape_.maxLayer(multicluster));
             multicluster.sigmaEtaEtaTot(shape_.sigmaEtaEtaTot(multicluster));
             multicluster.sigmaEtaEtaMax(shape_.sigmaEtaEtaMax(multicluster));
             multicluster.sigmaPhiPhiTot(shape_.sigmaPhiPhiTot(multicluster));
             multicluster.sigmaPhiPhiMax(shape_.sigmaPhiPhiMax(multicluster));
             multicluster.sigmaZZ(shape_.sigmaZZ(multicluster));
             multicluster.sigmaRRTot(shape_.sigmaRRTot(multicluster));
             multicluster.sigmaRRMax(shape_.sigmaRRMax(multicluster));
             multicluster.sigmaRRMean(shape_.sigmaRRMean(multicluster));
             multicluster.eMax(shape_.eMax(multicluster));
             // fill quality flag
             multicluster.setHwQual(id_->decision(multicluster));
 
             multiclusters_out.push_back( 0, multicluster);
         }
     }
 }

void HGCalMulticlusteringImpl::findNeighbor	(	const std::vector< std::pair< unsigned int, double >> &	rankedList,
		unsigned int	searchInd,
		const std::vector< edm::Ptr< l1t::HGCalCluster >> &	clustersPtr,
		std::vector< unsigned int > &	neigbors
	)

private

Definition at line 43 of file HGCalMulticlusteringImpl.cc.

References distDbscan_, Exception, and mag().

Referenced by clusterizeDBSCAN(), and eventSetup().

                                              {
 
     if(clustersPtrs.size() <= searchInd || clustersPtrs.size() < rankedList.size()){
         throw cms::Exception("IndexOutOfBound: clustersPtrs in 'findNeighbor'");
     }
 
     for(unsigned int ind = searchInd+1; ind < rankedList.size() && fabs(rankedList.at(ind).second - rankedList.at(searchInd).second) < distDbscan_ ; ind++){
 
         if(clustersPtrs.size() <= rankedList.at(ind).first){
             throw cms::Exception("IndexOutOfBound: clustersPtrs in 'findNeighbor'");
 
         } else if(((*(clustersPtrs[rankedList.at(ind).first])).centreProj() - (*(clustersPtrs[rankedList.at(searchInd).first])).centreProj()).mag() < distDbscan_){
             neighbors.push_back(ind);
         }
     }
 
     for(unsigned int ind = 0; ind < searchInd && fabs(rankedList.at(searchInd).second - rankedList.at(ind).second) < distDbscan_ ; ind++){
 
         if(clustersPtrs.size() <= rankedList.at(ind).first){
             throw cms::Exception("IndexOutOfBound: clustersPtrs in 'findNeighbor'");
 
         } else if(((*(clustersPtrs[rankedList.at(ind).first])).centreProj() - (*(clustersPtrs[rankedList.at(searchInd).first])).centreProj()).mag() < distDbscan_){
             neighbors.push_back(ind);
         }
     }
 }

bool HGCalMulticlusteringImpl::isPertinent	(	const l1t::HGCalCluster &	clu,
		const l1t::HGCalMulticluster &	mclu,
		double	dR
	)		const

Definition at line 25 of file HGCalMulticlusteringImpl.cc.

References l1t::HGCalClusterT< C >::centreProj(), l1t::HGCalClusterT< C >::detId(), PATTauDiscriminationAgainstElectronDeadECAL_cfi::dR, and mag().

Referenced by clusterizeDR(), and eventSetup().

 {
     HGCalDetId cluDetId( clu.detId() );
     HGCalDetId firstClusterDetId( mclu.detId() );
     
     if( cluDetId.zside() != firstClusterDetId.zside() ){
         return false;
     }
     if( ( mclu.centreProj() - clu.centreProj() ).mag() < dR ){
         return true;
     }
     return false;
 
 }