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

Inheritance diagram for EgammaHLTHcalIsolationProducersRegional:

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

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

	~EgammaHLTHcalIsolationProducersRegional ()

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
	EgammaHLTHcalIsolationProducersRegional (const EgammaHLTHcalIsolationProducersRegional &rhs)

EgammaHLTHcalIsolationProducersRegional &	operator= (const EgammaHLTHcalIsolationProducersRegional &rhs)

Private Attributes
bool	doEtSum_

bool	doRhoCorrection_

float	effectiveAreaBarrel_

float	effectiveAreaEndcap_

edm::EDGetTokenT< HBHERecHitCollection >	hbheRecHitProducer_

EgammaHLTHcalIsolation *	isolAlgo_

edm::EDGetTokenT< reco::RecoEcalCandidateCollection >	recoEcalCandidateProducer_

float	rhoMax_

edm::EDGetTokenT< double >	rhoProducer_

float	rhoScale_

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	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

Author: Monica Vazquez Acosta (CERN)

$Id:

Definition at line 38 of file EgammaHLTHcalIsolationProducersRegional.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 27 of file EgammaHLTHcalIsolationProducersRegional.cc.

References particleFlowClusterECALTimeSelected_cfi::depth, doEtSum_, doRhoCorrection_, effectiveAreaBarrel_, effectiveAreaEndcap_, edm::ParameterSet::getParameter(), hbheRecHitProducer_, isolAlgo_, recoEcalCandidateProducer_, rhoMax_, rhoProducer_, and rhoScale_.

 {
  // use configuration file to setup input/output collection names
   recoEcalCandidateProducer_ = consumes<reco::RecoEcalCandidateCollection>(config.getParameter<edm::InputTag>("recoEcalCandidateProducer"));
   hbheRecHitProducer_        = consumes<HBHERecHitCollection>(config.getParameter<edm::InputTag>("hbheRecHitProducer"));
 
   doRhoCorrection_           = config.getParameter<bool>("doRhoCorrection");
   if (doRhoCorrection_)
     rhoProducer_               = consumes<double>(config.getParameter<edm::InputTag>("rhoProducer"));
 
   rhoMax_                    = config.getParameter<double>("rhoMax"); 
   rhoScale_                  = config.getParameter<double>("rhoScale"); 
   
   double eMinHB              = config.getParameter<double>("eMinHB");
   double eMinHE              = config.getParameter<double>("eMinHE");
   double etMinHB             = config.getParameter<double>("etMinHB");  
   double etMinHE             = config.getParameter<double>("etMinHE");
   double innerCone           = config.getParameter<double>("innerCone");
   double outerCone           = config.getParameter<double>("outerCone");
   int depth                  = config.getParameter<int>("depth");
   doEtSum_                   = config.getParameter<bool>("doEtSum");
   effectiveAreaBarrel_       = config.getParameter<double>("effectiveAreaBarrel");
   effectiveAreaEndcap_       = config.getParameter<double>("effectiveAreaEndcap");
   isolAlgo_                  = new EgammaHLTHcalIsolation(eMinHB,eMinHE,etMinHB,etMinHE,innerCone,outerCone,depth);
  
   //register your products
   produces < reco::RecoEcalCandidateIsolationMap >();  
 }

EgammaHLTHcalIsolationProducersRegional::~EgammaHLTHcalIsolationProducersRegional ( )

Definition at line 56 of file EgammaHLTHcalIsolationProducersRegional.cc.

References isolAlgo_.

                                                                                   {
   delete isolAlgo_;
 }

EgammaHLTHcalIsolationProducersRegional::EgammaHLTHcalIsolationProducersRegional ( const EgammaHLTHcalIsolationProducersRegional & rhs )

inlineprivate

Definition at line 47 of file EgammaHLTHcalIsolationProducersRegional.h.

47 {}

Member Function Documentation

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

static

Definition at line 60 of file EgammaHLTHcalIsolationProducersRegional.cc.

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

                                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>(("recoEcalCandidateProducer"), edm::InputTag("hltL1SeededRecoEcalCandidate"));
   desc.add<edm::InputTag>(("hbheRecHitProducer"), edm::InputTag("hltHbhereco"));
   desc.add<edm::InputTag>(("rhoProducer"), edm::InputTag("fixedGridRhoFastjetAllCalo"));
   desc.add<bool>(("doRhoCorrection"), false);
   desc.add<double>(("rhoMax"), 9.9999999E7); 
   desc.add<double>(("rhoScale"), 1.0); 
   desc.add<double>(("eMinHB"), 0.7);
   desc.add<double>(("eMinHE"), 0.8);
   desc.add<double>(("etMinHB"), -1.0);  
   desc.add<double>(("etMinHE"), -1.0);
   desc.add<double>(("innerCone"), 0);
   desc.add<double>(("outerCone"), 0.15);
   desc.add<int>(("depth"),  -1);
   desc.add<bool>(("doEtSum"), false);
   desc.add<double>(("effectiveAreaBarrel"), 0.105);
   desc.add<double>(("effectiveAreaEndcap"), 0.170);
   descriptions.add(("hltEgammaHLTHcalIsolationProducersRegional"), desc);  
 }

