Inheritance diagram for PFLinker:

Public Member Functions
	PFLinker (const edm::ParameterSet &)

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

	~PFLinker () 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 &descriptions)

Private Member Functions
template<typename TYPE >
edm::ValueMap< reco::PFCandidatePtr >	fillValueMap (edm::Event &event, std::string label, edm::Handle< TYPE > &inputObjCollection, const std::map< edm::Ref< TYPE >, reco::PFCandidatePtr > &mapToTheCandidate, const edm::OrphanHandle< reco::PFCandidateCollection > &newPFCandColl) const

Private Attributes
bool	fillMuonRefs_
	Set muon refs and produce the value map? More...

bool	forceElectronsInHGCAL_
	Put Electrons within HGCAL coming from SimPFProducer. More...

edm::EDGetTokenT< reco::GsfElectronCollection >	inputTagGsfElectrons_
	Input GsfElectrons. More...

edm::EDGetTokenT< reco::MuonToMuonMap >	inputTagMuonMap_

edm::EDGetTokenT< reco::MuonCollection >	inputTagMuons_

std::vector< edm::EDGetTokenT< reco::PFCandidateCollection > >	inputTagPFCandidates_
	Input PFCandidates. More...

edm::EDGetTokenT< reco::PhotonCollection >	inputTagPhotons_
	Input Photons. More...

edm::InputTag	muonTag_
	Input Muons. More...

std::string	nameOutputElectronsPF_
	name of output ValueMap electrons More...

std::string	nameOutputMergedPF_
	name of output merged ValueMap More...

std::string	nameOutputPF_
	name of output collection of PFCandidate More...

std::string	nameOutputPhotonsPF_
	name of output ValueMap photons More...

bool	producePFCandidates_
	Flags - if true: References will be towards new collection ; if false to the original one. More...

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

Producer meant for the Post PF reconstruction.

Fills the GsfElectron, Photon and Muon Ref into the PFCandidate Produces the ValueMap between GsfElectronRef/Photon/Mupns with PFCandidateRef

Author: R. Bellan - UCSB ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch, F. Beaudette - CERN Flori.nosp@m.an.B.nosp@m.eaude.nosp@m.tte@.nosp@m.cern..nosp@m.ch

Definition at line 25 of file PFLinker.cc.

Constructor & Destructor Documentation

◆ PFLinker()

PFLinker::PFLinker ( const edm::ParameterSet & iConfig )

explicit

Definition at line 97 of file PFLinker.cc.

References cms::cuda::assert(), fillMuonRefs_, forceElectronsInHGCAL_, edm::ParameterSet::getParameter(), mps_fire::i, ProducerED_cfi::InputTag, inputTagGsfElectrons_, inputTagMuonMap_, inputTagMuons_, inputTagPFCandidates_, inputTagPhotons_, edm::InputTag::label(), muonTag_, nameOutputElectronsPF_, nameOutputMergedPF_, nameOutputPF_, nameOutputPhotonsPF_, producePFCandidates_, AlCaHLTBitMon_QueryRunRegistry::string, and triggerMatcherToHLTDebug_cfi::tags.

                                                  {
   // vector of InputTag; more than 1 is not for RECO, it is for analysis
 
   std::vector<edm::InputTag> tags = iConfig.getParameter<std::vector<edm::InputTag>>("PFCandidate");
   for (unsigned int i = 0; i < tags.size(); ++i)
     inputTagPFCandidates_.push_back(consumes<reco::PFCandidateCollection>(tags[i]));
 
   inputTagGsfElectrons_ = consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("GsfElectrons"));
 
   inputTagPhotons_ = consumes<reco::PhotonCollection>(iConfig.getParameter<edm::InputTag>("Photons"));
 
   muonTag_ = iConfig.getParameter<edm::InputTag>("Muons");
   inputTagMuons_ = consumes<reco::MuonCollection>(edm::InputTag(muonTag_.label()));
   inputTagMuonMap_ = consumes<reco::MuonToMuonMap>(muonTag_);
 
   nameOutputPF_ = iConfig.getParameter<std::string>("OutputPF");
 
   nameOutputElectronsPF_ = iConfig.getParameter<std::string>("ValueMapElectrons");
 
   nameOutputPhotonsPF_ = iConfig.getParameter<std::string>("ValueMapPhotons");
 
   producePFCandidates_ = iConfig.getParameter<bool>("ProducePFCandidates");
 
   nameOutputMergedPF_ = iConfig.getParameter<std::string>("ValueMapMerged");
 
   fillMuonRefs_ = iConfig.getParameter<bool>("FillMuonRefs");
 
   forceElectronsInHGCAL_ = iConfig.getParameter<bool>("forceElectronsInHGCAL");
 
   // should not produce PFCandidates and read seve
   if (producePFCandidates_ && inputTagPFCandidates_.size() > 1) {
     edm::LogError("PFLinker")
         << " cannot read several collections of PFCandidates and produce a new collection at the same time. "
         << std::endl;
     assert(false);
   }
   if (producePFCandidates_) {
     produces<reco::PFCandidateCollection>(nameOutputPF_);
   }
   produces<edm::ValueMap<reco::PFCandidatePtr>>(nameOutputElectronsPF_);
   produces<edm::ValueMap<reco::PFCandidatePtr>>(nameOutputPhotonsPF_);
   produces<edm::ValueMap<reco::PFCandidatePtr>>(nameOutputMergedPF_);
   if (fillMuonRefs_)
     produces<edm::ValueMap<reco::PFCandidatePtr>>(muonTag_.label());
 }

