#include <PFLinker.h>

Inheritance diagram for PFLinker:

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

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

	~PFLinker ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndex	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndex > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndex > &) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
template<typename T >
bool	fetchCollection (edm::Handle< T > &c, const edm::InputTag &tag, const edm::Event &iEvent) const

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...

edm::InputTag	inputTagGsfElectrons_
	Input GsfElectrons. More...

edm::InputTag	inputTagMuons_
	Input Muons. More...

std::vector< edm::InputTag >	inputTagPFCandidates_
	Input PFCandidates. More...

edm::InputTag	inputTagPhotons_
	Input Photons. 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::EDProducer
typedef EDProducer	ModuleType

typedef WorkerT< EDProducer >	WorkerType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDProducer
CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

Date:: 2013/02/26 16:32:20

Revision:: 1.7

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 31 of file PFLinker.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 14 of file PFLinker.cc.

References fillMuonRefs_, edm::ParameterSet::getParameter(), inputTagGsfElectrons_, inputTagMuons_, inputTagPFCandidates_, inputTagPhotons_, edm::InputTag::label(), nameOutputElectronsPF_, nameOutputMergedPF_, nameOutputPF_, nameOutputPhotonsPF_, producePFCandidates_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                   {
   // vector of InputTag; more than 1 is not for RECO, it is for analysis
   inputTagPFCandidates_ 
     = iConfig.getParameter<std::vector<edm::InputTag> >("PFCandidate");
   inputTagGsfElectrons_
     = iConfig.getParameter<edm::InputTag>("GsfElectrons");
   inputTagPhotons_
     = iConfig.getParameter<edm::InputTag>("Photons");
   inputTagMuons_
     = iConfig.getParameter<edm::InputTag>("Muons");
   
   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");
 
   // 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(0);
   }
   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> > (inputTagMuons_.label());
 
 }

PFLinker::~PFLinker ( )

Definition at line 58 of file PFLinker.cc.

58 {;}

Member Function Documentation

template<typename T >

bool PFLinker::fetchCollection	(	edm::Handle< T > &	c,
		const edm::InputTag &	tag,
		const edm::Event &	iEvent
	)		const

private

Definition at line 219 of file PFLinker.cc.

References newFWLiteAna::found, and edm::Event::getByLabel().

                                                  {  
 
   bool found = iEvent.getByLabel(tag, c);
   
   if(!found )
     {
       std::ostringstream  err;
       err<<" cannot get " <<tag<<std::endl;
       edm::LogError("PFLinker")<<err.str();
     }
   return found;
 }

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 237 of file PFLinker.cc.

References edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), producePFCandidates_, and makeHLTPrescaleTable::values.

                                                                                                         {
   
   std::auto_ptr<edm::ValueMap<reco::PFCandidatePtr> > pfMap_p(new 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(pfMap_p,label);
   return returnValue;
 }

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

overridevirtual

Implements edm::EDProducer.

Definition at line 60 of file PFLinker.cc.

                                                                     {
   
   std::auto_ptr<reco::PFCandidateCollection>
     pfCandidates_p(new reco::PFCandidateCollection);
   
   edm::Handle<reco::GsfElectronCollection> gsfElectrons;
   bool status=fetchCollection<reco::GsfElectronCollection>(gsfElectrons,
                               inputTagGsfElectrons_,
                               iEvent );
   std::map<reco::GsfElectronRef,reco::PFCandidatePtr> electronCandidateMap;  
 
   if(!status) {
     std::ostringstream err;
     err << " Problem in PFLinker: no electron collection called " << inputTagGsfElectrons_ << std::endl;
     edm::LogError("PFLinker") << err.str();
   }
 
 
   edm::Handle<reco::PhotonCollection> photons;
   status=fetchCollection<reco::PhotonCollection>(photons,
                          inputTagPhotons_,
                          iEvent );
   if(!status) {
     std::ostringstream err;
     err << " Problem in PFLinker: no photon collection called " << inputTagPhotons_ << std::endl;
     edm::LogError("PFLinker") << err.str();
   }
 
 
   std::map<reco::PhotonRef,reco::PFCandidatePtr> photonCandidateMap;
 
 
   edm::Handle<reco::MuonToMuonMap> muonMap;
   if(fillMuonRefs_)
     status=fetchCollection<reco::MuonToMuonMap>(muonMap,
                         inputTagMuons_,
                         iEvent);
   std::map<reco::MuonRef,reco::PFCandidatePtr> muonCandidateMap;
   
   unsigned nColPF=inputTagPFCandidates_.size();
   
   if(!status) {
     std::ostringstream err;
     err << " Problem in PFLinker: no muon collection called " << inputTagMuons_ << std::endl;
     edm::LogError("PFLinker") << err.str();
   }
 
   
   edm::Handle<reco::PFCandidateCollection> pfCandidates;
   for(unsigned icol=0;icol<nColPF;++icol) {
     
     bool status=fetchCollection<reco::PFCandidateCollection>(pfCandidates, 
                                  inputTagPFCandidates_[icol], 
                                  iEvent );
     
     unsigned ncand=(status)?pfCandidates->size():0;
     
     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());
     GsfElectronEqual myEqual(gsfTrackRef);
     std::vector<reco::GsfElectron>::const_iterator itcheck=find_if(gsfElectrons->begin(),gsfElectrons->end(),myEqual);
     if(itcheck==gsfElectrons->end()) {
       std::ostringstream err;
       err << " Problem in PFLinker: no GsfElectron " << std::endl;
       edm::LogError("PFLinker") << err.str();
       continue; // Watch out ! Continue
     } 
     reco::GsfElectronRef electronRef(gsfElectrons,itcheck-gsfElectrons->begin());
     cand.setGsfElectronRef(electronRef);
     cand.setSuperClusterRef(electronRef->superCluster());
     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());
     PhotonEqual myEqual(scRef);
     std::vector<reco::Photon>::const_iterator itcheck=find_if(photons->begin(),photons->end(),myEqual);
     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());
     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(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_){
     edm::Handle<reco::MuonCollection> muons; 
     iEvent.getByLabel(inputTagMuons_.label(), muons);
     
     pfMapMuons = fillValueMap<reco::MuonCollection>(iEvent, 
                             inputTagMuons_.label(), 
                             muons, 
                             muonCandidateMap,
                             pfCandidateRefProd);
   }
   
   std::auto_ptr<edm::ValueMap<reco::PFCandidatePtr> > 
     pfMapMerged(new edm::ValueMap<reco::PFCandidatePtr>());
   edm::ValueMap<reco::PFCandidatePtr>::Filler pfMapMergedFiller(*pfMapMerged);
   
   *pfMapMerged                   += pfMapGsfElectrons;
   *pfMapMerged                   += pfMapPhotons;
   if(fillMuonRefs_) *pfMapMerged += pfMapMuons;
   
   iEvent.put(pfMapMerged,nameOutputMergedPF_);
 }

Member Data Documentation

bool PFLinker::fillMuonRefs_

private

Set muon refs and produce the value map?

Definition at line 84 of file PFLinker.h.

Referenced by PFLinker(), and produce().

edm::InputTag PFLinker::inputTagGsfElectrons_

private

Input GsfElectrons.

Definition at line 60 of file PFLinker.h.

Referenced by PFLinker(), and produce().

edm::InputTag PFLinker::inputTagMuons_

private

Input Muons.

Definition at line 66 of file PFLinker.h.

Referenced by PFLinker(), and produce().

std::vector<edm::InputTag> PFLinker::inputTagPFCandidates_

private

Input PFCandidates.

Definition at line 57 of file PFLinker.h.

Referenced by PFLinker(), and produce().

edm::InputTag PFLinker::inputTagPhotons_

private

Input Photons.

Definition at line 63 of file PFLinker.h.

Referenced by PFLinker(), and produce().

std::string PFLinker::nameOutputElectronsPF_

private

name of output ValueMap electrons

Definition at line 72 of file PFLinker.h.

Referenced by PFLinker(), and produce().

std::string PFLinker::nameOutputMergedPF_

private

name of output merged ValueMap

Definition at line 78 of file PFLinker.h.

Referenced by PFLinker(), and produce().

std::string PFLinker::nameOutputPF_

private

name of output collection of PFCandidate

Definition at line 69 of file PFLinker.h.

Referenced by PFLinker(), and produce().

std::string PFLinker::nameOutputPhotonsPF_

private

name of output ValueMap photons

Definition at line 75 of file PFLinker.h.

Referenced by PFLinker(), and produce().

bool PFLinker::producePFCandidates_

private

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

Definition at line 81 of file PFLinker.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation