#include <KDTreeLinkerPSEcal.h>

Inheritance diagram for KDTreeLinkerPSEcal:

Public Member Functions
void	buildTree () override

void	clear () override

void	insertFieldClusterElt (reco::PFBlockElement *ecalCluster) override

void	insertTargetElt (reco::PFBlockElement *psCluster) override

	KDTreeLinkerPSEcal ()

void	searchLinks () override

void	updatePFBlockEltWithLinks () override

	~KDTreeLinkerPSEcal () 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 Member Functions
void	buildTree (const RecHitSet &rechitsSet, KDTreeLinkerAlgo< reco::PFRecHit const * > &tree)

Private Attributes
BlockEltSet	fieldClusterSet_

const double	ps1ToEcal_

const double	ps2ToEcal_

RecHit2BlockEltMap	rechit2ClusterLinks_

RecHitSet	rechitsNegSet_

RecHitSet	rechitsPosSet_

const double	resPSlength_

const double	resPSpitch_

BlockElt2BlockEltMap	target2ClusterLinks_

BlockEltSet	targetSet_

KDTreeLinkerAlgo< reco::PFRecHit const * >	treeNeg_

KDTreeLinkerAlgo< reco::PFRecHit const * >	treePos_

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 KDTreeLinkerPSEcal.h.

Constructor & Destructor Documentation

KDTreeLinkerPSEcal::KDTreeLinkerPSEcal ( )

Definition at line 12 of file KDTreeLinkerPSEcal.cc.

   : KDTreeLinkerBase(),
     resPSpitch_ (0.19),
     resPSlength_ (6.1),
     ps1ToEcal_ (1.072),
     ps2ToEcal_ (1.057)
 {}

KDTreeLinkerPSEcal::~KDTreeLinkerPSEcal ( )

override

Definition at line 20 of file KDTreeLinkerPSEcal.cc.

References clear().

 {
   clear();
 }

Member Function Documentation

void KDTreeLinkerPSEcal::buildTree ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 70 of file KDTreeLinkerPSEcal.cc.

References rechitsNegSet_, rechitsPosSet_, treeNeg_, and treePos_.

 {
   buildTree(rechitsNegSet_, treeNeg_);
   buildTree(rechitsPosSet_, treePos_);
 }

void KDTreeLinkerPSEcal::buildTree	(	const RecHitSet &	rechitsSet,
		KDTreeLinkerAlgo< reco::PFRecHit const * > &	tree
	)

private

Definition at line 77 of file KDTreeLinkerPSEcal.cc.

References KDTreeLinkerAlgo< DATA >::build(), and reco::PFRecHit::position().

 {
   // List of pseudo-rechits that will be used to create the KDTree
   std::vector<KDTreeNodeInfo<reco::PFRecHit const*>> eltList;
 
   // Filling of this eltList
   for(RecHitSet::const_iterator it = rechitsSet.begin(); 
       it != rechitsSet.end(); it++) {
 
     const reco::PFRecHit* rh = *it;
     const auto & posxyz = rh->position();
         
     KDTreeNodeInfo rhinfo {rh, posxyz.x(), posxyz.y()};
     eltList.push_back(rhinfo);
   }
 
   // xmin-xmax, ymain-ymax
   KDTreeBox region{-150., 150., -150., 150.};
 
   // We may now build the KDTree
   tree.build(eltList, region);
 }

void KDTreeLinkerPSEcal::clear ( void )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 230 of file KDTreeLinkerPSEcal.cc.

References KDTreeLinkerAlgo< DATA >::clear(), fieldClusterSet_, rechit2ClusterLinks_, rechitsNegSet_, rechitsPosSet_, target2ClusterLinks_, targetSet_, treeNeg_, and treePos_.

Referenced by ~KDTreeLinkerPSEcal().

 {
   targetSet_.clear();
   fieldClusterSet_.clear();
 
   rechitsNegSet_.clear();
   rechitsPosSet_.clear();
 
   rechit2ClusterLinks_.clear();
   target2ClusterLinks_.clear();
 
   treeNeg_.clear();
   treePos_.clear();
 }

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

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 37 of file KDTreeLinkerPSEcal.cc.

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

 {
   const reco::PFClusterRef& clusterref = ecalCluster->clusterRef();
 
   if (clusterref->layer() != PFLayer::ECAL_ENDCAP)
     return;
       
   const std::vector<reco::PFRecHitFraction> &fraction = clusterref->recHitFractions();
 
   // We create a list of cluster
   fieldClusterSet_.insert(ecalCluster);
 
   double clusterz = clusterref->position().Z();
   RecHitSet& rechitsSet = (clusterz < 0) ? rechitsNegSet_ : rechitsPosSet_;
 
   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 Clusters
     rechit2ClusterLinks_[&rechit].insert(ecalCluster);
     
     // We create a liste of rechits
     rechitsSet.insert(&rechit);
   }
 }

void KDTreeLinkerPSEcal::insertTargetElt ( reco::PFBlockElement * psCluster )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 27 of file KDTreeLinkerPSEcal.cc.

References targetSet_.

 {
   // This test is more or less done in PFBlockAlgo.h. In others cases, it should be switch on.
   //if (!((psCluster->clusterRef()->layer() == PFLayer::PS1) || (psCluster->clusterRef()->layer() == PFLayer::PS2)))
   //  return;
   targetSet_.insert(psCluster);
 }

void KDTreeLinkerPSEcal::searchLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 102 of file KDTreeLinkerPSEcal.cc.

References KDTreeLinkerBase::cristalXYMaxSize_, reco::PFCluster::layer(), reco::CaloCluster::position(), reco::PFCluster::positionREP(), PFLayer::PS1, ps1ToEcal_, ps2ToEcal_, rpcPointValidation_cfi::recHit, rechit2ClusterLinks_, resPSlength_, resPSpitch_, KDTreeLinkerAlgo< DATA >::search(), target2ClusterLinks_, targetSet_, treeNeg_, treePos_, x, and y.

 {
   // Must of the code has been taken from LinkByRecHit.cc
 
   // We iterate over the PS clusters.
   for(BlockEltSet::iterator it = targetSet_.begin(); 
       it != targetSet_.end(); it++) {
 
     (*it)->setIsValidMultilinks(true);
     
     reco::PFClusterRef clusterPSRef = (*it)->clusterRef();
     const reco::PFCluster& clusterPS = *clusterPSRef;
 
     // PS cluster position, extrapolated to ECAL
     double zPS = clusterPS.position().Z();
     double xPS = clusterPS.position().X();
     double yPS = clusterPS.position().Y();
 
     double etaPS = fabs(clusterPS.positionREP().eta());
     double deltaX = 0.;
     double deltaY = 0.;
     double xPSonEcal = xPS;
     double yPSonEcal = yPS;
 
     if (clusterPS.layer() == PFLayer::PS1) { // PS1
 
       // vertical strips, measure x with pitch precision
       deltaX = resPSpitch_;
       deltaY = resPSlength_;
       xPSonEcal *= ps1ToEcal_;
       yPSonEcal *= ps1ToEcal_;
 
     } else { // PS2
 
       // horizontal strips, measure y with pitch precision
       deltaY = resPSpitch_;
       deltaX = resPSlength_;
       xPSonEcal *= ps2ToEcal_;
       yPSonEcal *= ps2ToEcal_;
 
     }
  
     
     // Estimate the maximal envelope in phi/eta that will be used to find rechit candidates.
     // Same envelope for cap et barrel rechits.
     
     
     double maxEcalRadius = cristalXYMaxSize_ / 2.;
 
     // The inflation factor includes the approximate projection from Preshower to ECAL
     double inflation = 2.4 - (etaPS-1.6);
     double rangeX = maxEcalRadius * (1 + (0.05 + 1.0 / maxEcalRadius * deltaX / 2.)) * inflation; 
     double rangeY = maxEcalRadius * (1 + (0.05 + 1.0 / maxEcalRadius * deltaY / 2.)) * inflation; 
     
     // We search for all candidate recHits, ie all recHits contained in the maximal size envelope.
     std::vector<reco::PFRecHit const*> recHits;
     KDTreeBox trackBox(xPSonEcal - rangeX, xPSonEcal + rangeX, 
           yPSonEcal - rangeY, yPSonEcal + rangeY);
 
     if (zPS < 0)
       treeNeg_.search(trackBox, recHits);
     else
       treePos_.search(trackBox, recHits);
 
 
     for(auto const& recHit : recHits) {
            
       const auto & corners = recHit->getCornersXYZ();
 
       // 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();
 
     const auto & posxyz = recHit->position() * zPS / clusterz;
 
     double x[5];
     double y[5];
     for ( unsigned jc=0; jc<4; ++jc ) {
       auto cornerpos = corners[jc].basicVector() * zPS / clusterz;
       x[3-jc] = cornerpos.x() + (cornerpos.x()-posxyz.x()) * (0.05 +1.0/fabs((cornerpos.x()-posxyz.x()))*deltaX/2.);
       y[3-jc] = cornerpos.y() + (cornerpos.y()-posxyz.y()) * (0.05 +1.0/fabs((cornerpos.y()-posxyz.y()))*deltaY/2.);
     }
 
     x[4] = x[0];
     y[4] = y[0];
     
     bool isinside = TMath::IsInside(xPS,
                     yPS,
                     5,x,y);
     
     // Check if the track and the cluster are linked
     if( isinside )
       target2ClusterLinks_[*it].insert(*clusterIt); 
       }
     }
     
   }
 }

void KDTreeLinkerPSEcal::updatePFBlockEltWithLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 207 of file KDTreeLinkerPSEcal.cc.

References reco::PFMultiLinksTC::linkedClusters, and target2ClusterLinks_.

 {
   //TODO YG : Check if cluster positionREP() is valid ?
 
   // Here we save in each track the list of phi/eta values of linked clusters.
   for (BlockElt2BlockEltMap::iterator it = target2ClusterLinks_.begin();
        it != target2ClusterLinks_.end(); ++it) {
     reco::PFMultiLinksTC multitracks(true);
 
     for (BlockEltSet::iterator jt = it->second.begin();
      jt != it->second.end(); ++jt) {
 
       double clusterphi = (*jt)->clusterRef()->positionREP().phi();
       double clustereta = (*jt)->clusterRef()->positionREP().eta();
 
       multitracks.linkedClusters.push_back(std::make_pair(clusterphi, clustereta));
     }
 
     it->first->setMultilinks(multitracks);
   }
 }