KDTreeLinkerTrackHcal Class Reference

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 (const edm::ParameterSet &conf)
void	searchLinks () override
void	updatePFBlockEltWithLinks () override
	~KDTreeLinkerTrackHcal () 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
bool	checkExit_
BlockElt2BlockEltMap	cluster2TargetLinks_
BlockEltSet	fieldClusterSet_
RecHit2BlockEltMap	rechit2ClusterLinks_
RecHitSet	rechitsSet_
BlockEltSet	targetSet_
reco::PFTrajectoryPoint::LayerType	trajectoryLayerEntrance_
std::string	trajectoryLayerEntranceString_
reco::PFTrajectoryPoint::LayerType	trajectoryLayerExit_
std::string	trajectoryLayerExitString_
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.
const float	cutOffFrac = 1E-4
bool	debug_ = false
float	phiOffset_ = 0.25

Detailed Description

Definition at line 8 of file KDTreeLinkerTrackHcal.cc.

Constructor & Destructor Documentation

KDTreeLinkerTrackHcal::KDTreeLinkerTrackHcal

(

const edm::ParameterSet &

conf

)

Definition at line 66 of file KDTreeLinkerTrackHcal.cc.

References checkExit_, KDTreeLinkerBase::cristalPhiEtaMaxSize_, reco::PFTrajectoryPoint::HCALEntrance, reco::PFTrajectoryPoint::HCALExit, reco::PFTrajectoryPoint::layerTypeByName(), KDTreeLinkerBase::phiOffset_, trajectoryLayerEntrance_, trajectoryLayerEntranceString_, trajectoryLayerExit_, trajectoryLayerExitString_, reco::PFTrajectoryPoint::Unknown, and reco::PFTrajectoryPoint::VFcalEntrance.

    : KDTreeLinkerBase(conf),
      trajectoryLayerEntranceString_(conf.getParameter<std::string>("trajectoryLayerEntrance")),
      trajectoryLayerExitString_(conf.getParameter<std::string>("trajectoryLayerExit")) {
  // Initialization
  cristalPhiEtaMaxSize_ = 0.2;
  phiOffset_ = 0.32;
  // 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;
}

KDTreeLinkerTrackHcal::~KDTreeLinkerTrackHcal ( )

override

Definition at line 87 of file KDTreeLinkerTrackHcal.cc.

References clear().

{ clear(); }

Member Function Documentation

void KDTreeLinkerTrackHcal::buildTree ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 124 of file KDTreeLinkerTrackHcal.cc.

References KDTreeLinkerAlgo< DATA, DIM >::build(), RhoEtaPhi::eta(), f, M_PI, phi, RhoEtaPhi::phi(), phimax, phimin, KDTreeLinkerBase::phiOffset_, rechitsSet_, HLT_2018_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 KDTreeLinkerTrackHcal::clear ( void  )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 264 of file KDTreeLinkerTrackHcal.cc.

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

References reco::PFBlockElement::clusterRef(), KDTreeLinkerBase::cutOffFrac, fieldClusterSet_, funct::fract(), HLT_2018_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 < cutOffFrac))
      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 89 of file KDTreeLinkerTrackHcal.cc.

References targetSet_, reco::PFBlockElement::trackRefPF(), and trajectoryLayerEntrance_.

                                                                     {
  if (track->trackRefPF()->extrapolatedPoint(trajectoryLayerEntrance_).isValid()) {
    targetSet_.insert(track);
  }
}

void KDTreeLinkerTrackHcal::searchLinks ( )

overridevirtual

Implements KDTreeLinkerBase.

Definition at line 161 of file KDTreeLinkerTrackHcal.cc.