EgammaHLTHcalIsolationProducersRegional& EgammaHLTHcalIsolationProducersRegional::operator= ( const EgammaHLTHcalIsolationProducersRegional & rhs )

inlineprivate

Definition at line 48 of file EgammaHLTHcalIsolationProducersRegional.h.

48 {return *this;}

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

override

Definition at line 81 of file EgammaHLTHcalIsolationProducersRegional.cc.

References begin, doEtSum_, doRhoCorrection_, effectiveAreaBarrel_, effectiveAreaEndcap_, edm::EventSetup::get(), edm::Event::getByToken(), EgammaHLTHcalIsolation::getESum(), EgammaHLTHcalIsolation::getEtSum(), hbheRecHitProducer_, edm::AssociationMap< Tag >::insert(), isolAlgo_, edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::Event::put(), recoEcalCandidateProducer_, rho, rhoMax_, rhoProducer_, and rhoScale_.

                                                                                                    {
   
   // Get the HLT filtered objects
   edm::Handle<reco::RecoEcalCandidateCollection> recoEcalCandHandle;
   iEvent.getByToken(recoEcalCandidateProducer_,recoEcalCandHandle);
 
   // Get the barrel hcal hits
   edm::Handle<HBHERecHitCollection>  hbheRecHitHandle;
   iEvent.getByToken(hbheRecHitProducer_, hbheRecHitHandle);
   const HBHERecHitCollection* hbheRecHitCollection = hbheRecHitHandle.product();
   
   edm::ESHandle<HcalChannelQuality> hcalChStatusHandle;    
   iSetup.get<HcalChannelQualityRcd>().get( "withTopo", hcalChStatusHandle );
   const HcalChannelQuality* hcalChStatus = hcalChStatusHandle.product();
 
   edm::ESHandle<HcalSeverityLevelComputer> hcalSevLvlComp;
   iSetup.get<HcalSeverityLevelComputerRcd>().get(hcalSevLvlComp);
 
   edm::Handle<double> rhoHandle;
   double rho = 0.0;
   if (doRhoCorrection_) {
     iEvent.getByToken(rhoProducer_, rhoHandle);
     rho = *(rhoHandle.product());
   }
 
   if (rho > rhoMax_)
     rho = rhoMax_;
 
   rho = rho*rhoScale_;
 
   edm::ESHandle<CaloGeometry> caloGeomHandle;
   iSetup.get<CaloGeometryRecord>().get(caloGeomHandle);
   const CaloGeometry* caloGeom = caloGeomHandle.product();
   
   reco::RecoEcalCandidateIsolationMap isoMap(recoEcalCandHandle);
   
    
   for(reco::RecoEcalCandidateCollection::const_iterator iRecoEcalCand = recoEcalCandHandle->begin(); iRecoEcalCand != recoEcalCandHandle->end(); iRecoEcalCand++){
     
     reco::RecoEcalCandidateRef recoEcalCandRef(recoEcalCandHandle,iRecoEcalCand -recoEcalCandHandle ->begin());
     
     float isol = 0;
     if(doEtSum_) {
       isol = isolAlgo_->getEtSum(recoEcalCandRef->superCluster()->eta(),
                  recoEcalCandRef->superCluster()->phi(),hbheRecHitCollection,caloGeom,
                  hcalSevLvlComp.product(),hcalChStatus);      
      
       if (doRhoCorrection_) {
     if (fabs(recoEcalCandRef->superCluster()->eta()) < 1.442) 
       isol = isol - rho*effectiveAreaBarrel_;
     else
       isol = isol - rho*effectiveAreaEndcap_;
       }
     } else {
       isol = isolAlgo_->getESum(recoEcalCandRef->superCluster()->eta(),recoEcalCandRef->superCluster()->phi(),
                 hbheRecHitCollection,caloGeom,
                 hcalSevLvlComp.product(),hcalChStatus);      
     }
 
     isoMap.insert(recoEcalCandRef, isol);   
   }
 
   iEvent.put(std::make_unique<reco::RecoEcalCandidateIsolationMap>(isoMap));
 
 }