#include <HLTHcalPFClusterIsolationProducer.h>

Inheritance diagram for HLTHcalPFClusterIsolationProducer< T1 >:

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

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

	~HLTHcalPFClusterIsolationProducer () override

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

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

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, ModuleToResolverIndicies 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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) 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 std::vector< T1 >	T1Collection

typedef edm::AssociationMap< edm::OneToValue< std::vector< T1 >, float > >	T1IsolationMap

typedef edm::Ref< T1Collection >	T1Ref

Private Attributes
const std::vector< double >	absEtaLowEdges_

const bool	doRhoCorrection_

const double	drMax_

const double	drVetoBarrel_

const double	drVetoEndcap_

const std::vector< double >	effectiveAreas_

const double	energyBarrel_

const double	energyEndcap_

const double	etaStripBarrel_

const double	etaStripEndcap_

const edm::EDGetTokenT< reco::PFClusterCollection >	pfClusterProducerHCAL_

const edm::EDGetTokenT< reco::PFClusterCollection >	pfClusterProducerHFEM_

const edm::EDGetTokenT< reco::PFClusterCollection >	pfClusterProducerHFHAD_

edm::EDGetTokenT< T1Collection >	recoCandidateProducer_

const double	rhoMax_

const edm::EDGetTokenT< double >	rhoProducer_

const double	rhoScale_

const bool	useEt_

const bool	useHF_

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

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

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

template<typename T1>
class HLTHcalPFClusterIsolationProducer< T1 >

Definition at line 29 of file HLTHcalPFClusterIsolationProducer.h.

Member Typedef Documentation

template<typename T1 >

typedef std::vector<T1> HLTHcalPFClusterIsolationProducer< T1 >::T1Collection

private

Definition at line 31 of file HLTHcalPFClusterIsolationProducer.h.

template<typename T1 >

typedef edm::AssociationMap<edm::OneToValue<std::vector<T1>, float > > HLTHcalPFClusterIsolationProducer< T1 >::T1IsolationMap

private

Definition at line 33 of file HLTHcalPFClusterIsolationProducer.h.

template<typename T1 >

typedef edm::Ref<T1Collection> HLTHcalPFClusterIsolationProducer< T1 >::T1Ref

private

Definition at line 32 of file HLTHcalPFClusterIsolationProducer.h.

Constructor & Destructor Documentation

template<typename T1 >

HLTHcalPFClusterIsolationProducer< T1 >::HLTHcalPFClusterIsolationProducer ( const edm::ParameterSet & config )

explicit

Definition at line 21 of file HLTHcalPFClusterIsolationProducer.cc.

References HLTHcalPFClusterIsolationProducer< T1 >::absEtaLowEdges_, HLTHcalPFClusterIsolationProducer< T1 >::doRhoCorrection_, HLTHcalPFClusterIsolationProducer< T1 >::effectiveAreas_, Exception, edm::ParameterSet::getParameter(), HLTHcalPFClusterIsolationProducer< T1 >::recoCandidateProducer_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                       :
   pfClusterProducerHCAL_  ( consumes<reco::PFClusterCollection>(config.getParameter<edm::InputTag>("pfClusterProducerHCAL"))),
   rhoProducer_            ( consumes<double>(config.getParameter<edm::InputTag>("rhoProducer"))),
   pfClusterProducerHFEM_  ( consumes<reco::PFClusterCollection>(config.getParameter<edm::InputTag>("pfClusterProducerHFEM"))),
   pfClusterProducerHFHAD_ ( consumes<reco::PFClusterCollection>(config.getParameter<edm::InputTag>("pfClusterProducerHFHAD"))),
   useHF_                  ( config.getParameter<bool>("useHF")),
   drMax_                  ( config.getParameter<double>("drMax")),
   drVetoBarrel_           ( config.getParameter<double>("drVetoBarrel")),
   drVetoEndcap_           ( config.getParameter<double>("drVetoEndcap")),
   etaStripBarrel_         ( config.getParameter<double>("etaStripBarrel")),
   etaStripEndcap_         ( config.getParameter<double>("etaStripEndcap")),
   energyBarrel_           ( config.getParameter<double>("energyBarrel")),
   energyEndcap_           ( config.getParameter<double>("energyEndcap")),
   useEt_                  ( config.getParameter<bool>("useEt")),
   doRhoCorrection_        ( config.getParameter<bool>("doRhoCorrection")),
   rhoMax_                 ( config.getParameter<double>("rhoMax")),
   rhoScale_               ( config.getParameter<double>("rhoScale")),
   effectiveAreas_         ( config.getParameter<std::vector<double> >("effectiveAreas")) ,
   absEtaLowEdges_         ( config.getParameter<std::vector<double> >("absEtaLowEdges")) {
 
   if (doRhoCorrection_) {
     if (absEtaLowEdges_.size() != effectiveAreas_.size())
       throw cms::Exception("IncompatibleVects") << "absEtaLowEdges and effectiveAreas should be of the same size. \n";
 
     if (absEtaLowEdges_.at(0) != 0.0)
       throw cms::Exception("IncompleteCoverage") << "absEtaLowEdges should start from 0. \n";
 
     for (unsigned int aIt = 0; aIt < absEtaLowEdges_.size() - 1; aIt++) {
       if ( !(absEtaLowEdges_.at( aIt ) < absEtaLowEdges_.at( aIt + 1 )) )
         throw cms::Exception("ImproperBinning") << "absEtaLowEdges entries should be in increasing order. \n";
     }
   }
   
   std::string recoCandidateProducerName = "recoCandidateProducer";
   if ((typeid(HLTHcalPFClusterIsolationProducer<T1>) == typeid(HLTHcalPFClusterIsolationProducer<reco::RecoEcalCandidate>))) recoCandidateProducerName = "recoEcalCandidateProducer";
   recoCandidateProducer_ = consumes<T1Collection>(config.getParameter<edm::InputTag>(recoCandidateProducerName));
   
   produces <T1IsolationMap >();
 }

