Inheritance diagram for GeneralTracksImporter:

Public Member Functions
	GeneralTracksImporter (const edm::ParameterSet &conf, edm::ConsumesCollector &cc)

void	importToBlock (const edm::Event &, ElementList &) const override

Public Member Functions inherited from BlockElementImporterBase
	BlockElementImporterBase (const edm::ParameterSet &conf, edm::ConsumesCollector &cc)

	BlockElementImporterBase (const BlockElementImporterBase &)=delete

const std::string &	name () const

BlockElementImporterBase &	operator= (const BlockElementImporterBase &)=delete

virtual void	updateEventSetup (const edm::EventSetup &)

virtual	~BlockElementImporterBase ()=default

Private Attributes
const bool	cleanBadConvBrems_

const std::vector< double >	DPtovPtCut_

const double	muonMaxDPtOPt_

const edm::EDGetTokenT< reco::MuonCollection >	muons_

const std::vector< unsigned >	NHitCut_

const edm::EDGetTokenT< reco::PFRecTrackCollection >	src_

const reco::TrackBase::TrackQuality	trackQuality_

edm::EDGetTokenT< reco::TrackCollection >	tracksSrc_

const bool	useIterTracking_

const bool	vetoEndcap_

unsigned int	vetoMode_

edm::EDGetTokenT< reco::PFCandidateCollection >	vetoPFCandidatesSrc_

edm::EDGetTokenT< reco::PFRecTrackCollection >	vetoPFTracksSrc_

edm::EDGetTokenT< std::vector< TICLSeedingRegion > >	vetoTICLSeedingSrc_

Additional Inherited Members
Public Types inherited from BlockElementImporterBase
typedef std::vector< std::unique_ptr< reco::PFBlockElement > >	ElementList

enum	VetoMode { pfRecTrackCollection = 0, ticlSeedingRegion = 1, pfCandidateCollection = 2 }

Detailed Description

Definition at line 12 of file GeneralTracksImporter.cc.

Constructor & Destructor Documentation

◆ GeneralTracksImporter()

GeneralTracksImporter::GeneralTracksImporter	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &	cc
	)

inline

Definition at line 14 of file GeneralTracksImporter.cc.

References gpuPixelDoublets::cc, edm::ParameterSet::getParameter(), BlockElementImporterBase::pfCandidateCollection, BlockElementImporterBase::pfRecTrackCollection, BlockElementImporterBase::ticlSeedingRegion, tracksSrc_, vetoEndcap_, vetoMode_, vetoPFCandidatesSrc_, vetoPFTracksSrc_, and vetoTICLSeedingSrc_.

       : BlockElementImporterBase(conf, cc),
         src_(cc.consumes<reco::PFRecTrackCollection>(conf.getParameter<edm::InputTag>("source"))),
         vetoEndcap_(conf.getParameter<bool>("vetoEndcap")),
         muons_(cc.consumes<reco::MuonCollection>(conf.getParameter<edm::InputTag>("muonSrc"))),
         trackQuality_(reco::TrackBase::qualityByName(conf.getParameter<std::string>("trackQuality"))),
         DPtovPtCut_(conf.getParameter<std::vector<double>>("DPtOverPtCuts_byTrackAlgo")),
         NHitCut_(conf.getParameter<std::vector<unsigned>>("NHitCuts_byTrackAlgo")),
         useIterTracking_(conf.getParameter<bool>("useIterativeTracking")),
         cleanBadConvBrems_(conf.getParameter<bool>("cleanBadConvertedBrems")),
         muonMaxDPtOPt_(conf.getParameter<double>("muonMaxDPtOPt")) {
     if (vetoEndcap_) {
       vetoMode_ = conf.getParameter<unsigned>("vetoMode");
       switch (vetoMode_) {
         case pfRecTrackCollection:
           vetoPFTracksSrc_ = cc.consumes<reco::PFRecTrackCollection>(conf.getParameter<edm::InputTag>("vetoSrc"));
           break;
         case ticlSeedingRegion:
           vetoTICLSeedingSrc_ =
               cc.consumes<std::vector<TICLSeedingRegion>>(conf.getParameter<edm::InputTag>("vetoSrc"));
           tracksSrc_ = cc.consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("tracksSrc"));
           break;
         case pfCandidateCollection:
           vetoPFCandidatesSrc_ = cc.consumes<reco::PFCandidateCollection>(conf.getParameter<edm::InputTag>("vetoSrc"));
           break;
       }  // switch
     }
   }

Member Function Documentation

◆ importToBlock()

