#include <HLTrigger/Egamma/src/HLTScoutingEgammaProducer.cc>

Inheritance diagram for HLTScoutingEgammaProducer:

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

	~HLTScoutingEgammaProducer ()

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)

	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
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
typedef edm::AssociationMap < edm::OneToValue< std::vector < reco::RecoEcalCandidate > , float, unsigned int > >	RecoEcalCandMap

Private Member Functions
virtual void	produce (edm::StreamID sid, edm::Event &iEvent, edm::EventSetup const &setup) const overridefinal

Private Attributes
const edm::EDGetTokenT < RecoEcalCandMap >	DetaMap_

const edm::EDGetTokenT < RecoEcalCandMap >	DphiMap_

const edm::EDGetTokenT < RecoEcalCandMap >	EcalPFClusterIsoMap_

const edm::EDGetTokenT < reco::RecoEcalCandidateCollection >	EgammaCandidateCollection_

const double	egammaEtaCut

const edm::EDGetTokenT < reco::GsfTrackCollection >	EgammaGsfTrackCollection_

const double	egammaHoverECut

const double	egammaPtCut

const edm::EDGetTokenT < RecoEcalCandMap >	EleGsfTrackIsoMap_

const edm::EDGetTokenT < RecoEcalCandMap >	HcalPFClusterIsoMap_

const edm::EDGetTokenT < RecoEcalCandMap >	HoverEMap_

const edm::EDGetTokenT < RecoEcalCandMap >	MissingHitsMap_

const edm::EDGetTokenT < RecoEcalCandMap >	OneOEMinusOneOPMap_

const edm::EDGetTokenT < RecoEcalCandMap >	SigmaIEtaIEtaMap_

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

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

Description: Producer for ScoutingElectron and ScoutingPhoton

Definition at line 44 of file HLTScoutingEgammaProducer.h.

Member Typedef Documentation

typedef edm::AssociationMap<edm::OneToValue<std::vector<reco::RecoEcalCandidate>, float, unsigned int> > HLTScoutingEgammaProducer::RecoEcalCandMap

private

Definition at line 46 of file HLTScoutingEgammaProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 22 of file HLTScoutingEgammaProducer.cc.

                                                                                   :
     EgammaCandidateCollection_(consumes<reco::RecoEcalCandidateCollection>
                                (iConfig.getParameter<edm::InputTag>("EgammaCandidates"))),
     EgammaGsfTrackCollection_(consumes<reco::GsfTrackCollection>
                               (iConfig.getParameter<edm::InputTag>("EgammaGsfTracks"))),
     SigmaIEtaIEtaMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                     "SigmaIEtaIEtaMap"))),
     HoverEMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("HoverEMap"))),
     DetaMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("DetaMap"))),
     DphiMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>("DphiMap"))),
     MissingHitsMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                   "MissingHitsMap"))),
     OneOEMinusOneOPMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                       "OneOEMinusOneOPMap"))),
     EcalPFClusterIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                        "EcalPFClusterIsoMap"))),
     EleGsfTrackIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                      "EleGsfTrackIsoMap"))),
     HcalPFClusterIsoMap_(consumes<RecoEcalCandMap>(iConfig.getParameter<edm::InputTag>(
                                                        "HcalPFClusterIsoMap"))),
     egammaPtCut(iConfig.getParameter<double>("egammaPtCut")),
     egammaEtaCut(iConfig.getParameter<double>("egammaEtaCut")),
     egammaHoverECut(iConfig.getParameter<double>("egammaHoverECut"))
 {
     //register products
     produces<ScoutingElectronCollection>();
     produces<ScoutingPhotonCollection>();
 }

HLTScoutingEgammaProducer::~HLTScoutingEgammaProducer ( )

Definition at line 51 of file HLTScoutingEgammaProducer.cc.

52 { }

Member Function Documentation

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

static

