#include <KDTreeLinkerTrackHcal.h>

Inheritance diagram for KDTreeLinkerTrackHcal:

Public Member Functions
void	buildTree () override

void	clear () override

void	insertFieldClusterElt (reco::PFBlockElement *hcalCluster) override

void	insertTargetElt (reco::PFBlockElement *track) override

	KDTreeLinkerTrackHcal ()

void	searchLinks () override

void	updatePFBlockEltWithLinks () override

	~KDTreeLinkerTrackHcal () override

Public Member Functions inherited from KDTreeLinkerBase
const reco::PFBlockElement::Type &	fieldType () const

void	process ()

void	setDebug (bool isDebug)

void	setFieldType (const reco::PFBlockElement::Type &fld)

void	setTargetType (const reco::PFBlockElement::Type &tgt)

const reco::PFBlockElement::Type &	targetType () const

virtual	~KDTreeLinkerBase ()

Private Attributes
BlockElt2BlockEltMap	cluster2TargetLinks_

BlockEltSet	fieldClusterSet_

RecHit2BlockEltMap	rechit2ClusterLinks_

RecHitSet	rechitsSet_

BlockEltSet	targetSet_

KDTreeLinkerAlgo< reco::PFRecHit const * >	tree_

Additional Inherited Members
Protected Attributes inherited from KDTreeLinkerBase
reco::PFBlockElement::Type	_fieldType

reco::PFBlockElement::Type	_targetType

float	cristalPhiEtaMaxSize_ = 0.04

float	cristalXYMaxSize_ = 3.

bool	debug_ = false

float	phiOffset_ = 0.25

Detailed Description

Definition at line 12 of file KDTreeLinkerTrackHcal.h.

Constructor & Destructor Documentation

KDTreeLinkerTrackHcal::KDTreeLinkerTrackHcal ( )

Definition at line 13 of file KDTreeLinkerTrackHcal.cc.

References KDTreeLinkerBase::cristalPhiEtaMaxSize_, and KDTreeLinkerBase::phiOffset_.

   : KDTreeLinkerBase()
 {
   cristalPhiEtaMaxSize_ = 0.2;
   phiOffset_ = 0.32;
 }

KDTreeLinkerTrackHcal::~KDTreeLinkerTrackHcal ( )

override

Definition at line 20 of file KDTreeLinkerTrackHcal.cc.

References clear().

 {
   clear();
 }

Member Function Documentation

void KDTreeLinkerTrackHcal::buildTree ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 66 of file KDTreeLinkerTrackHcal.cc.

References KDTreeLinkerAlgo< DATA >::build(), RhoEtaPhi::eta(), M_PI, phi, RhoEtaPhi::phi(), phimax, phimin, KDTreeLinkerBase::phiOffset_, rechitsSet_, and tree_.

 {
   // List of pseudo-rechits that will be used to create the KDTree
   std::vector<KDTreeNodeInfo<reco::PFRecHit const*>> eltList;
 
   // Filling of this list
   for(RecHitSet::const_iterator it = rechitsSet_.begin(); 
       it != rechitsSet_.end(); it++) {
     
     const reco::PFRecHit::REPPoint &posrep = (*it)->positionREP();
     
     KDTreeNodeInfo<reco::PFRecHit const*> rh1 (*it, posrep.eta(), posrep.phi());
     eltList.push_back(rh1);
     
     // Here we solve the problem of phi circular set by duplicating some rechits
     // too close to -Pi (or to Pi) and adding (substracting) to them 2 * Pi.
     if (rh1.dim[1] > (M_PI - phiOffset_)) {
       double phi = rh1.dim[1] - 2 * M_PI;
       KDTreeNodeInfo rh2(*it, posrep.eta(), phi);
       eltList.push_back(rh2);
     }
 
     if (rh1.dim[1] < (M_PI * -1.0 + phiOffset_)) {
       double phi = rh1.dim[1] + 2 * M_PI;
       KDTreeNodeInfo rh3(*it, posrep.eta(), phi);
       eltList.push_back(rh3);
     }
   }
 
   // Here we define the upper/lower bounds of the 2D space (eta/phi).
   double phimin = -1.0 * M_PI - phiOffset_;
   double phimax = M_PI + phiOffset_;
 
   // etamin-etamax, phimin-phimax
   KDTreeBox region(-3.0, 3.0, phimin, phimax);
 
   // We may now build the KDTree
   tree_.build(eltList, region);
 }

