Inheritance diagram for KDTreeLinkerTrackEcal:

Public Member Functions
void	buildTree () override

void	clear () override

void	insertFieldClusterElt (reco::PFBlockElement *ecalCluster) override

void	insertTargetElt (reco::PFBlockElement *track) override

	KDTreeLinkerTrackEcal (const edm::ParameterSet &conf)

void	searchLinks () override

void	updatePFBlockEltWithLinks () override

	~KDTreeLinkerTrackEcal () override

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

	KDTreeLinkerBase (const edm::ParameterSet &conf)

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
Static Protected Member Functions inherited from KDTreeLinkerBase
template<typename T >
static std::vector< size_t >	sort_indexes (const std::vector< T > &v)

Protected Attributes inherited from KDTreeLinkerBase
reco::PFBlockElement::Type	_fieldType

reco::PFBlockElement::Type	_targetType

float	cristalPhiEtaMaxSize_ = 0.04

float	cristalXYMaxSize_ = 3.

const float	cutOffFrac = 1E-4

bool	debug_ = false

float	phiOffset_ = 0.25

Detailed Description

Definition at line 11 of file KDTreeLinkerTrackEcal.cc.

Constructor & Destructor Documentation

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

Definition at line 62 of file KDTreeLinkerTrackEcal.cc.

62 : KDTreeLinkerBase(conf) {}

KDTreeLinkerBase::KDTreeLinkerBase

KDTreeLinkerBase(const edm::ParameterSet &conf)

Definition: KDTreeLinkerBase.h:21

KDTreeLinkerTrackEcal::~KDTreeLinkerTrackEcal ( )

override

Definition at line 64 of file KDTreeLinkerTrackEcal.cc.

References clear().

64 { clear(); }

KDTreeLinkerTrackEcal::clear

void clear() override

Definition: KDTreeLinkerTrackEcal.cc:263

Member Function Documentation

void KDTreeLinkerTrackEcal::buildTree ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 101 of file KDTreeLinkerTrackEcal.cc.

References KDTreeLinkerAlgo< DATA, DIM >::build(), RhoEtaPhi::eta(), validate-o2o-wbm::f, M_PI, phi, RhoEtaPhi::phi(), phimax, phimin, KDTreeLinkerBase::phiOffset_, rechitsSet_, HLT_FULL_cff::region, and tree_.

                                       {
   // List of pseudo-rechits that will be used to create the KDTree
   std::vector<KDTreeNodeInfo<reco::PFRecHit const *, 2>> 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 *, 2> 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.dims[1] > (M_PI - phiOffset_)) {
       float phi = rh1.dims[1] - 2 * M_PI;
       KDTreeNodeInfo<reco::PFRecHit const *, 2> rh2(*it, float(posrep.eta()), phi);
       eltList.push_back(rh2);
     }
 
     if (rh1.dims[1] < (M_PI * -1.0 + phiOffset_)) {
       float phi = rh1.dims[1] + 2 * M_PI;
       KDTreeNodeInfo<reco::PFRecHit const *, 2> rh3(*it, float(posrep.eta()), phi);
       eltList.push_back(rh3);
     }
   }
 
   // Here we define the upper/lower bounds of the 2D space (eta/phi).
   float phimin = -1.0 * M_PI - phiOffset_;
   float phimax = M_PI + phiOffset_;
 
   // etamin-etamax, phimin-phimax
   KDTreeBox region(-3.0f, 3.0f, phimin, phimax);
 
   // We may now build the KDTree
   tree_.build(eltList, region);
 }

void KDTreeLinkerTrackEcal::clear ( void )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 263 of file KDTreeLinkerTrackEcal.cc.

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

Referenced by ~KDTreeLinkerTrackEcal().

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

void KDTreeLinkerTrackEcal::insertFieldClusterElt ( reco::PFBlockElement * ecalCluster )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 72 of file KDTreeLinkerTrackEcal.cc.

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

                                                                                  {
   const reco::PFClusterRef &clusterref = ecalCluster->clusterRef();
 
   // This test is more or less done in PFBlockAlgo.h. In others cases, it should be switch on.
   //   if (!((clusterref->layer() == PFLayer::ECAL_ENDCAP) ||
   //    (clusterref->layer() == PFLayer::ECAL_BARREL)))
   //     return;
 
   const std::vector<reco::PFRecHitFraction> &fraction = clusterref->recHitFractions();
 
   // We create a list of ecalCluster
   fieldClusterSet_.insert(ecalCluster);
   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 < cutOffFrac))
       continue;
 
     const reco::PFRecHit &rechit = *rh;
 
     // We save the links rechit to EcalClusters
     rechit2ClusterLinks_[&rechit].insert(ecalCluster);
 
     // We create a liste of rechits
     rechitsSet_.insert(&rechit);
   }
 }

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

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 66 of file KDTreeLinkerTrackEcal.cc.

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

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

void KDTreeLinkerTrackEcal::searchLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 138 of file KDTreeLinkerTrackEcal.cc.

