Inheritance diagram for pat::PackedCandidateTrackChi2Producer:

Public Member Functions
	PackedCandidateTrackChi2Producer (const edm::ParameterSet &iConfig)

void	produce (edm::Event &, const edm::EventSetup &) override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)

Private Types
typedef edm::ValueMap< float >	FloatMap

Private Attributes
edm::EDGetTokenT< edm::Association< reco::PFCandidateCollection > >	candidate2PFToken_

const edm::EDGetTokenT< pat::PackedCandidateCollection >	candidateToken_

const bool	doLostTracks_

edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > >	track2LostTrackToken_

const edm::EDGetTokenT< reco::TrackCollection >	trackToken_

Static Private Attributes
static const uint8_t	roundingPrecision = 8

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Definition at line 14 of file PackedCandidateTrackChi2Producer.cc.

Member Typedef Documentation

◆ FloatMap

typedef edm::ValueMap<float> pat::PackedCandidateTrackChi2Producer::FloatMap

private

Definition at line 15 of file PackedCandidateTrackChi2Producer.cc.

Constructor & Destructor Documentation

◆ PackedCandidateTrackChi2Producer()

pat::PackedCandidateTrackChi2Producer::PackedCandidateTrackChi2Producer ( const edm::ParameterSet & iConfig )

inlineexplicit

Definition at line 18 of file PackedCandidateTrackChi2Producer.cc.

         : candidateToken_(consumes<pat::PackedCandidateCollection>(iConfig.getParameter<edm::InputTag>("candidates"))),
           trackToken_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("trackCollection"))),
           doLostTracks_(iConfig.getParameter<bool>("doLostTracks")) {
       if (doLostTracks_) {
         track2LostTrackToken_ = consumes<edm::Association<pat::PackedCandidateCollection>>(
             iConfig.getParameter<edm::InputTag>("candidates"));
       } else {
         candidate2PFToken_ =
             consumes<edm::Association<reco::PFCandidateCollection>>(iConfig.getParameter<edm::InputTag>("candidates"));
       }
  
       produces<FloatMap>();
     }

References candidate2PFToken_, doLostTracks_, edm::ParameterSet::getParameter(), and track2LostTrackToken_.

Member Function Documentation

◆ fillDescriptions()

void pat::PackedCandidateTrackChi2Producer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 102 of file PackedCandidateTrackChi2Producer.cc.

                                                                                                      {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("candidates", edm::InputTag("packedPFCandidates"))
       ->setComment("packed candidate input collection");
   desc.add<edm::InputTag>("trackCollection", edm::InputTag("generalTracks"))->setComment("track input collection");
   desc.add<bool>("doLostTracks", false);
   descriptions.add("packedPFCandidateTrackChi2", desc);
 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

◆ produce()

void pat::PackedCandidateTrackChi2Producer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

override

Definition at line 48 of file PackedCandidateTrackChi2Producer.cc.

                                                                                                {
   auto const candidates = iEvent.getHandle(candidateToken_);
  
   const edm::Association<reco::PFCandidateCollection>* candidate2PF = nullptr;
   if (!doLostTracks_) {
     candidate2PF = &iEvent.get(candidate2PFToken_);
   }
  
   const edm::Association<pat::PackedCandidateCollection>* tracks2LT = nullptr;
   edm::Handle<reco::TrackCollection> trks;
   if (doLostTracks_) {
     tracks2LT = &iEvent.get(track2LostTrackToken_);
     iEvent.getByToken(trackToken_, trks);
   }
  
   const auto nCand = candidates->size();
   std::vector<float> trkChi2Map(nCand, 0);
  
   if (doLostTracks_) {  //for Lost tracks we don't have references to PFCands, so we must loop over tracks and check keys...
     for (size_t i = 0; i < trks->size(); i++) {
       const auto& trk = reco::TrackRef(trks, i);
       const auto& lostTrack = (*tracks2LT)[trk];
       if (lostTrack.isNonnull()) {
         const float nChi2 = trk->normalizedChi2();
         trkChi2Map.at(lostTrack.key()) = MiniFloatConverter::reduceMantissaToNbitsRounding<roundingPrecision>(nChi2);
       }
     }
   } else {  //for the regular PackedPFCands we have direct references...
     for (size_t i = 0; i < nCand; i++) {
       const auto& cand = pat::PackedCandidateRef(candidates, i);
  
       // ignore neutral candidates or without track
       if (cand->charge() == 0 || !cand->hasTrackDetails())
         continue;
  
       const auto& candTrack = (*candidate2PF)[cand]->trackRef();
  
       if (candTrack.isNonnull()) {
         const float nChi2 = candTrack->normalizedChi2();
  
         trkChi2Map.at(i) = MiniFloatConverter::reduceMantissaToNbitsRounding<roundingPrecision>(nChi2);
       }
     }
   }
  
   // fill the value maps
   std::unique_ptr<FloatMap> valueMap = std::make_unique<FloatMap>();
   FloatMap::Filler filler(*valueMap);
   filler.insert(candidates, trkChi2Map.begin(), trkChi2Map.end());
   filler.fill();
   iEvent.put(std::move(valueMap), "");
 }