#include <RecoEgamma/EgammaHLTProducers/interface/EgammaHLTElectronCombinedIsolationProducer.h>

Inheritance diagram for EgammaHLTElectronCombinedIsolationProducer:

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

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

	~EgammaHLTElectronCombinedIsolationProducer ()

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

ModuleDescription const &	moduleDescription () const

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

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

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::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Attributes
std::vector< edm::EDGetTokenT < reco::RecoEcalCandidateIsolationMap > >	CaloIsolTag_

std::vector< double >	CaloIsolWeight_

edm::ParameterSet	conf_

edm::EDGetTokenT < reco::ElectronCollection >	electronProducer_

edm::EDGetTokenT < reco::RecoEcalCandidateCollection >	recoEcalCandidateProducer_

edm::EDGetTokenT < reco::ElectronIsolationMap >	TrackIsolTag_

double	TrackIsolWeight_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

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

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

Author: Alessio Ghezzi

Definition at line 33 of file EgammaHLTElectronCombinedIsolationProducer.h.

Constructor & Destructor Documentation

EgammaHLTElectronCombinedIsolationProducer::EgammaHLTElectronCombinedIsolationProducer ( const edm::ParameterSet & config )

explicit

Definition at line 13 of file EgammaHLTElectronCombinedIsolationProducer.cc.

References CaloIsolTag_, CaloIsolWeight_, conf_, electronProducer_, edm::hlt::Exception, edm::ParameterSet::getParameter(), recoEcalCandidateProducer_, GlobalPosition_Frontier_DevDB_cff::tag, TrackIsolTag_, and TrackIsolWeight_.

                                                                                                                     : conf_(config) {
 
   electronProducer_          = consumes<reco::ElectronCollection>(conf_.getParameter<edm::InputTag>("electronProducer"));
   recoEcalCandidateProducer_ = consumes<reco::RecoEcalCandidateCollection>(conf_.getParameter<edm::InputTag>("recoEcalCandidateProducer"));
 
   for (edm::InputTag const & tag : conf_.getParameter< std::vector<edm::InputTag> > ("CaloIsolationMapTags"))
     CaloIsolTag_.push_back(consumes<reco::RecoEcalCandidateIsolationMap>(tag));
   
   TrackIsolTag_              = consumes<reco::ElectronIsolationMap>(conf_.getParameter<edm::InputTag>("TrackIsolationMapTag"));
 
   CaloIsolWeight_ = conf_.getParameter< std::vector<double> > ("CaloIsolationWeight");
   TrackIsolWeight_ = conf_.getParameter<double>("TrackIsolationWeight");
   
   if (CaloIsolTag_.size() != CaloIsolWeight_.size()){
     throw cms::Exception("BadConfig") << "vectors CaloIsolationMapTags and CaloIsolationWeight need to have size 3";
   }
   
   //register your products
   produces < reco::ElectronIsolationMap >();
 }

EgammaHLTElectronCombinedIsolationProducer::~EgammaHLTElectronCombinedIsolationProducer ( )

Definition at line 34 of file EgammaHLTElectronCombinedIsolationProducer.cc.

35 {}

Member Function Documentation

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

static

Definition at line 37 of file EgammaHLTElectronCombinedIsolationProducer.cc.

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

                                                                                                             {
 
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("electronProducer", edm::InputTag(""));
   desc.add<edm::InputTag>("recoEcalCandidateProducer", edm::InputTag(""));
   desc.add<std::vector<edm::InputTag> >("CaloIsolationMapTags", std::vector<edm::InputTag>());
   desc.add<edm::InputTag>("TrackIsolationMapTag", edm::InputTag(""));
 desc.add<std::vector<double> >("CaloIsolationWeight", std::vector<double>());
   desc.add<double>("TrackIsolationWeight", 0);
   descriptions.add("hltEgammaHLTElectronCombinedIsolationProducer", desc);  
 }

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

virtual

Implements edm::EDProducer.

Definition at line 49 of file EgammaHLTElectronCombinedIsolationProducer.cc.

References CaloIsolTag_, CaloIsolWeight_, edm::AssociationMap< edm::OneToValue< std::vector< reco::RecoEcalCandidate >, float > >::const_iterator, edm::AssociationMap< edm::OneToValue< std::vector< reco::Electron >, float > >::const_iterator, electronProducer_, spr::find(), edm::Event::getByToken(), edm::AssociationMap< Tag >::insert(), edm::Event::put(), recoEcalCandidateProducer_, TrackIsolTag_, and TrackIsolWeight_.

                                                                                                       {
   
   edm::Handle<reco::ElectronCollection> electronHandle;
   iEvent.getByToken(electronProducer_,electronHandle);
 
   edm::Handle<reco::RecoEcalCandidateCollection> recoecalcandHandle;
   iEvent.getByToken(recoEcalCandidateProducer_,recoecalcandHandle);
   
   std::vector< edm::Handle<reco::RecoEcalCandidateIsolationMap> > CaloIsoMap;
   for( unsigned int u=0; u < CaloIsolTag_.size(); u++){
     edm::Handle<reco::RecoEcalCandidateIsolationMap> depMapTemp;
     if(CaloIsolWeight_[u] != 0) 
       iEvent.getByToken(CaloIsolTag_[u],depMapTemp);
 
     CaloIsoMap.push_back(depMapTemp);
   }
   
   edm::Handle<reco::ElectronIsolationMap> TrackIsoMap;
   if(TrackIsolWeight_ != 0) 
     iEvent.getByToken(TrackIsolTag_,TrackIsoMap);
   
   reco::ElectronIsolationMap TotalIsolMap;
   double TotalIso=0;
   for(reco::ElectronCollection::const_iterator iElectron = electronHandle->begin(); iElectron != electronHandle->end(); iElectron++){
     TotalIso=0; 
     reco::ElectronRef electronref(reco::ElectronRef(electronHandle,iElectron - electronHandle->begin()));
     const reco::SuperClusterRef theEleClus = electronref->superCluster();
  
    //look for corresponding recoecal candidates to search for in the ecal and Hcal iso map
     for(reco::RecoEcalCandidateCollection::const_iterator iRecoEcalCand = recoecalcandHandle->begin(); iRecoEcalCand != recoecalcandHandle->end(); iRecoEcalCand++){
       reco::RecoEcalCandidateRef recoecalcandref(recoecalcandHandle,iRecoEcalCand-recoecalcandHandle->begin());
       const reco::SuperClusterRef cluster = recoecalcandref->superCluster();
       if(&(*cluster) ==  &(*theEleClus)) {//recoecalcand and electron have the same SC
     for(unsigned int u=0;  u < CaloIsolTag_.size() ;u++){
       if(CaloIsolWeight_[u]==0){continue;}
       reco::RecoEcalCandidateIsolationMap::const_iterator mapi = (*CaloIsoMap[u]).find( recoecalcandref );
       TotalIso += mapi->val * CaloIsolWeight_[u];
     }
     break;
       }
     }
   
     //add the track isolation
     if(TrackIsolWeight_ != 0){
       reco::ElectronIsolationMap::const_iterator mapi = (*TrackIsoMap).find( electronref );
       TotalIso += mapi->val * TrackIsolWeight_;
     }
     TotalIsolMap.insert(electronref, TotalIso);
     
   }
 
   std::auto_ptr<reco::ElectronIsolationMap> isolMap(new reco::ElectronIsolationMap(TotalIsolMap));
   iEvent.put(isolMap);
 
 }