Definition at line 208 of file HLTScoutingEgammaProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and HLT_25ns14e33_v1_cff::InputTag.

                                                                                            {
     edm::ParameterSetDescription desc;
     desc.add<edm::InputTag>("EgammaCandidates", edm::InputTag("hltEgammaCandidates"));
     desc.add<edm::InputTag>("EgammaGsfTracks", edm::InputTag("hltEgammaGsfTracks"));
     desc.add<edm::InputTag>("SigmaIEtaIEtaMap", edm::InputTag(
                                 "hltEgammaClusterShape:sigmaIEtaIEta5x5"));
     desc.add<edm::InputTag>("HoverEMap", edm::InputTag("hltEgammaHoverE"));
     desc.add<edm::InputTag>("DetaMap", edm::InputTag("hltEgammaGsfTrackVars:Deta"));
     desc.add<edm::InputTag>("DphiMap", edm::InputTag("hltEgammaGsfTrackVars:Dphi"));
     desc.add<edm::InputTag>("MissingHitsMap", edm::InputTag("hltEgammaGsfTrackVars:MissingHits"));
     desc.add<edm::InputTag>("OneOEMinusOneOPMap", edm::InputTag(
                                 "hltEgammaGsfTrackVars:OneOESuperMinusOneOP"));
     desc.add<edm::InputTag>("EcalPFClusterIsoMap", edm::InputTag("hltEgammaEcalPFClusterIso"));
     desc.add<edm::InputTag>("EleGsfTrackIsoMap", edm::InputTag("hltEgammaEleGsfTrackIso"));
     desc.add<edm::InputTag>("HcalPFClusterIsoMap", edm::InputTag("hltEgammaHcalPFClusterIso"));
     desc.add<double>("egammaPtCut", 4.0);
     desc.add<double>("egammaEtaCut", 2.5);
     desc.add<double>("egammaHoverECut", 1.0);
     descriptions.add("hltScoutingEgammaProducer", desc);
 }

void HLTScoutingEgammaProducer::produce	(	edm::StreamID	sid,
		edm::Event &	iEvent,
		edm::EventSetup const &	setup
	)		const

finaloverrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 55 of file HLTScoutingEgammaProducer.cc.

