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 (const edm::ParameterSet &conf)

void	searchLinks () override

void	updatePFBlockEltWithLinks () override

	~KDTreeLinkerPSEcal () 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 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
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 10 of file KDTreeLinkerPSEcal.cc.

Constructor & Destructor Documentation

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

Definition at line 73 of file KDTreeLinkerPSEcal.cc.

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

KDTreeLinkerPSEcal::resPSlength_

const double resPSlength_

Definition: KDTreeLinkerPSEcal.cc:45

KDTreeLinkerPSEcal::ps2ToEcal_

const double ps2ToEcal_

Definition: KDTreeLinkerPSEcal.cc:47

KDTreeLinkerPSEcal::resPSpitch_

const double resPSpitch_

Definition: KDTreeLinkerPSEcal.cc:44

KDTreeLinkerBase::KDTreeLinkerBase

KDTreeLinkerBase(const edm::ParameterSet &conf)

Definition: KDTreeLinkerBase.h:21

KDTreeLinkerPSEcal::ps1ToEcal_

const double ps1ToEcal_

Definition: KDTreeLinkerPSEcal.cc:46

KDTreeLinkerPSEcal::~KDTreeLinkerPSEcal ( )

override

Definition at line 76 of file KDTreeLinkerPSEcal.cc.

References clear().

76 { clear(); }

KDTreeLinkerPSEcal::clear

void clear() override

Definition: KDTreeLinkerPSEcal.cc:254

Member Function Documentation

void KDTreeLinkerPSEcal::buildTree ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 116 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 121 of file KDTreeLinkerPSEcal.cc.

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

                                                                                                             {
   // List of pseudo-rechits that will be used to create the KDTree
   std::vector<KDTreeNodeInfo<reco::PFRecHit const *, 2>> 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<reco::PFRecHit const *, 2> rhinfo{rh, posxyz.x(), posxyz.y()};
     eltList.push_back(rhinfo);
   }
 
   // xmin-xmax, ymain-ymax
   KDTreeBox region{-150.f, 150.f, -150.f, 150.f};
 
   // We may now build the KDTree
   tree.build(eltList, region);
 }

void KDTreeLinkerPSEcal::clear ( void )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 254 of file KDTreeLinkerPSEcal.cc.

References KDTreeLinkerAlgo< DATA, DIM >::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 85 of file KDTreeLinkerPSEcal.cc.

References reco::PFBlockElement::clusterRef(), KDTreeLinkerBase::cutOffFrac, PFLayer::ECAL_ENDCAP, fieldClusterSet_, funct::fract(), HLT_FULL_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 < cutOffFrac))
       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 78 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 141 of file KDTreeLinkerPSEcal.cc.

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

                                      {
   // Most 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++) {
     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.;
     float xPSonEcal = xPS;
     float 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);
     float rangeX = maxEcalRadius * (1 + (0.05 + 1.0 / maxEcalRadius * deltaX / 2.)) * inflation;
     float 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 231 of file KDTreeLinkerPSEcal.cc.

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

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