References checkExit_, cluster2TargetLinks_, KDTreeLinkerBase::cristalPhiEtaMaxSize_, PVValHelper::eta, reco::PFTrajectoryPoint::isValid(), M_PI, phi, reco::PFTrajectoryPoint::positionREP(), rpcPointValidation_cfi::recHit, rechit2ClusterLinks_, FastTrackerRecHitMaskProducer_cfi::recHits, runTheMatrix::ret, KDTreeLinkerAlgo< DATA, DIM >::search(), targetSet_, trajectoryLayerEntrance_, trajectoryLayerExit_, 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(trajectoryLayerEntrance_);

    // The track didn't reach hcal
    if (!atHCAL.isValid())
      continue;

    // In case the exit point check is requested, check eta and phi differences between entrance and exit
    double dHeta = 0.0;
    float dHphi = 0.0;
    if (checkExit_) {
      const reco::PFTrajectoryPoint& atHCALExit = trackref->extrapolatedPoint(trajectoryLayerExit_);
      dHeta = atHCALExit.positionREP().eta() - atHCAL.positionREP().eta();
      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;
    }  // checkExit_

    float tracketa = atHCAL.positionREP().eta() + 0.1 * dHeta;
    float 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.;
    float rangeeta = (cristalPhiEtaMaxSize_ * (1.5 + 0.5) + 0.2 * fabs(dHeta)) * inflation;
    float 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 239 of file KDTreeLinkerTrackHcal.cc.

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

                                                      {
  //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(trajectoryLayerEntrance_);
      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);
}

Member Data Documentation

bool KDTreeLinkerTrackHcal::checkExit_

private

Definition at line 59 of file KDTreeLinkerTrackHcal.cc.

Referenced by KDTreeLinkerTrackHcal(), and searchLinks().

BlockElt2BlockEltMap KDTreeLinkerTrackHcal::cluster2TargetLinks_

private

Definition at line 46 of file KDTreeLinkerTrackHcal.cc.

Referenced by clear(), searchLinks(), and updatePFBlockEltWithLinks().

BlockEltSet KDTreeLinkerTrackHcal::fieldClusterSet_

private

Definition at line 40 of file KDTreeLinkerTrackHcal.cc.

Referenced by clear(), insertFieldClusterElt(), and updatePFBlockEltWithLinks().

RecHit2BlockEltMap KDTreeLinkerTrackHcal::rechit2ClusterLinks_

private

Definition at line 49 of file KDTreeLinkerTrackHcal.cc.

Referenced by clear(), insertFieldClusterElt(), and searchLinks().

RecHitSet KDTreeLinkerTrackHcal::rechitsSet_

private

Definition at line 43 of file KDTreeLinkerTrackHcal.cc.

Referenced by buildTree(), clear(), and insertFieldClusterElt().

BlockEltSet KDTreeLinkerTrackHcal::targetSet_

private

Definition at line 39 of file KDTreeLinkerTrackHcal.cc.

Referenced by clear(), insertTargetElt(), and searchLinks().

reco::PFTrajectoryPoint::LayerType KDTreeLinkerTrackHcal::trajectoryLayerEntrance_

private

Definition at line 57 of file KDTreeLinkerTrackHcal.cc.

Referenced by insertTargetElt(), KDTreeLinkerTrackHcal(), searchLinks(), and updatePFBlockEltWithLinks().

std::string KDTreeLinkerTrackHcal::trajectoryLayerEntranceString_

private

Definition at line 55 of file KDTreeLinkerTrackHcal.cc.

Referenced by KDTreeLinkerTrackHcal().

reco::PFTrajectoryPoint::LayerType KDTreeLinkerTrackHcal::trajectoryLayerExit_

private

Definition at line 58 of file KDTreeLinkerTrackHcal.cc.

Referenced by KDTreeLinkerTrackHcal(), and searchLinks().

std::string KDTreeLinkerTrackHcal::trajectoryLayerExitString_

private

Definition at line 56 of file KDTreeLinkerTrackHcal.cc.

Referenced by KDTreeLinkerTrackHcal().

KDTreeLinkerAlgo<reco::PFRecHit const*> KDTreeLinkerTrackHcal::tree_

private

Definition at line 52 of file KDTreeLinkerTrackHcal.cc.

Referenced by buildTree(), clear(), and searchLinks().