Inheritance diagram for HLTHGCalLayerClusterIsolationProducer< T1 >:

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

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

	~HLTHGCalLayerClusterIsolationProducer () override=default

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Static Public Member Functions
static void	fillDescriptions (edm::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 bool	doRhoCorrection_

const double	drMax_

const double	drVetoEM_

const double	drVetoHad_

const std::vector< double >	effectiveAreas_

const edm::EDGetTokenT < reco::CaloClusterCollection >	layerClusterProducer_

const double	minEnergyEM_

const double	minEnergyHad_

const double	minEtEM_

const double	minEtHad_

edm::EDGetTokenT< T1Collection >	recoCandidateProducer_

const double	rhoMax_

const edm::EDGetTokenT< double >	rhoProducer_

const double	rhoScale_

const bool	useEt_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename T1>
class HLTHGCalLayerClusterIsolationProducer< T1 >

Definition at line 38 of file HLTHGCalLayerClusterIsolationProducer.cc.

Member Typedef Documentation

template<typename T1 >

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

private

Definition at line 39 of file HLTHGCalLayerClusterIsolationProducer.cc.

template<typename T1 >

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

private

Definition at line 41 of file HLTHGCalLayerClusterIsolationProducer.cc.

template<typename T1 >

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

private

Definition at line 40 of file HLTHGCalLayerClusterIsolationProducer.cc.

Constructor & Destructor Documentation

template<typename T1 >

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

explicit

Definition at line 70 of file HLTHGCalLayerClusterIsolationProducer.cc.

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

     : layerClusterProducer_(
           consumes<reco::CaloClusterCollection>(config.getParameter<edm::InputTag>("layerClusterProducer"))),
       rhoProducer_(consumes<double>(config.getParameter<edm::InputTag>("rhoProducer"))),
       drMax_(config.getParameter<double>("drMax")),
       drVetoEM_(config.getParameter<double>("drVetoEM")),
       drVetoHad_(config.getParameter<double>("drVetoHad")),
       minEnergyEM_(config.getParameter<double>("minEnergyEM")),
       minEnergyHad_(config.getParameter<double>("minEnergyHad")),
       minEtEM_(config.getParameter<double>("minEtEM")),
       minEtHad_(config.getParameter<double>("minEtHad")),
       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")) {
   if (doRhoCorrection_) {
     if (effectiveAreas_.size() != 2)
       throw cms::Exception("IncompatibleVects")
           << "effectiveAreas should have two elements for em and had components. \n";
   }
 
   std::string recoCandidateProducerName = "recoCandidateProducer";
   if ((typeid(HLTHGCalLayerClusterIsolationProducer<T1>) ==
        typeid(HLTHGCalLayerClusterIsolationProducer<reco::RecoEcalCandidate>)))
     recoCandidateProducerName = "recoEcalCandidateProducer";
 
   recoCandidateProducer_ = consumes<T1Collection>(config.getParameter<edm::InputTag>(recoCandidateProducerName));
   produces<T1IsolationMap>();
   produces<T1IsolationMap>("em");
   produces<T1IsolationMap>("had");
 }

template<typename T1 >

HLTHGCalLayerClusterIsolationProducer< T1 >::~HLTHGCalLayerClusterIsolationProducer ( )

overridedefault

Member Function Documentation

template<typename T1 >

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

static

