Inheritance diagram for TrackAndHCALLinker:

Public Member Functions
bool	linkPrefilter (const reco::PFBlockElement , const reco::PFBlockElement ) const override

double	testLink (const reco::PFBlockElement , const reco::PFBlockElement ) const override

	TrackAndHCALLinker (const edm::ParameterSet &conf)

Public Member Functions inherited from BlockElementLinkerBase
	BlockElementLinkerBase (const edm::ParameterSet &conf)

	BlockElementLinkerBase (const BlockElementLinkerBase &)=delete

const std::string &	name () const

BlockElementLinkerBase &	operator= (const BlockElementLinkerBase &)=delete

virtual	~BlockElementLinkerBase ()=default

Private Attributes
bool	checkExit_

bool	debug_

reco::PFTrajectoryPoint::LayerType	trajectoryLayerEntrance_

std::string	trajectoryLayerEntranceString_

reco::PFTrajectoryPoint::LayerType	trajectoryLayerExit_

std::string	trajectoryLayerExitString_

bool	useKDTree_

Detailed Description

Definition at line 10 of file TrackAndHCALLinker.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 12 of file TrackAndHCALLinker.cc.

References cms::cuda::assert(), checkExit_, reco::PFTrajectoryPoint::HCALEntrance, reco::PFTrajectoryPoint::HCALExit, reco::PFTrajectoryPoint::layerTypeByName(), trajectoryLayerEntrance_, trajectoryLayerEntranceString_, trajectoryLayerExit_, trajectoryLayerExitString_, reco::PFTrajectoryPoint::Unknown, and reco::PFTrajectoryPoint::VFcalEntrance.

       : BlockElementLinkerBase(conf),
         useKDTree_(conf.getParameter<bool>("useKDTree")),
         trajectoryLayerEntranceString_(conf.getParameter<std::string>("trajectoryLayerEntrance")),
         trajectoryLayerExitString_(conf.getParameter<std::string>("trajectoryLayerExit")),
         debug_(conf.getUntrackedParameter<bool>("debug", false)) {
     // convert TrajectoryLayers info from string to enum
     trajectoryLayerEntrance_ = reco::PFTrajectoryPoint::layerTypeByName(trajectoryLayerEntranceString_);
     trajectoryLayerExit_ = reco::PFTrajectoryPoint::layerTypeByName(trajectoryLayerExitString_);
     // make sure the requested setting is supported
     assert((trajectoryLayerEntrance_ == reco::PFTrajectoryPoint::HCALEntrance &&
             trajectoryLayerExit_ == reco::PFTrajectoryPoint::HCALExit) ||
            (trajectoryLayerEntrance_ == reco::PFTrajectoryPoint::HCALEntrance &&
             trajectoryLayerExit_ == reco::PFTrajectoryPoint::Unknown) ||
            (trajectoryLayerEntrance_ == reco::PFTrajectoryPoint::VFcalEntrance &&
             trajectoryLayerExit_ == reco::PFTrajectoryPoint::Unknown));
     // flag if exit layer should be checked or not
     checkExit_ = trajectoryLayerExit_ != reco::PFTrajectoryPoint::Unknown;
   }

Member Function Documentation

bool TrackAndHCALLinker::linkPrefilter	(	const reco::PFBlockElement *	elem1,
		const reco::PFBlockElement *	elem2
	)		const

overridevirtual

Reimplemented from BlockElementLinkerBase.

Definition at line 48 of file TrackAndHCALLinker.cc.

References relativeConstraints::empty, reco::PFBlockElement::getMultilinks(), reco::PFBlockElement::HCAL, reco::PFBlockElement::isMultilinksValide(), mps_fire::result, reco::PFBlockElement::TRACK, reco::PFBlockElement::type(), and useKDTree_.

                                                                                                              {
   bool result = false;
   // Track-HCAL KDTree multilinks are stored to track's elem
   switch (elem1->type()) {
     case reco::PFBlockElement::TRACK:
       result = (elem1->isMultilinksValide(elem2->type()) && !elem1->getMultilinks(elem2->type()).empty() &&
                 elem2->isMultilinksValide(elem1->type()));
       break;
     case reco::PFBlockElement::HCAL:
       result = (elem2->isMultilinksValide(elem1->type()) && !elem2->getMultilinks(elem1->type()).empty() &&
                 elem1->isMultilinksValide(elem2->type()));
     default:
       break;
   }
   return (useKDTree_ ? result : true);
 }

