#include <GamIsoDetIdCollectionProducer.h>

Inheritance diagram for GamIsoDetIdCollectionProducer:

Public Member Functions
void	beginJob ()

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

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

	~GamIsoDetIdCollectionProducer () 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::EDGetTokenT< reco::PhotonCollection >	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::EDGetTokenT< EcalRecHitCollection >	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 41 of file GamIsoDetIdCollectionProducer.h.

Constructor & Destructor Documentation

◆ GamIsoDetIdCollectionProducer()

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

explicit

ctor

Definition at line 27 of file GamIsoDetIdCollectionProducer.cc.

     : recHitsToken_(consumes<EcalRecHitCollection>(iConfig.getParameter<edm::InputTag>("recHitsLabel"))),
       emObjectToken_(consumes<reco::PhotonCollection>(iConfig.getParameter<edm::InputTag>("emObjectLabel"))),
       caloGeometryToken_(esConsumes()),
       sevLvToken_(esConsumes()),
       //the labels are still used to decide if its endcap or barrel...
       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_.

◆ ~GamIsoDetIdCollectionProducer()

GamIsoDetIdCollectionProducer::~GamIsoDetIdCollectionProducer ( )

override

Definition at line 65 of file GamIsoDetIdCollectionProducer.cc.

65 {}

Member Function Documentation

◆ beginJob()

void GamIsoDetIdCollectionProducer::beginJob ( void )

Definition at line 67 of file GamIsoDetIdCollectionProducer.cc.

67 {}

◆ produce()

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

override

producer

Definition at line 70 of file GamIsoDetIdCollectionProducer.cc.

                                                                                          {
   using namespace edm;
   using namespace std;
  
   //Get EM Object
   Handle<reco::PhotonCollection> 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();
  
   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::PhotonCollection::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;
  
       GlobalPoint pclu(emObj->caloPosition().x(), emObj->caloPosition().y(), emObj->caloPosition().z());
       doubleConeSel_->selectCallback(pclu, *recHitsH, [&](const EcalRecHit& recHitRef) {
         const EcalRecHit* recIt = &recHitRef;
  
         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();
  
         if (et < etCut_)
           return;  //dont fill if below ET noise value
  
         bool isBarrel = false;
         if (fabs(caloGeom->getPosition(recIt->detid()).eta() < 1.479))
           isBarrel = true;
  
         int severityFlag = sevLevel->severityLevel(recIt->detid(), *recHitsH);
         std::vector<int>::const_iterator sit;
         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_);
 }