◆ ~PFLinker()

PFLinker::~PFLinker ( )

override

Definition at line 143 of file PFLinker.cc.

143 { ; }

Member Function Documentation

◆ fillDescriptions()

void PFLinker::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 81 of file PFLinker.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
   edm::ParameterSetDescription desc;
   desc.add<std::vector<edm::InputTag>>("PFCandidate", {edm::InputTag("particleFlow")});
   desc.add<edm::InputTag>("GsfElectrons", {"gedGsfElectrons"});
   desc.add<edm::InputTag>("Photons", {"gedPhotons"});
   desc.add<edm::InputTag>("Muons", {"muons", "muons1stStep2muonsMap"});
   desc.add<bool>("ProducePFCandidates", true);
   desc.add<bool>("FillMuonRefs", true);
   desc.add<std::string>("OutputPF", "");
   desc.add<std::string>("ValueMapElectrons", "electrons");
   desc.add<std::string>("ValueMapPhotons", "photons");
   desc.add<std::string>("ValueMapMerged", "all");
   desc.add<bool>("forceElectronsInHGCAL", false);
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillValueMap()

template<typename TYPE >

edm::ValueMap< reco::PFCandidatePtr > PFLinker::fillValueMap	(	edm::Event &	event,
		std::string	label,
		edm::Handle< TYPE > &	inputObjCollection,
		const std::map< edm::Ref< TYPE >, reco::PFCandidatePtr > &	mapToTheCandidate,
		const edm::OrphanHandle< reco::PFCandidateCollection > &	newPFCandColl
	)		const

private

Definition at line 273 of file PFLinker.cc.

References trigObjTnPSource_cfi::filler, label, eostools::move(), producePFCandidates_, and contentValuesCheck::values.

                                                                            {
   auto pfMap_p = std::make_unique<edm::ValueMap<reco::PFCandidatePtr>>();
   edm::ValueMap<reco::PFCandidatePtr>::Filler filler(*pfMap_p);
 
   typedef typename std::map<edm::Ref<TYPE>, reco::PFCandidatePtr>::const_iterator MapTYPE_it;
 
   unsigned nObj = inputObjCollection->size();
   std::vector<reco::PFCandidatePtr> values(nObj);
 
   for (unsigned iobj = 0; iobj < nObj; ++iobj) {
     edm::Ref<TYPE> objRef(inputObjCollection, iobj);
     MapTYPE_it itcheck = mapToTheCandidate.find(objRef);
 
     reco::PFCandidatePtr candPtr;
 
     if (itcheck != mapToTheCandidate.end())
       candPtr = producePFCandidates_ ? reco::PFCandidatePtr(newPFCandColl, itcheck->second.key()) : itcheck->second;
 
     values[iobj] = candPtr;
   }
 
   filler.insert(inputObjCollection, values.begin(), values.end());
   filler.fill();
   edm::ValueMap<reco::PFCandidatePtr> returnValue = *pfMap_p;
   event.put(std::move(pfMap_p), label);
   return returnValue;
 }

◆ produce()

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

override

Definition at line 145 of file PFLinker.cc.