template<typename T1 >

HLTHcalPFClusterIsolationProducer< T1 >::~HLTHcalPFClusterIsolationProducer ( )

override

Definition at line 62 of file HLTHcalPFClusterIsolationProducer.cc.

63 {}

Member Function Documentation

template<typename T1 >

void HLTHcalPFClusterIsolationProducer< T1 >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 66 of file HLTHcalPFClusterIsolationProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), defaultModuleLabel(), edm::ParameterSetDescription::ifValue(), or, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                        {
  
   std::string recoCandidateProducerName = "recoCandidateProducer";
   if ((typeid(HLTHcalPFClusterIsolationProducer<T1>) == typeid(HLTHcalPFClusterIsolationProducer<reco::RecoEcalCandidate>))) recoCandidateProducerName = "recoEcalCandidateProducer";
 
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>(recoCandidateProducerName, edm::InputTag("hltL1SeededRecoEcalCandidatePF"));
   desc.add<edm::InputTag>("pfClusterProducerHCAL", edm::InputTag("hltParticleFlowClusterHCAL"));
   desc.ifValue(edm::ParameterDescription<bool>("useHF", false, true),
            true >> (edm::ParameterDescription<edm::InputTag>("pfClusterProducerHFEM", edm::InputTag("hltParticleFlowClusterHFEM"), true) and
             edm::ParameterDescription<edm::InputTag>("pfClusterProducerHFHAD", edm::InputTag("hltParticleFlowClusterHFHAD"), true)) or
            false >> (edm::ParameterDescription<edm::InputTag>("pfClusterProducerHFEM", edm::InputTag(""), true) and
              edm::ParameterDescription<edm::InputTag>("pfClusterProducerHFHAD", edm::InputTag(""), true)));
   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>("drMax", 0.3);
   desc.add<double>("drVetoBarrel", 0.0);
   desc.add<double>("drVetoEndcap", 0.0);
   desc.add<double>("etaStripBarrel", 0.0);
   desc.add<double>("etaStripEndcap", 0.0);
   desc.add<double>("energyBarrel", 0.0);
   desc.add<double>("energyEndcap", 0.0);
   desc.add<bool>("useEt", true);
   desc.add<std::vector<double> >("effectiveAreas", {0.2, 0.25}); // 2016 post-ichep sinEle default
   desc.add<std::vector<double> >("absEtaLowEdges", {0.0, 1.479}); // Barrel, Endcap
   descriptions.add(defaultModuleLabel<HLTHcalPFClusterIsolationProducer<T1>>(), desc);
 }

template<typename T1 >

void HLTHcalPFClusterIsolationProducer< T1 >::produce	(	edm::StreamID	sid,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

override

Definition at line 97 of file HLTHcalPFClusterIsolationProducer.cc.

                                                                                                                         {
   
   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::Handle<T1Collection> recoCandHandle;
 
   std::vector<edm::Handle<reco::PFClusterCollection>> clusterHandles;  
   edm::Handle<reco::PFClusterCollection> clusterHcalHandle;
   edm::Handle<reco::PFClusterCollection> clusterHfemHandle;
   edm::Handle<reco::PFClusterCollection> clusterHfhadHandle;
 
   iEvent.getByToken(recoCandidateProducer_,recoCandHandle);
   iEvent.getByToken(pfClusterProducerHCAL_, clusterHcalHandle);
   //const reco::PFClusterCollection* forIsolationHcal = clusterHcalHandle.product();
   clusterHandles.push_back(clusterHcalHandle);
 
   if (useHF_) {
     iEvent.getByToken(pfClusterProducerHFEM_, clusterHfemHandle);
     clusterHandles.push_back(clusterHfemHandle);
     iEvent.getByToken(pfClusterProducerHFHAD_, clusterHfhadHandle);
     clusterHandles.push_back(clusterHfhadHandle);
   }
 
   T1IsolationMap recoCandMap(recoCandHandle);
   HcalPFClusterIsolation<T1> isoAlgo(drMax_, drVetoBarrel_, drVetoEndcap_, etaStripBarrel_, etaStripEndcap_, energyBarrel_, energyEndcap_, useEt_);
   
   for (unsigned int iReco = 0; iReco < recoCandHandle->size(); iReco++) {
     T1Ref candRef(recoCandHandle, iReco);
         
     float sum = isoAlgo.getSum(candRef, clusterHandles);
  
     if (doRhoCorrection_) {
       int iEA = -1;
       auto cEta = std::abs(candRef->eta());
       for (int bIt = absEtaLowEdges_.size() - 1; bIt > -1; bIt--) {
         if ( cEta > absEtaLowEdges_.at(bIt) ) {
           iEA = bIt;
           break;
         }
       }
 
       sum = sum - rho*effectiveAreas_.at(iEA);
     }
 
     recoCandMap.insert(candRef, sum);
   }
   
   iEvent.put(std::make_unique<T1IsolationMap>(recoCandMap));
 }