void KDTreeLinkerTrackHcal::clear ( void )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 216 of file KDTreeLinkerTrackHcal.cc.

References KDTreeLinkerAlgo< DATA >::clear(), cluster2TargetLinks_, fieldClusterSet_, rechit2ClusterLinks_, rechitsSet_, targetSet_, and tree_.

Referenced by ~KDTreeLinkerTrackHcal().

 {
   targetSet_.clear();
   fieldClusterSet_.clear();
 
   rechitsSet_.clear();
 
   rechit2ClusterLinks_.clear();
   cluster2TargetLinks_.clear();
 
   tree_.clear();
 }

void KDTreeLinkerTrackHcal::insertFieldClusterElt ( reco::PFBlockElement * hcalCluster )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 35 of file KDTreeLinkerTrackHcal.cc.

References reco::PFBlockElement::clusterRef(), fieldClusterSet_, funct::fract(), dedxEstimators_cff::fraction, edm::Ref< C, T, F >::isNull(), rechit2ClusterLinks_, and rechitsSet_.

 {
   const reco::PFClusterRef& clusterref = hcalCluster->clusterRef();
 
   // This test is more or less done in PFBlockAlgo.h. In others cases, it should be switch on.
   //   if (!((clusterref->layer() == PFLayer::HCAL_ENDCAP) ||
   //    (clusterref->layer() == PFLayer::HCAL_BARREL1)))
   //     return;
 
   const std::vector<reco::PFRecHitFraction> &fraction = clusterref->recHitFractions();
 
   // We create a list of hcalCluster
   fieldClusterSet_.insert(hcalCluster);
   for(size_t rhit = 0; rhit < fraction.size(); ++rhit) {
     const reco::PFRecHitRef& rh = fraction[rhit].recHitRef();
     double fract = fraction[rhit].fraction();
 
     if ((rh.isNull()) || (fract < 1E-4))
       continue;
       
     const reco::PFRecHit& rechit = *rh;
       
     // We save the links rechit to HcalClusters
     rechit2ClusterLinks_[&rechit].insert(hcalCluster);
     
     // We create a liste of rechits
     rechitsSet_.insert(&rechit);
   }
 }

void KDTreeLinkerTrackHcal::insertTargetElt ( reco::PFBlockElement * track )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 26 of file KDTreeLinkerTrackHcal.cc.

References reco::PFTrajectoryPoint::HCALEntrance, targetSet_, and reco::PFBlockElement::trackRefPF().

 {
   if( track->trackRefPF()->extrapolatedPoint( reco::PFTrajectoryPoint::HCALEntrance ).isValid() ) {
     targetSet_.insert(track);
   }
 }

void KDTreeLinkerTrackHcal::searchLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 107 of file KDTreeLinkerTrackHcal.cc.

