#include <EleIsoDetIdCollectionProducer.h>

Inheritance diagram for EleIsoDetIdCollectionProducer:

Public Member Functions
void	beginJob ()

	EleIsoDetIdCollectionProducer (const edm::ParameterSet &)
	ctor More...

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

	~EleIsoDetIdCollectionProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Attributes
edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeometryToken_

edm::InputTag	emObjectLabel_

edm::EDGetToken	emObjectToken_

double	energyCut_

double	etCandCut_

double	etCut_

std::vector< int >	flagsexclEB_

std::vector< int >	flagsexclEE_

double	innerRadius_

std::string	interestingDetIdCollection_

double	outerRadius_

edm::InputTag	recHitsLabel_

edm::EDGetToken	recHitsToken_

std::vector< int >	severitiesexclEB_

std::vector< int >	severitiesexclEE_

edm::ESGetToken< EcalSeverityLevelAlgo, EcalSeverityLevelAlgoRcd >	sevLvToken_

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

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Original author: Matthew LeBourgeois PH/CMG Modified from : RecoEcal/EgammaClusterProducers/{src,interface}/InterestingDetIdCollectionProducer.{h,cc} by Paolo Meridiani PH/CMG

Implementation: <Notes on="" implementation>="">

Definition at line 38 of file EleIsoDetIdCollectionProducer.h.

Constructor & Destructor Documentation

◆ EleIsoDetIdCollectionProducer()

EleIsoDetIdCollectionProducer::EleIsoDetIdCollectionProducer ( const edm::ParameterSet & iConfig )

explicit

ctor

Definition at line 27 of file EleIsoDetIdCollectionProducer.cc.

     : recHitsToken_(consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"))),
       emObjectToken_(consumes<reco::GsfElectronCollection>(iConfig.getParameter<edm::InputTag>("emObjectLabel"))),
       caloGeometryToken_(esConsumes()),
       sevLvToken_(esConsumes()),
       recHitsLabel_(iConfig.getParameter<edm::InputTag>("recHitsLabel")),
       emObjectLabel_(iConfig.getParameter<edm::InputTag>("emObjectLabel")),
       energyCut_(iConfig.getParameter<double>("energyCut")),
       etCut_(iConfig.getParameter<double>("etCut")),
       etCandCut_(iConfig.getParameter<double>("etCandCut")),
       outerRadius_(iConfig.getParameter<double>("outerRadius")),
       innerRadius_(iConfig.getParameter<double>("innerRadius")),
       interestingDetIdCollection_(iConfig.getParameter<std::string>("interestingDetIdCollection")) {
   const std::vector<std::string> flagnamesEB =
       iConfig.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEB");
  
   const std::vector<std::string> flagnamesEE =
       iConfig.getParameter<std::vector<std::string> >("RecHitFlagToBeExcludedEE");
  
   flagsexclEB_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEB);
  
   flagsexclEE_ = StringToEnumValue<EcalRecHit::Flags>(flagnamesEE);
  
   const std::vector<std::string> severitynamesEB =
       iConfig.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEB");
  
   severitiesexclEB_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEB);
  
   const std::vector<std::string> severitynamesEE =
       iConfig.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcludedEE");
  
   severitiesexclEE_ = StringToEnumValue<EcalSeverityLevel::SeverityLevel>(severitynamesEE);
  
   //register your products
   produces<DetIdCollection>(interestingDetIdCollection_);
 }

References flagsexclEB_, flagsexclEE_, edm::ParameterSet::getParameter(), interestingDetIdCollection_, severitiesexclEB_, and severitiesexclEE_.

◆ ~EleIsoDetIdCollectionProducer()

EleIsoDetIdCollectionProducer::~EleIsoDetIdCollectionProducer ( )

override

Definition at line 64 of file EleIsoDetIdCollectionProducer.cc.

64 {}

Member Function Documentation

◆ beginJob()

void EleIsoDetIdCollectionProducer::beginJob ( void )

Definition at line 66 of file EleIsoDetIdCollectionProducer.cc.

66 {}

◆ produce()

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

