#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)

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	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)

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 override final

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.

References ~HLTScoutingEgammaProducer().

                                                                                   :
     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 ( )

default

Referenced by HLTScoutingEgammaProducer().

Member Function Documentation

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

static

Definition at line 208 of file HLTScoutingEgammaProducer.cc.

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

                                                                                            {
     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 54 of file HLTScoutingEgammaProducer.cc.

References edm::RefToBase< T >::castTo(), ALCARECOTkAlJpsiMuMu_cff::charge, allConversions_cfi::d0, DetaMap_, DphiMap_, allConversions_cfi::dz, EcalPFClusterIsoMap_, EgammaCandidateCollection_, egammaEtaCut, EgammaGsfTrackCollection_, egammaHoverECut, egammaPtCut, EleGsfTrackIsoMap_, edm::Event::getByToken(), edm::getRef(), HcalPFClusterIsoMap_, HoverEMap_, diffTreeTool::index, edm::Ref< C, T, F >::isAvailable(), edm::Ref< C, T, F >::isNull(), MissingHitsMap_, eostools::move(), OneOEMinusOneOPMap_, edm::Event::put(), SurveyInfoScenario_cff::seed, SigmaIEtaIEtaMap_, and HiIsolationCommonParameters_cff::track.

 {
     using namespace edm;
 
     std::unique_ptr<ScoutingElectronCollection> outElectrons(new ScoutingElectronCollection());
     std::unique_ptr<ScoutingPhotonCollection> outPhotons(new ScoutingPhotonCollection());
 
     // Get RecoEcalCandidate
     Handle<reco::RecoEcalCandidateCollection> EgammaCandidateCollection;
     if(!iEvent.getByToken(EgammaCandidateCollection_,
                           EgammaCandidateCollection)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get GsfTrack
     Handle<reco::GsfTrackCollection> EgammaGsfTrackCollection;
     if(!iEvent.getByToken(EgammaGsfTrackCollection_,
                           EgammaGsfTrackCollection)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get SigmaIEtaIEtaMap
     Handle<RecoEcalCandMap> SigmaIEtaIEtaMap;
     if(!iEvent.getByToken(SigmaIEtaIEtaMap_, SigmaIEtaIEtaMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get HoverEMap
     Handle<RecoEcalCandMap> HoverEMap;
     if(!iEvent.getByToken(HoverEMap_, HoverEMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get DetaMap
     Handle<RecoEcalCandMap> DetaMap;
     if(!iEvent.getByToken(DetaMap_, DetaMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get DphiMap
     Handle<RecoEcalCandMap> DphiMap;
     if(!iEvent.getByToken(DphiMap_, DphiMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get MissingHitsMap
     Handle<RecoEcalCandMap> MissingHitsMap;
     if(!iEvent.getByToken(MissingHitsMap_, MissingHitsMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get 1/E - 1/p Map
     Handle<RecoEcalCandMap> OneOEMinusOneOPMap;
     if(!iEvent.getByToken(OneOEMinusOneOPMap_, OneOEMinusOneOPMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get EcalPFClusterIsoMap
     Handle<RecoEcalCandMap> EcalPFClusterIsoMap;
     if(!iEvent.getByToken(EcalPFClusterIsoMap_, EcalPFClusterIsoMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get EleGsfTrackIsoMap
     Handle<RecoEcalCandMap> EleGsfTrackIsoMap;
     if(!iEvent.getByToken(EleGsfTrackIsoMap_, EleGsfTrackIsoMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Get HcalPFClusterIsoMap
     Handle<RecoEcalCandMap> HcalPFClusterIsoMap;
     if(!iEvent.getByToken(HcalPFClusterIsoMap_, HcalPFClusterIsoMap)){
         iEvent.put(std::move(outElectrons));
         iEvent.put(std::move(outPhotons));
         return;
     }
 
     // Produce electrons and photons
     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(std::move(outElectrons));
     iEvent.put(std::move(outPhotons));
 }