References cluster2TargetLinks_, KDTreeLinkerBase::cristalPhiEtaMaxSize_, PVValHelper::eta, reco::PFTrajectoryPoint::HCALEntrance, reco::PFTrajectoryPoint::HCALExit, reco::PFTrajectoryPoint::isValid(), M_PI, phi, reco::PFTrajectoryPoint::positionREP(), rpcPointValidation_cfi::recHit, rechit2ClusterLinks_, KDTreeLinkerAlgo< DATA >::search(), targetSet_, and tree_.

 {
   // Must of the code has been taken from LinkByRecHit.cc
 
   // We iterate over the tracks.
   for(BlockEltSet::iterator it = targetSet_.begin(); 
       it != targetSet_.end(); it++) {
     
     reco::PFRecTrackRef trackref = (*it)->trackRefPF();
 
     const reco::PFTrajectoryPoint& atHCAL = 
       trackref->extrapolatedPoint(reco::PFTrajectoryPoint::HCALEntrance);
     const reco::PFTrajectoryPoint& atHCALExit = 
       trackref->extrapolatedPoint(reco::PFTrajectoryPoint::HCALExit);
     
     // The track didn't reach hcal
     if( ! atHCAL.isValid()) continue;
     
     double dHeta = atHCALExit.positionREP().eta() - atHCAL.positionREP().eta();
     double dHphi = atHCALExit.positionREP().phi() - atHCAL.positionREP().phi(); 
     if ( dHphi > M_PI ) dHphi = dHphi - 2. * M_PI;
     else if ( dHphi < -M_PI ) dHphi = dHphi + 2. * M_PI; 
     
     double tracketa = atHCAL.positionREP().eta() + 0.1 * dHeta;
     double trackphi = atHCAL.positionREP().phi() + 0.1 * dHphi;
     
     if (trackphi > M_PI) trackphi -= 2 * M_PI;
     else if (trackphi < -M_PI) trackphi += 2 * M_PI;
 
     // Estimate the maximal envelope in phi/eta that will be used to find rechit candidates.
     // Same envelope for cap et barrel rechits.
     double inflation = 1.;
     double rangeeta = (cristalPhiEtaMaxSize_ * (1.5 + 0.5) + 0.2 * fabs(dHeta)) * inflation; 
     double rangephi = (cristalPhiEtaMaxSize_ * (1.5 + 0.5) + 0.2 * fabs(dHphi)) * inflation; 
 
     // We search for all candidate recHits, ie all recHits contained in the maximal size envelope.
     std::vector<reco::PFRecHit const*> recHits;
     KDTreeBox trackBox(tracketa - rangeeta, tracketa + rangeeta,
                trackphi - rangephi, trackphi + rangephi);
     tree_.search(trackBox, recHits);
     
     // Here we check all rechit candidates using the non-approximated method.
     for(auto const& recHit : recHits) {
 
       const auto &rhrep        = recHit->positionREP();
       const auto & corners = recHit->getCornersREP();
       
       double rhsizeeta = fabs(corners[3].eta() - corners[1].eta());
       double rhsizephi = fabs(corners[3].phi() - corners[1].phi());
       if ( rhsizephi > M_PI ) rhsizephi = 2.*M_PI - rhsizephi;
       
       double deta = fabs(rhrep.eta() - tracketa);
       double dphi = fabs(rhrep.phi() - trackphi);
       if ( dphi > M_PI ) dphi = 2.*M_PI - dphi;
       
       // Find all clusters associated to given rechit
       RecHit2BlockEltMap::iterator ret = rechit2ClusterLinks_.find(recHit);
       
       for(BlockEltSet::iterator clusterIt = ret->second.begin(); 
       clusterIt != ret->second.end(); clusterIt++) {
     
     const reco::PFClusterRef clusterref = (*clusterIt)->clusterRef();
     int fracsNbr = clusterref->recHitFractions().size();
     
     double _rhsizeeta = rhsizeeta * (1.5 + 0.5 / fracsNbr) + 0.2 * fabs(dHeta);
     double _rhsizephi = rhsizephi * (1.5 + 0.5 / fracsNbr) + 0.2 * fabs(dHphi);
     
     // Check if the track and the cluster are linked
     if(deta < (_rhsizeeta / 2.) && dphi < (_rhsizephi / 2.))
       cluster2TargetLinks_[*clusterIt].insert(*it);
       }
     }
   }
 }

void KDTreeLinkerTrackHcal::updatePFBlockEltWithLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 183 of file KDTreeLinkerTrackHcal.cc.

References cluster2TargetLinks_, fieldClusterSet_, reco::PFTrajectoryPoint::HCALEntrance, reco::PFMultiLinksTC::linkedClusters, and reco::PFTrajectoryPoint::positionREP().

 {
   //TODO YG : Check if cluster positionREP() is valid ?
 
   // Here we save in each HCAL cluster the list of phi/eta values of linked clusters.
   for (BlockElt2BlockEltMap::iterator it = cluster2TargetLinks_.begin();
        it != cluster2TargetLinks_.end(); ++it) {
     reco::PFMultiLinksTC multitracks(true);
 
     for (BlockEltSet::iterator jt = it->second.begin();
      jt != it->second.end(); ++jt) {
 
       reco::PFRecTrackRef trackref = (*jt)->trackRefPF();
       const reco::PFTrajectoryPoint& atHCAL = 
     trackref->extrapolatedPoint(reco::PFTrajectoryPoint::HCALEntrance);
       double tracketa = atHCAL.positionREP().eta();
       double trackphi = atHCAL.positionREP().phi();
       
       multitracks.linkedClusters.push_back(std::make_pair(trackphi, tracketa));
     }
 
     it->first->setMultilinks(multitracks);
   }
 
   // We set the multilinks flag of the track to true. It will allow us to 
   // use in an optimized way our algo results in the recursive linking algo.
   for (BlockEltSet::iterator it = fieldClusterSet_.begin();
        it != fieldClusterSet_.end(); ++it)
     (*it)->setIsValidMultilinks(true);
 
 }