References edm::RefToBase< T >::castTo(), RecoTauCleanerPlugins::charge, DetaMap_, DphiMap_, EcalPFClusterIsoMap_, EgammaCandidateCollection_, egammaEtaCut, EgammaGsfTrackCollection_, egammaHoverECut, egammaPtCut, EleGsfTrackIsoMap_, edm::Event::getByToken(), edm::getRef(), HcalPFClusterIsoMap_, HoverEMap_, cmsHarvester::index, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNull(), MissingHitsMap_, OneOEMinusOneOPMap_, edm::Event::put(), fileCollector::seed, and SigmaIEtaIEtaMap_.

 {
     using namespace edm;
 
     // Get RecoEcalCandidate
     Handle<reco::RecoEcalCandidateCollection> EgammaCandidateCollection;
     if(!iEvent.getByToken(EgammaCandidateCollection_,
                           EgammaCandidateCollection)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: EgammaCandidateCollection" << "\n";
         return;
     }
 
     // Get GsfTrack
     Handle<reco::GsfTrackCollection> EgammaGsfTrackCollection;
     if(!iEvent.getByToken(EgammaGsfTrackCollection_,
                           EgammaGsfTrackCollection)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: EgammaGsfTrackCollection" << "\n";
         return;
     }
 
     // Get SigmaIEtaIEtaMap
     Handle<RecoEcalCandMap> SigmaIEtaIEtaMap;
     if(!iEvent.getByToken(SigmaIEtaIEtaMap_, SigmaIEtaIEtaMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaClusterShape:sigmaIEtaIEta5x5" << "\n";
         return;
     }
 
     // Get HoverEMap
     Handle<RecoEcalCandMap> HoverEMap;
     if(!iEvent.getByToken(HoverEMap_, HoverEMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaHoverE" << "\n";
         return;
     }
 
     // Get DetaMap
     Handle<RecoEcalCandMap> DetaMap;
     if(!iEvent.getByToken(DetaMap_, DetaMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaGsfTrackVars:Deta" << "\n";
         return;
     }
 
     // Get DphiMap
     Handle<RecoEcalCandMap> DphiMap;
     if(!iEvent.getByToken(DphiMap_, DphiMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaGsfTrackVars:Dphi" << "\n";
         return;
     }
 
     // Get MissingHitsMap
     Handle<RecoEcalCandMap> MissingHitsMap;
     if(!iEvent.getByToken(MissingHitsMap_, MissingHitsMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaGsfTrackVars:MissingHits" << "\n";
         return;
     }
 
     // Get 1/E - 1/p Map
     Handle<RecoEcalCandMap> OneOEMinusOneOPMap;
     if(!iEvent.getByToken(OneOEMinusOneOPMap_, OneOEMinusOneOPMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaGsfTrackVars:OneOESuperMinusOneOP" << "\n";
         return;
     }
 
     // Get EcalPFClusterIsoMap
     Handle<RecoEcalCandMap> EcalPFClusterIsoMap;
     if(!iEvent.getByToken(EcalPFClusterIsoMap_, EcalPFClusterIsoMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaEcalPFClusterIso" << "\n";
         return;
     }
 
     // Get EleGsfTrackIsoMap
     Handle<RecoEcalCandMap> EleGsfTrackIsoMap;
     if(!iEvent.getByToken(EleGsfTrackIsoMap_, EleGsfTrackIsoMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: hltEgammaEleGsfTrackIso" << "\n";
         return;
     }
 
     // Get HcalPFClusterIsoMap
     Handle<RecoEcalCandMap> HcalPFClusterIsoMap;
     if(!iEvent.getByToken(HcalPFClusterIsoMap_, HcalPFClusterIsoMap)){
         edm::LogError ("HLTScoutingEgammaProducer")
             << "invalid collection: HcalPFClusterIso" << "\n";
         return;
     }
 
     // Produce electrons and photons
     std::auto_ptr<ScoutingElectronCollection> outElectrons(new ScoutingElectronCollection());
     std::auto_ptr<ScoutingPhotonCollection> outPhotons(new ScoutingPhotonCollection());
     int index = 0;
     for (auto &candidate : *EgammaCandidateCollection) {
         reco::RecoEcalCandidateRef candidateRef = getRef(EgammaCandidateCollection, index);
         ++index;
         if (candidateRef.isNull() && !candidateRef.isAvailable())
             continue;
 
         if ((*HoverEMap)[candidateRef] > egammaHoverECut)
             continue;
         if (candidate.pt() < egammaPtCut)
             continue;
         if (fabs(candidate.eta()) > egammaEtaCut)
             continue;
 
         reco::SuperClusterRef scRef = candidate.superCluster();
         if (scRef.isNull() && !scRef.isAvailable())
             continue;
         float d0 = 0.0;
         float dz = 0.0;
         int charge = -999;
         for (auto &track: *EgammaGsfTrackCollection) {
             RefToBase<TrajectorySeed> seed = track.extra()->seedRef();
             reco::ElectronSeedRef elseed = seed.castTo<reco::ElectronSeedRef>();
             RefToBase<reco::CaloCluster> caloCluster = elseed->caloCluster();
             reco::SuperClusterRef scRefFromTrk = caloCluster.castTo<reco::SuperClusterRef>() ;
             if (scRefFromTrk == scRef) {
                 d0 = track.d0();
                 dz = track.dz();
                 charge = track.charge();
             }
         }
         if (charge == -999) { // No associated track. Candidate is a scouting photon
             outPhotons->emplace_back(candidate.pt(), candidate.eta(), candidate.phi(),
                                      candidate.mass(), (*SigmaIEtaIEtaMap)[candidateRef],
                                      (*HoverEMap)[candidateRef],
                                      (*EcalPFClusterIsoMap)[candidateRef],
                                      (*HcalPFClusterIsoMap)[candidateRef]);
         } else { // Candidate is a scouting electron
             outElectrons->emplace_back(candidate.pt(), candidate.eta(), candidate.phi(),
                                        candidate.mass(), d0, dz, (*DetaMap)[candidateRef],
                                        (*DphiMap)[candidateRef], (*SigmaIEtaIEtaMap)[candidateRef],
                                        (*HoverEMap)[candidateRef],
                                        (*OneOEMinusOneOPMap)[candidateRef],
                                        (*MissingHitsMap)[candidateRef], charge,
                                        (*EcalPFClusterIsoMap)[candidateRef],
                                        (*HcalPFClusterIsoMap)[candidateRef],
                                        (*EleGsfTrackIsoMap)[candidateRef]);
         }
     }
 
     // Put output
     iEvent.put(outElectrons);
     iEvent.put(outPhotons);
 }