double TrackAndHCALLinker::testLink	(	const reco::PFBlockElement *	elem1,
		const reco::PFBlockElement *	elem2
	)		const

overridevirtual

Implements BlockElementLinkerBase.

Definition at line 65 of file TrackAndHCALLinker.cc.

References checkExit_, reco::PFBlockElementCluster::clusterRef(), LinkByRecHit::computeDist(), debug_, reco::deltaPhi(), reco::PFBlockElement::getMultilinks(), reco::PFBlockElement::isMultilinksValide(), reco::PFTrajectoryPoint::isValid(), reco::PFTrajectoryPoint::position(), reco::PFTrajectoryPoint::positionREP(), LinkByRecHit::testTrackAndClusterByRecHit(), reco::PFBlockElementTrack::trackRefPF(), trajectoryLayerEntrance_, trajectoryLayerExit_, reco::PFBlockElement::type(), and useKDTree_.

                                                                                                           {
   const reco::PFBlockElementCluster* hcalelem(nullptr);
   const reco::PFBlockElementTrack* tkelem(nullptr);
   double dist(-1.0);
   if (elem1->type() < elem2->type()) {
     tkelem = static_cast<const reco::PFBlockElementTrack*>(elem1);
     hcalelem = static_cast<const reco::PFBlockElementCluster*>(elem2);
   } else {
     tkelem = static_cast<const reco::PFBlockElementTrack*>(elem2);
     hcalelem = static_cast<const reco::PFBlockElementCluster*>(elem1);
   }
   const reco::PFRecTrackRef& trackref = tkelem->trackRefPF();
   const reco::PFClusterRef& clusterref = hcalelem->clusterRef();
   const reco::PFCluster::REPPoint& hcalreppos = clusterref->positionREP();
   const reco::PFTrajectoryPoint& tkAtHCALEnt = trackref->extrapolatedPoint(trajectoryLayerEntrance_);
   const reco::PFCluster::REPPoint& tkreppos = tkAtHCALEnt.positionREP();
   // Check exit point
   double dHEta = 0.;
   double dHPhi = 0.;
   double dRHCALEx = 0.;
   if (checkExit_) {
     const reco::PFTrajectoryPoint& tkAtHCALEx = trackref->extrapolatedPoint(trajectoryLayerExit_);
     dHEta = (tkAtHCALEx.positionREP().Eta() - tkAtHCALEnt.positionREP().Eta());
     dHPhi = reco::deltaPhi(tkAtHCALEx.positionREP().Phi(), tkAtHCALEnt.positionREP().Phi());
     dRHCALEx = tkAtHCALEx.position().R();
   }
 
   // Check if the linking has been done using the KDTree algo
   // Glowinski & Gouzevitch
   if (useKDTree_ && tkelem->isMultilinksValide(hcalelem->type())) {  //KDTree Algo
     const reco::PFMultilinksType& multilinks = tkelem->getMultilinks(hcalelem->type());
 
     // Check if the link Track/Hcal exist
     reco::PFMultilinksType::const_iterator mlit = multilinks.begin();
     for (; mlit != multilinks.end(); ++mlit)
       if (mlit->clusterRef == clusterref)
         break;
 
     // If the link exist, we fill dist and linktest.
 
     if (mlit != multilinks.end()) {
       // when checkExit_ is false
       if (!checkExit_) {
         dist = LinkByRecHit::computeDist(hcalreppos.Eta(), hcalreppos.Phi(), tkreppos.Eta(), tkreppos.Phi());
       }
       // when checkExit_ is true
       else {
         //special case ! A looper  can exit the barrel inwards and hit the endcap
         //In this case calculate the distance based on the first crossing since
         //the looper will probably never make it to the endcap
         if (dRHCALEx < tkAtHCALEnt.position().R()) {
           dist = LinkByRecHit::computeDist(hcalreppos.Eta(), hcalreppos.Phi(), tkreppos.Eta(), tkreppos.Phi());
           edm::LogWarning("TrackHCALLinker ")
               << "Special case of linking with track hitting HCAL and looping back in the tracker ";
         } else {
           dist = LinkByRecHit::computeDist(
               hcalreppos.Eta(), hcalreppos.Phi(), tkreppos.Eta() + 0.1 * dHEta, tkreppos.Phi() + 0.1 * dHPhi);
         }
       }  // checkExit_
     }    // multilinks
 
   } else {  // Old algorithm
     if (tkAtHCALEnt.isValid())
       dist = LinkByRecHit::testTrackAndClusterByRecHit(*trackref, *clusterref, false, debug_);
   }
   return dist;
 }