Inheritance diagram for PFMatchedCandidateRefExtractor:

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

virtual void	produce (edm::StreamID iID, edm::Event &iEvent, const edm::EventSetup &iSetup) const override

virtual	~PFMatchedCandidateRefExtractor ()

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

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Attributes
edm::EDGetTokenT< edm::View< reco::Candidate > >	col1Token_

edm::EDGetTokenT< edm::View< reco::Candidate > >	col2Token_

bool	extractPFCands_

std::string	moduleLabel_

edm::EDGetTokenT< edm::View< reco::PFCandidate > >	pfCandToken_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Definition at line 15 of file PFMatchedCandidateRefExtractor.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 35 of file PFMatchedCandidateRefExtractor.cc.

References extractPFCands_, edm::ParameterSet::getParameter(), and pfCandToken_.

                                                                                              :
   col1Token_(consumes<edm::View<reco::Candidate> >( iConfig.getParameter<edm::InputTag>("col1") )),
   col2Token_(consumes<edm::View<reco::Candidate> >( iConfig.getParameter<edm::InputTag>("col2") )),
   moduleLabel_(iConfig.getParameter<std::string>("@module_label"))
 {
   //register products
   
   extractPFCands_=iConfig.getParameter<bool>("extractPFCandidates");
 
   produces<edm::PtrVector<reco::Candidate> >("col1");
   produces<edm::PtrVector<reco::Candidate> >("col2");
   if(extractPFCands_) {
     pfCandToken_=mayConsume<edm::View<reco::PFCandidate> >( iConfig.getParameter<edm::InputTag>("pfCandCollection") );
     produces<edm::PtrVector<reco::PFCandidate> >("pfCandCol1");
     produces<edm::PtrVector<reco::PFCandidate> >("pfCandCol2");
   }  
 
 }

PFMatchedCandidateRefExtractor::~PFMatchedCandidateRefExtractor ( )

virtual

Definition at line 55 of file PFMatchedCandidateRefExtractor.cc.

55 {

56 }

Member Function Documentation

void PFMatchedCandidateRefExtractor::produce	(	edm::StreamID	iID,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

overridevirtual

Definition at line 61 of file PFMatchedCandidateRefExtractor.cc.

References EnergyCorrector::c, col1Token_, col2Token_, DEFINE_FWK_MODULE, reco::deltaR2(), extractPFCands_, edm::Event::getByToken(), electronMatch_cfi::matched, eostools::move(), pfCandToken_, and edm::Event::put().

 {  
 
 
   std::unique_ptr<edm::PtrVector<reco::Candidate> > outcol1(new edm::PtrVector<reco::Candidate>());
   std::unique_ptr<edm::PtrVector<reco::Candidate> > outcol2(new edm::PtrVector<reco::Candidate>());
   
   std::unique_ptr<edm::PtrVector<reco::PFCandidate> > outPFCandCol1(new edm::PtrVector<reco::PFCandidate>());
   std::unique_ptr<edm::PtrVector<reco::PFCandidate> > outPFCandCol2(new edm::PtrVector<reco::PFCandidate>());
 
   edm::Handle< edm::View<reco::Candidate> > col1Handle;
   edm::Handle< edm::View<reco::Candidate> > col2Handle;
   edm::Handle< edm::View<reco::PFCandidate> > pfCandHandle;
 
   iEvent.getByToken( col1Token_, col1Handle );
   iEvent.getByToken( col2Token_, col2Handle ); 
    if(extractPFCands_) {
      iEvent.getByToken( pfCandToken_, pfCandHandle ); 
    }
 
   for(size_t iC1=0;iC1<col1Handle->size();iC1++) {
     for(size_t iC2=0;iC2<col2Handle->size();iC2++) {
       
       bool matched=(col1Handle->ptrAt(iC1)==col2Handle->ptrAt(iC2));
       if(!matched &&
      deltaR2(col1Handle->ptrAt(iC1)->p4(), col2Handle->ptrAt(iC2)->p4() )< 0.000001) {
     matched=true;
       }
    
       if(matched) {
     outcol1->push_back( col1Handle->ptrAt(iC1) );
     outcol2->push_back( col2Handle->ptrAt(iC2) );
     
     if(!extractPFCands_) continue;
     std::set<reco::CandidatePtr> sc1s;
     std::set<reco::CandidatePtr> sc2s;
     for(size_t ics1=0;ics1<col1Handle->ptrAt(iC1)->numberOfSourceCandidatePtrs();
         ics1++ ) {
       sc1s.insert( col1Handle->ptrAt(iC1)->sourceCandidatePtr(ics1));
     }
     for(size_t ics2=0;ics2<col2Handle->ptrAt(iC2)->numberOfSourceCandidatePtrs();
         ics2++ ) {
       sc2s.insert( col2Handle->ptrAt(iC2)->sourceCandidatePtr(ics2));
     }
 
     for(size_t ic=0;ic<pfCandHandle->size(); ++ic) {
       reco::PFCandidatePtr c = pfCandHandle->ptrAt(ic);
 
       bool match1=(sc1s.find(c)!=sc1s.end());
       bool match2=(sc2s.find(c)!=sc2s.end());
       
       if(!match1) {//recovery when pfcandidate sources are not equivalent
         for(size_t ics1=0;ics1<sc1s.size();ics1++) {
           if(deltaR2(c->p4(), 
          col1Handle->ptrAt(iC1)->sourceCandidatePtr(ics1)->p4())<0.0000001) { //tight dR, pfcandidates should be the same
         match1=true;
         break;
           }
         }
       }
       if(!match2) {//recovery when pfcandidate sources are not equivalent
         for(size_t ics2=0;ics2<sc2s.size();ics2++) {
           if(deltaR2(c->p4(), 
          col2Handle->ptrAt(iC2)->sourceCandidatePtr(ics2)->p4())<0.00001) { //tight dR
         match2=true;
         break;
           }
         }
       }
 
       if(match1) {
         outPFCandCol1->push_back(c);
       }
       if(match2) {
         outPFCandCol2->push_back(c);
       }
     } //pfcand loop
     
       } //matching
     } //col2
   } //col1
 
   iEvent.put(std::move(outcol1),"col1");
   iEvent.put(std::move(outcol2),"col2");
   if(extractPFCands_) {
     iEvent.put(std::move(outPFCandCol1),"pfCandCol1");
     iEvent.put(std::move(outPFCandCol2),"pfCandCol2");
   }
 
 }