References reco::PFCandidate::e, submitPVResolutionJobs::err, fillMuonRefs_, forceElectronsInHGCAL_, reco::PFCandidate::gamma, electronIsolatorFromEffectiveArea_cfi::gsfElectrons, mps_fire::i, iEvent, inputTagGsfElectrons_, inputTagMuonMap_, inputTagMuons_, inputTagPFCandidates_, inputTagPhotons_, edm::InputTag::label(), LogDebug, eostools::move(), DiMuonV_cfg::muons, muonTag_, nameOutputElectronsPF_, nameOutputMergedPF_, nameOutputPF_, nameOutputPhotonsPF_, reco::GsfElectron::P4_COMBINATION, zmumugammaAnalyzer_cfi::pfCandidates, displacedMuons_cfi::photon, BPHMonitor_cfi::photons, producePFCandidates_, and reco::Photon::regression2.

                                                                     {
   auto pfCandidates_p = std::make_unique<reco::PFCandidateCollection>();
 
   auto gsfElectrons = iEvent.getHandle(inputTagGsfElectrons_);
 
   std::map<reco::GsfElectronRef, reco::PFCandidatePtr> electronCandidateMap;
 
   auto photons = iEvent.getHandle(inputTagPhotons_);
   std::map<reco::PhotonRef, reco::PFCandidatePtr> photonCandidateMap;
 
   edm::Handle<reco::MuonToMuonMap> muonMap;
   if (fillMuonRefs_)
     muonMap = iEvent.getHandle(inputTagMuonMap_);
   std::map<reco::MuonRef, reco::PFCandidatePtr> muonCandidateMap;
 
   unsigned nColPF = inputTagPFCandidates_.size();
 
   for (unsigned icol = 0; icol < nColPF; ++icol) {
     auto pfCandidates = iEvent.getHandle(inputTagPFCandidates_[icol]);
     unsigned ncand = pfCandidates->size();
 
     for (unsigned i = 0; i < ncand; ++i) {
       edm::Ptr<reco::PFCandidate> candPtr(pfCandidates, i);
       reco::PFCandidate cand(candPtr);
 
       bool isphoton = cand.particleId() == reco::PFCandidate::gamma && cand.mva_nothing_gamma() > 0.;
       bool iselectron = cand.particleId() == reco::PFCandidate::e;
       // PFCandidates may have a valid MuonRef though they are not muons.
       bool hasNonNullMuonRef = cand.muonRef().isNonnull() && fillMuonRefs_;
 
       // if not an electron or a photon or a muon just fill the PFCandidate collection
       if (!(isphoton || iselectron || hasNonNullMuonRef)) {
         pfCandidates_p->push_back(cand);
         continue;
       }
 
       if (hasNonNullMuonRef) {
         reco::MuonRef muRef = (*muonMap)[cand.muonRef()];
         cand.setMuonRef(muRef);
         muonCandidateMap[muRef] = candPtr;
       }
 
       // if it is an electron. Find the GsfElectron with the same GsfTrack
       if (iselectron) {
         const reco::GsfTrackRef& gsfTrackRef(cand.gsfTrackRef());
         auto itcheck = find_if(gsfElectrons->begin(), gsfElectrons->end(), [&gsfTrackRef](const auto& ele) {
           return (ele.gsfTrack() == gsfTrackRef);
         });
         if (itcheck == gsfElectrons->end()) {
           if (!forceElectronsInHGCAL_) {
             std::ostringstream err;
             err << " Problem in PFLinker: no GsfElectron " << std::endl;
             edm::LogError("PFLinker") << err.str();
           } else {
             LogDebug("PFLinker") << "Forcing an electron pfCandidate at: " << cand.eta() << " in HGCAL" << std::endl;
             pfCandidates_p->push_back(cand);
           }
           continue;  // Watch out ! Continue
         }
         reco::GsfElectronRef electronRef(gsfElectrons, itcheck - gsfElectrons->begin());
         cand.setGsfElectronRef(electronRef);
         cand.setSuperClusterRef(electronRef->superCluster());
         // update energy information since now it is done post-particleFlowTmp
         cand.setEcalEnergy(electronRef->superCluster()->rawEnergy(), electronRef->ecalEnergy());
         cand.setDeltaP(electronRef->p4Error(reco::GsfElectron::P4_COMBINATION));
         cand.setP4(electronRef->p4(reco::GsfElectron::P4_COMBINATION));
         electronCandidateMap[electronRef] = candPtr;
       }
 
       // if it is a photon, find the one with the same PF super-cluster
       if (isphoton) {
         const reco::SuperClusterRef& scRef(cand.superClusterRef());
         auto itcheck = find_if(
             photons->begin(), photons->end(), [&scRef](const auto& photon) { return photon.superCluster() == scRef; });
         if (itcheck == photons->end()) {
           std::ostringstream err;
           err << " Problem in PFLinker: no Photon " << std::endl;
           edm::LogError("PFLinker") << err.str();
           continue;  // Watch out ! Continue
         }
         reco::PhotonRef photonRef(photons, itcheck - photons->begin());
         cand.setPhotonRef(photonRef);
         cand.setSuperClusterRef(photonRef->superCluster());
         // update energy information since now it is done post-particleFlowTmp
         cand.setEcalEnergy(photonRef->superCluster()->rawEnergy(),
                            photonRef->getCorrectedEnergy(reco::Photon::regression2));
         cand.setDeltaP(photonRef->getCorrectedEnergyError(reco::Photon::regression2));
         cand.setP4(photonRef->p4(reco::Photon::regression2));
         photonCandidateMap[photonRef] = candPtr;
       }
 
       pfCandidates_p->push_back(cand);
     }
     // save the PFCandidates and get a valid handle
   }
   const edm::OrphanHandle<reco::PFCandidateCollection> pfCandidateRefProd =
       (producePFCandidates_) ? iEvent.put(std::move(pfCandidates_p), nameOutputPF_)
                              : edm::OrphanHandle<reco::PFCandidateCollection>();
 
   // now make the valuemaps
 
   edm::ValueMap<reco::PFCandidatePtr> pfMapGsfElectrons = fillValueMap<reco::GsfElectronCollection>(
       iEvent, nameOutputElectronsPF_, gsfElectrons, electronCandidateMap, pfCandidateRefProd);
 
   edm::ValueMap<reco::PFCandidatePtr> pfMapPhotons = fillValueMap<reco::PhotonCollection>(
       iEvent, nameOutputPhotonsPF_, photons, photonCandidateMap, pfCandidateRefProd);
 
   edm::ValueMap<reco::PFCandidatePtr> pfMapMuons;
 
   if (fillMuonRefs_) {
     auto muons = iEvent.getHandle(inputTagMuons_);
 
     pfMapMuons =
         fillValueMap<reco::MuonCollection>(iEvent, muonTag_.label(), muons, muonCandidateMap, pfCandidateRefProd);
   }
 
   auto pfMapMerged = std::make_unique<edm::ValueMap<reco::PFCandidatePtr>>();
   edm::ValueMap<reco::PFCandidatePtr>::Filler pfMapMergedFiller(*pfMapMerged);
 
   *pfMapMerged += pfMapGsfElectrons;
   *pfMapMerged += pfMapPhotons;
   if (fillMuonRefs_)
     *pfMapMerged += pfMapMuons;
 
   iEvent.put(std::move(pfMapMerged), nameOutputMergedPF_);
 }

Member Data Documentation

◆ fillMuonRefs_

bool PFLinker::fillMuonRefs_

private

Set muon refs and produce the value map?

Definition at line 73 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ forceElectronsInHGCAL_

bool PFLinker::forceElectronsInHGCAL_

private

Put Electrons within HGCAL coming from SimPFProducer.

Definition at line 76 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ inputTagGsfElectrons_

edm::EDGetTokenT<reco::GsfElectronCollection> PFLinker::inputTagGsfElectrons_

private

Input GsfElectrons.

Definition at line 48 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ inputTagMuonMap_

edm::EDGetTokenT<reco::MuonToMuonMap> PFLinker::inputTagMuonMap_

private

Definition at line 56 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ inputTagMuons_

edm::EDGetTokenT<reco::MuonCollection> PFLinker::inputTagMuons_

private

Definition at line 55 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ inputTagPFCandidates_

std::vector<edm::EDGetTokenT<reco::PFCandidateCollection> > PFLinker::inputTagPFCandidates_

private

Input PFCandidates.

Definition at line 45 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ inputTagPhotons_

edm::EDGetTokenT<reco::PhotonCollection> PFLinker::inputTagPhotons_

private

Input Photons.

Definition at line 51 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ muonTag_

edm::InputTag PFLinker::muonTag_

private

Input Muons.

Definition at line 54 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ nameOutputElectronsPF_

std::string PFLinker::nameOutputElectronsPF_

private

name of output ValueMap electrons

Definition at line 61 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ nameOutputMergedPF_

std::string PFLinker::nameOutputMergedPF_

private

name of output merged ValueMap

Definition at line 67 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ nameOutputPF_

std::string PFLinker::nameOutputPF_

private

name of output collection of PFCandidate

Definition at line 58 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ nameOutputPhotonsPF_

std::string PFLinker::nameOutputPhotonsPF_

private

name of output ValueMap photons

Definition at line 64 of file PFLinker.cc.

Referenced by PFLinker(), and produce().

◆ producePFCandidates_

bool PFLinker::producePFCandidates_

private

Flags - if true: References will be towards new collection ; if false to the original one.

Definition at line 70 of file PFLinker.cc.

Referenced by fillValueMap(), PFLinker(), and produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PFLinker()

◆ ~PFLinker()

Member Function Documentation

◆ fillDescriptions()

◆ fillValueMap()

◆ produce()

Member Data Documentation

◆ fillMuonRefs_

◆ forceElectronsInHGCAL_

◆ inputTagGsfElectrons_

◆ inputTagMuonMap_

◆ inputTagMuons_

◆ inputTagPFCandidates_

◆ inputTagPhotons_

◆ muonTag_

◆ nameOutputElectronsPF_

◆ nameOutputMergedPF_

◆ nameOutputPF_

◆ nameOutputPhotonsPF_

◆ producePFCandidates_