override

producer

Definition at line 69 of file EleIsoDetIdCollectionProducer.cc.

                                                                                          {
   using namespace edm;
   using namespace std;
  
   //Get EM Object
   Handle<reco::GsfElectronCollection> emObjectH;
   iEvent.getByToken(emObjectToken_, emObjectH);
  
   // take EcalRecHits
   Handle<EcalRecHitCollection> recHitsH;
   iEvent.getByToken(recHitsToken_, recHitsH);
  
   edm::ESHandle<CaloGeometry> pG = iSetup.getHandle(caloGeometryToken_);
   const CaloGeometry* caloGeom = pG.product();
  
   //Get the channel status from the db
   //edm::ESHandle<EcalChannelStatus> chStatus;
   //iSetup.get<EcalChannelStatusRcd>().get(chStatus);
  
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv = iSetup.getHandle(sevLvToken_);
   const EcalSeverityLevelAlgo* sevLevel = sevlv.product();
  
   CaloDualConeSelector<EcalRecHit>* doubleConeSel_ = nullptr;
   if (recHitsLabel_.instance() == "EcalRecHitsEB")
     doubleConeSel_ = new CaloDualConeSelector<EcalRecHit>(innerRadius_, outerRadius_, &*pG, DetId::Ecal, EcalBarrel);
   else if (recHitsLabel_.instance() == "EcalRecHitsEE")
     doubleConeSel_ = new CaloDualConeSelector<EcalRecHit>(innerRadius_, outerRadius_, &*pG, DetId::Ecal, EcalEndcap);
  
   //Create empty output collections
   auto detIdCollection = std::make_unique<DetIdCollection>();
  
   reco::GsfElectronCollection::const_iterator emObj;
   if (doubleConeSel_) {                                                     //if cone selector was created
     for (emObj = emObjectH->begin(); emObj != emObjectH->end(); emObj++) {  //Loop over candidates
  
       if (emObj->et() < etCandCut_)
         continue;  //don't calculate if object hasn't enough energy
  
       GlobalPoint pclu(emObj->caloPosition().x(), emObj->caloPosition().y(), emObj->caloPosition().z());
       doubleConeSel_->selectCallback(pclu, *recHitsH, [&](const EcalRecHit& recIt) {
         if (recIt.energy() < energyCut_)
           return;  //dont fill if below E noise value
  
         double et =
             recIt.energy() * caloGeom->getPosition(recIt.detid()).perp() / caloGeom->getPosition(recIt.detid()).mag();
  
         bool isBarrel = false;
         if (fabs(caloGeom->getPosition(recIt.detid()).eta() < 1.479))
           isBarrel = true;
  
         if (et < etCut_)
           return;  //dont fill if below ET noise value
  
         std::vector<int>::const_iterator sit;
         int severityFlag = sevLevel->severityLevel(recIt.detid(), *recHitsH);
         if (isBarrel) {
           sit = std::find(severitiesexclEB_.begin(), severitiesexclEB_.end(), severityFlag);
           if (sit != severitiesexclEB_.end())
             return;
         } else {
           sit = std::find(severitiesexclEE_.begin(), severitiesexclEE_.end(), severityFlag);
           if (sit != severitiesexclEE_.end())
             return;
         }
  
         if (isBarrel) {
           // new rechit flag checks
           if (!(recIt.checkFlag(EcalRecHit::kGood))) {
             if (recIt.checkFlags(flagsexclEB_)) {
               return;
             }
           }
         } else {
           // new rechit flag checks
           if (!(recIt.checkFlag(EcalRecHit::kGood))) {
             if (recIt.checkFlags(flagsexclEE_)) {
               return;
             }
           }
         }
  
         if (std::find(detIdCollection->begin(), detIdCollection->end(), recIt.detid()) == detIdCollection->end())
           detIdCollection->push_back(recIt.detid());
       });  //end rechits
  
     }  //end candidates
  
     delete doubleConeSel_;
   }  //end if cone selector was created
  
   iEvent.put(std::move(detIdCollection), interestingDetIdCollection_);
 }