void GeneralTracksImporter::importToBlock	(	const edm::Event &	e,
		BlockElementImporterBase::ElementList &	elems
	)		const

overridevirtual

Implements BlockElementImporterBase.

Definition at line 63 of file GeneralTracksImporter.cc.

References a, cms::cuda::assert(), cleanBadConvBrems_, reco::PFBlockElementTrack::convRefs(), reco::PFBlockElementTrack::displacedVertexRef(), HLT_2023v12_cff::distance, DPtovPtCut_, MillePedeFileConverter_cfg::e, edm::RefVector< C, T, F >::empty(), PFTrackAlgoTools::goodPtResolution(), PFMuonAlgo::hasValidTrack(), edm::Ref< C, T, F >::id(), heavyIonCSV_trainingSettings::idx, PFMuonAlgo::isLooseMuon(), PFMuonAlgo::isMuon(), edm::Ref< C, T, F >::isNull(), edm::Ref< C, T, F >::key(), LogDebug, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, gpuClustering::pixelStatus::mask, PFMuonAlgo::muAssocToTrack(), muonMaxDPtOPt_, PDWG_BPHSkim_cff::muons, muons_, NHitCut_, l1ctLayer1_patternWriters_cff::partition, BlockElementImporterBase::pfCandidateCollection, BlockElementImporterBase::pfRecTrackCollection, reco::PFBlockElementTrack::setMuonRef(), jetUpdater_cfi::sort, src_, reco::PFBlockElement::T_FROM_DISP, reco::PFBlockElement::T_FROM_GAMMACONV, BlockElementImporterBase::ticlSeedingRegion, reco::PFBlockElement::TRACK, HLT_2023v12_cff::track, trackQuality_, reco::PFBlockElementTrack::trackRef(), pwdgSkimBPark_cfi::tracks, tracksSrc_, reco::PFBlockElementTrack::trackType(), useIterTracking_, reco::PFBlockElementTrack::V0Ref(), PbPb_ZMuSkimMuonDPG_cff::veto, vetoEndcap_, vetoMode_, vetoPFCandidatesSrc_, vetoPFTracksSrc_, and vetoTICLSeedingSrc_.

                                                                                                              {
   typedef BlockElementImporterBase::ElementList::value_type ElementType;
   auto tracks = e.getHandle(src_);
 
   typedef std::pair<edm::ProductID, unsigned> TrackProdIDKey;
   std::vector<TrackProdIDKey> vetoed;
   if (vetoEndcap_) {
     switch (vetoMode_) {
       case pfRecTrackCollection: {
         const auto& vetoes = e.get(vetoPFTracksSrc_);
         for (const auto& veto : vetoes)
           vetoed.emplace_back(veto.trackRef().id(), veto.trackRef().key());
         break;
       }
       case ticlSeedingRegion: {
         const auto& vetoes = e.get(vetoTICLSeedingSrc_);
         auto tracksH = e.getHandle(tracksSrc_);
         for (const auto& veto : vetoes) {
           assert(veto.collectionID == tracksH.id());
           reco::TrackRef trkref = reco::TrackRef(tracksH, veto.index);
           vetoed.emplace_back(tracksH.id(), veto.index);  // track prod id and key
         }
         break;
       }
       case pfCandidateCollection: {
         const auto& vetoes = e.get(vetoPFCandidatesSrc_);
         for (const auto& veto : vetoes) {
           if (veto.trackRef().isNull())
             continue;
           vetoed.emplace_back(veto.trackRef().id(), veto.trackRef().key());
         }
         break;
       }
     }  // switch
     std::sort(vetoed.begin(), vetoed.end());
   }
   const auto muonH = e.getHandle(muons_);
   const auto& muons = *muonH;
   elems.reserve(elems.size() + tracks->size());
   std::vector<bool> mask(tracks->size(), true);
   reco::MuonRef muonref;
 
   // remove converted brems with bad pT resolution if requested
   // this reproduces the old behavior of PFBlockAlgo
   if (cleanBadConvBrems_) {
     auto itr = elems.begin();
     while (itr != elems.end()) {
       if ((*itr)->type() == reco::PFBlockElement::TRACK) {
         const reco::PFBlockElementTrack* trkel = static_cast<reco::PFBlockElementTrack*>(itr->get());
         const reco::ConversionRefVector& cRef = trkel->convRefs();
         const reco::PFDisplacedTrackerVertexRef& dvRef = trkel->displacedVertexRef(reco::PFBlockElement::T_FROM_DISP);
         const reco::VertexCompositeCandidateRef& v0Ref = trkel->V0Ref();
         // if there is no displaced vertex reference  and it is marked
         // as a conversion it's gotta be a converted brem
         if (trkel->trackType(reco::PFBlockElement::T_FROM_GAMMACONV) && cRef.empty() && dvRef.isNull() &&
             v0Ref.isNull()) {
           // if the Pt resolution is bad we kill this element
           if (!PFTrackAlgoTools::goodPtResolution(
                   trkel->trackRef(), DPtovPtCut_, NHitCut_, useIterTracking_, trackQuality_)) {
             itr = elems.erase(itr);
             continue;
           }
         }
       }
       ++itr;
     }  // loop on existing elements
   }
   // preprocess existing tracks in the element list and create a mask
   // so that we do not import tracks twice, tag muons we find
   // in this collection
   auto TKs_end = std::partition(
       elems.begin(), elems.end(), [](const ElementType& a) { return a->type() == reco::PFBlockElement::TRACK; });
   auto btk_elems = elems.begin();
   auto btrack = tracks->cbegin();
   auto etrack = tracks->cend();
   for (auto track = btrack; track != etrack; ++track) {
     auto tk_elem =
         std::find_if(btk_elems, TKs_end, [&](const ElementType& a) { return (a->trackRef() == track->trackRef()); });
     if (tk_elem != TKs_end) {
       mask[std::distance(tracks->cbegin(), track)] = false;
       // check and update if this track is a muon
       const int muId = PFMuonAlgo::muAssocToTrack((*tk_elem)->trackRef(), muons);
       if (muId != -1) {
         muonref = reco::MuonRef(muonH, muId);
         if (PFMuonAlgo::isLooseMuon(muonref) || PFMuonAlgo::isMuon(muonref)) {
           static_cast<reco::PFBlockElementTrack*>(tk_elem->get())->setMuonRef(muonref);
         }
       }
     }
   }
   // now we actually insert tracks, again tagging muons along the way
   reco::PFRecTrackRef pftrackref;
   reco::PFBlockElementTrack* trkElem = nullptr;
   for (auto track = btrack; track != etrack; ++track) {
     const unsigned idx = std::distance(btrack, track);
     // since we already set muon refs in the previously imported tracks,
     // here we can skip everything that is already imported
     if (!mask[idx])
       continue;
     muonref = reco::MuonRef();
     pftrackref = reco::PFRecTrackRef(tracks, idx);
     // Get the eventual muon associated to this track
     const int muId = PFMuonAlgo::muAssocToTrack(pftrackref->trackRef(), muons);
     bool thisIsAPotentialMuon = false;
     if (muId != -1) {
       muonref = reco::MuonRef(muonH, muId);
       thisIsAPotentialMuon =
           ((PFMuonAlgo::hasValidTrack(muonref, true, muonMaxDPtOPt_) && PFMuonAlgo::isLooseMuon(muonref)) ||
            (PFMuonAlgo::hasValidTrack(muonref, false, muonMaxDPtOPt_) && PFMuonAlgo::isMuon(muonref)));
     }
     if (thisIsAPotentialMuon || PFTrackAlgoTools::goodPtResolution(
                                     pftrackref->trackRef(), DPtovPtCut_, NHitCut_, useIterTracking_, trackQuality_)) {
       trkElem = new reco::PFBlockElementTrack(pftrackref);
       if (thisIsAPotentialMuon) {
         LogDebug("GeneralTracksImporter")
             << "Potential Muon P " << pftrackref->trackRef()->p() << " pt " << pftrackref->trackRef()->p() << std::endl;
       }
       if (muId != -1)
         trkElem->setMuonRef(muonref);
       //
       // if _vetoEndcap is false, add this trk automatically.
       // if _vetoEndcap is true, veto against the hgcal region tracks or charged PF candidates.
       // when simPF is used, we don't veto tracks with muonref even if they are in the hgcal region.
       //
       if (!vetoEndcap_)
         elems.emplace_back(trkElem);
       else {
         TrackProdIDKey trk = std::make_pair(pftrackref->trackRef().id(), pftrackref->trackRef().key());
         auto lower = std::lower_bound(vetoed.begin(), vetoed.end(), trk);
         bool inVetoList = (lower != vetoed.end() && *lower == trk);
         if (!inVetoList || (vetoMode_ == pfRecTrackCollection && muonref.isNonnull())) {
           elems.emplace_back(trkElem);
         } else
           delete trkElem;
       }
     }
   }
   elems.shrink_to_fit();
 }