References reco::PFTrajectoryPoint::ClosestApproach, cluster2TargetLinks_, KDTreeLinkerBase::cristalPhiEtaMaxSize_, PFLayer::ECAL_BARREL, reco::PFTrajectoryPoint::ECALShowerMax, PVValHelper::eta, reco::PFTrajectoryPoint::isValid(), M_PI, min(), reco::PFTrajectoryPoint::momentum(), phi, reco::PFTrajectoryPoint::position(), reco::PFTrajectoryPoint::positionREP(), sistrip::SpyUtilities::range(), rechit2ClusterLinks_, HLT_FULL_cff::recHits, runTheMatrix::ret, KDTreeLinkerAlgo< DATA, DIM >::search(), mathSSE::sqrt(), targetSet_, listHistos::trackPt, tree_, x, and y.

                                         {
   // Most 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 &atECAL = trackref->extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax);
 
     // The track didn't reach ecal
     if (!atECAL.isValid())
       continue;
 
     const reco::PFTrajectoryPoint &atVertex = trackref->extrapolatedPoint(reco::PFTrajectoryPoint::ClosestApproach);
 
     double trackPt = sqrt(atVertex.momentum().Vect().Perp2());
     float tracketa = atECAL.positionREP().eta();
     float trackphi = atECAL.positionREP().phi();
     double trackx = atECAL.position().X();
     double tracky = atECAL.position().Y();
     double trackz = atECAL.position().Z();
 
     // Estimate the maximal envelope in phi/eta that will be used to find rechit candidates.
     // Same envelope for cap et barrel rechits.
     float range = cristalPhiEtaMaxSize_ * (2.0 + 1.0 / std::min(1., trackPt / 2.));
 
     // We search for all candidate recHits, ie all recHits contained in the maximal size envelope.
     std::vector<reco::PFRecHit const *> recHits;
     KDTreeBox trackBox(tracketa - range, tracketa + range, trackphi - range, trackphi + range);
     tree_.search(trackBox, recHits);
 
     // Here we check all rechit candidates using the non-approximated method.
     for (auto const &recHit : recHits) {
       const auto &cornersxyz = recHit->getCornersXYZ();
       const auto &posxyz = recHit->position();
       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::const_iterator clusterIt = ret->second.begin(); clusterIt != ret->second.end(); clusterIt++) {
         reco::PFClusterRef clusterref = (*clusterIt)->clusterRef();
         double clusterz = clusterref->position().z();
         int fracsNbr = clusterref->recHitFractions().size();
 
         if (clusterref->layer() == PFLayer::ECAL_BARREL) {  // BARREL
           // Check if the track is in the barrel
           if (fabs(trackz) > 300.)
             continue;
 
           double _rhsizeeta = rhsizeeta * (2.00 + 1.0 / (fracsNbr * std::min(1., trackPt / 2.)));
           double _rhsizephi = rhsizephi * (2.00 + 1.0 / (fracsNbr * std::min(1., trackPt / 2.)));
 
           // Check if the track and the cluster are linked
           if (deta < (_rhsizeeta / 2.) && dphi < (_rhsizephi / 2.))
             cluster2TargetLinks_[*clusterIt].insert(*it);
 
         } else {  // ENDCAP
 
           // Check if the track is in the cap
           if (fabs(trackz) < 300.)
             continue;
           if (trackz * clusterz < 0.)
             continue;
 
           double x[5];
           double y[5];
           for (unsigned jc = 0; jc < 4; ++jc) {
             auto cornerposxyz = cornersxyz[jc];
             x[3 - jc] = cornerposxyz.x() +
                         (cornerposxyz.x() - posxyz.x()) * (1.00 + 0.50 / fracsNbr / std::min(1., trackPt / 2.));
             y[3 - jc] = cornerposxyz.y() +
                         (cornerposxyz.y() - posxyz.y()) * (1.00 + 0.50 / fracsNbr / std::min(1., trackPt / 2.));
           }
 
           x[4] = x[0];
           y[4] = y[0];
 
           bool isinside = TMath::IsInside(trackx, tracky, 5, x, y);
 
           // Check if the track and the cluster are linked
           if (isinside)
             cluster2TargetLinks_[*clusterIt].insert(*it);
         }
       }
     }
   }
 }

void KDTreeLinkerTrackEcal::updatePFBlockEltWithLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 238 of file KDTreeLinkerTrackEcal.cc.

References KDTreeLinkerBase::_fieldType, KDTreeLinkerBase::_targetType, cluster2TargetLinks_, and reco::PFMultiLinksTC::linkedPFObjects.

                                                       {
   //TODO YG : Check if cluster positionREP() is valid ?
 
   // Here we save in each ECAL cluster the list of phi/eta values of linked tracks.
   for (BlockElt2BlockEltMap::iterator it = cluster2TargetLinks_.begin(); it != cluster2TargetLinks_.end(); ++it) {
     const auto &ecalElt = it->first;
     const auto &trackEltSet = it->second;
     reco::PFMultiLinksTC multitracks(true);
 
     for (const auto &trackElt : trackEltSet) {
       const reco::PFRecTrackRef &trackref = trackElt->trackRefPF();
 
       reco::PFMultilink multiLink(trackref);
       multitracks.linkedPFObjects.push_back(multiLink);
 
       // We set the multilinks flag of the track (for links to ECAL) to true. It will allow us to
       // use it in an optimized way in prefilter
       trackElt->setIsValidMultilinks(true, _fieldType);
     }
 
     // We set multilinks of the ECAL element (for links to tracks)
     ecalElt->setMultilinks(multitracks, _targetType);
   }
 }