Definition at line 104 of file HLTHGCalLayerClusterIsolationProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), defaultModuleLabel(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                            {
   std::string recoCandidateProducerName = "recoCandidateProducer";
   if ((typeid(HLTHGCalLayerClusterIsolationProducer<T1>) ==
        typeid(HLTHGCalLayerClusterIsolationProducer<reco::RecoEcalCandidate>)))
     recoCandidateProducerName = "recoEcalCandidateProducer";
 
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>(recoCandidateProducerName, edm::InputTag("hltL1SeededRecoEcalCandidatePF"));
   desc.add<edm::InputTag>("layerClusterProducer", edm::InputTag("hltParticleFlowClusterECAL"));
   desc.add<edm::InputTag>("rhoProducer", edm::InputTag("fixedGridRhoFastjetAllCalo"));
   desc.add<bool>("doRhoCorrection", false);
   desc.add<bool>("useEt", false);
   desc.add<double>("rhoMax", 9.9999999E7);
   desc.add<double>("rhoScale", 1.0);
   desc.add<double>("drMax", 0.3);
   desc.add<double>("drVetoEM", 0.0);
   desc.add<double>("drVetoHad", 0.0);
   desc.add<double>("minEnergyEM", 0.0);
   desc.add<double>("minEnergyHad", 0.0);
   desc.add<double>("minEtEM", 0.0);
   desc.add<double>("minEtHad", 0.0);
   desc.add<std::vector<double>>("effectiveAreas", {0.0, 0.0});  // for em and had components
   descriptions.add(defaultModuleLabel<HLTHGCalLayerClusterIsolationProducer<T1>>(), desc);
 }

template<typename T1 >

void HLTHGCalLayerClusterIsolationProducer< T1 >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &
	)

override

Definition at line 130 of file HLTHGCalLayerClusterIsolationProducer.cc.

References HGCalClusterTools::emEnergyInCone(), HGCalClusterTools::ENERGY, HGCalClusterTools::ET, edm::Event::getByToken(), HGCalClusterTools::hadEnergyInCone(), edm::AssociationMap< Tag >::insert(), SiStripPI::min, edm::Handle< T >::product(), edm::Event::put(), and HLT_FULL_cff::rho.

                                                                                               {
   edm::Handle<double> rhoHandle;
   double rho = 0.0;
   if (doRhoCorrection_) {
     iEvent.getByToken(rhoProducer_, rhoHandle);
     rho = *(rhoHandle.product());
   }
 
   rho = std::min(rho, rhoMax_);
   rho = rho * rhoScale_;
 
   edm::Handle<T1Collection> recoCandHandle;
   edm::Handle<reco::CaloClusterCollection> clusterHandle;
 
   iEvent.getByToken(recoCandidateProducer_, recoCandHandle);
   iEvent.getByToken(layerClusterProducer_, clusterHandle);
 
   const std::vector<reco::CaloCluster> layerClusters = *(clusterHandle.product());
 
   T1IsolationMap recoCandMap(recoCandHandle);
   T1IsolationMap recoCandMapEm(recoCandHandle);
   T1IsolationMap recoCandMapHad(recoCandHandle);
 
   for (unsigned int iReco = 0; iReco < recoCandHandle->size(); iReco++) {
     T1Ref candRef(recoCandHandle, iReco);
 
     float sumEm =
         HGCalClusterTools::emEnergyInCone(candRef->eta(),
                                           candRef->phi(),
                                           layerClusters,
                                           drVetoEM_,
                                           drMax_,
                                           minEtEM_,
                                           minEnergyEM_,
                                           useEt_ ? HGCalClusterTools::EType::ET : HGCalClusterTools::EType::ENERGY);
 
     float sumHad =
         HGCalClusterTools::hadEnergyInCone(candRef->eta(),
                                            candRef->phi(),
                                            layerClusters,
                                            drVetoHad_,
                                            drMax_,
                                            minEtHad_,
                                            minEnergyHad_,
                                            useEt_ ? HGCalClusterTools::EType::ET : HGCalClusterTools::EType::ENERGY);
 
     if (doRhoCorrection_) {
       sumEm = sumEm - rho * effectiveAreas_.at(0);
       sumHad = sumHad - rho * effectiveAreas_.at(1);
     }
 
     float sum = sumEm + sumHad;
 
     recoCandMap.insert(candRef, sum);
     recoCandMapEm.insert(candRef, sumEm);
     recoCandMapHad.insert(candRef, sumHad);
   }
 
   iEvent.put(std::make_unique<T1IsolationMap>(recoCandMap));
   iEvent.put(std::make_unique<T1IsolationMap>(recoCandMapEm), "em");
   iEvent.put(std::make_unique<T1IsolationMap>(recoCandMapHad), "had");
 }