Inheritance diagram for HLTRechitInRegionsProducer< T1 >:

Public Member Functions
	HLTRechitInRegionsProducer (const edm::ParameterSet &ps)

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

	~HLTRechitInRegionsProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Types
typedef std::vector< T1 >	T1Collection

typedef T1::const_iterator	T1iterator

Private Member Functions
void	getEtaPhiRegions (std::vector< RectangularEtaPhiRegion > *, T1Collection, const L1CaloGeometry &, bool)

template<>
void	getEtaPhiRegions (std::vector< RectangularEtaPhiRegion > *theRegions, T1Collection theCandidateCollection, const L1CaloGeometry &l1CaloGeom, bool isolatedCase)

Private Attributes
const bool	doIsolated_

const std::vector< edm::InputTag >	hitLabels

std::vector< edm::EDGetTokenT< EcalRecHitCollection > >	hitTokens

const double	l1LowerThr_

const double	l1LowerThrIgnoreIsolation_

const edm::EDGetTokenT< T1Collection >	l1TokenIsolated_

const edm::EDGetTokenT< T1Collection >	l1TokenNonIsolated_

const double	l1UpperThr_

const std::vector< std::string >	productLabels

const double	regionEtaMargin_

const double	regionPhiMargin_

std::vector< edm::EDGetTokenT< EcalUncalibratedRecHitCollection > >	uncalibHitTokens

const bool	useUncalib_

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

template<typename T1>
class HLTRechitInRegionsProducer< T1 >

Definition at line 72 of file HLTRechitInRegionsProducer.cc.

Member Typedef Documentation

◆ T1Collection

template<typename T1 >

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

private

Definition at line 73 of file HLTRechitInRegionsProducer.cc.

◆ T1iterator

template<typename T1 >

typedef T1::const_iterator HLTRechitInRegionsProducer< T1 >::T1iterator

private

Definition at line 74 of file HLTRechitInRegionsProducer.cc.

Constructor & Destructor Documentation

◆ HLTRechitInRegionsProducer()

template<typename T1 >

HLTRechitInRegionsProducer< T1 >::HLTRechitInRegionsProducer ( const edm::ParameterSet & ps )

Definition at line 107 of file HLTRechitInRegionsProducer.cc.

     : useUncalib_(ps.getParameter<bool>("useUncalib")),
       doIsolated_(ps.getParameter<bool>("doIsolated")),
       l1TokenIsolated_(doIsolated_ ? consumes<T1Collection>(ps.getParameter<edm::InputTag>("l1TagIsolated"))
                                    : edm::EDGetTokenT<T1Collection>()),
       l1TokenNonIsolated_(consumes<T1Collection>(ps.getParameter<edm::InputTag>("l1TagNonIsolated"))),
       l1LowerThr_(ps.getParameter<double>("l1LowerThr")),
       l1UpperThr_(ps.getParameter<double>("l1UpperThr")),
       l1LowerThrIgnoreIsolation_(ps.getParameter<double>("l1LowerThrIgnoreIsolation")),
       regionEtaMargin_(ps.getParameter<double>("regionEtaMargin")),
       regionPhiMargin_(ps.getParameter<double>("regionPhiMargin")),
       hitLabels(ps.getParameter<std::vector<edm::InputTag>>("ecalhitLabels")),
       productLabels(ps.getParameter<std::vector<std::string>>("productLabels")) {
   if (useUncalib_) {
     for (unsigned int i = 0; i < hitLabels.size(); i++) {
       uncalibHitTokens.push_back(consumes<EcalUncalibratedRecHitCollection>(hitLabels[i]));
       produces<EcalUncalibratedRecHitCollection>(productLabels[i]);
     }
   } else {
     for (unsigned int i = 0; i < hitLabels.size(); i++) {
       hitTokens.push_back(consumes<EcalRecHitCollection>(hitLabels[i]));
       produces<EcalRecHitCollection>(productLabels[i]);
     }
   }
 }

References HLTRechitInRegionsProducer< T1 >::hitLabels, HLTRechitInRegionsProducer< T1 >::hitTokens, mps_fire::i, HLTRechitInRegionsProducer< T1 >::productLabels, HLTRechitInRegionsProducer< T1 >::uncalibHitTokens, and HLTRechitInRegionsProducer< T1 >::useUncalib_.

◆ ~HLTRechitInRegionsProducer()

template<typename T1 >

HLTRechitInRegionsProducer< T1 >::~HLTRechitInRegionsProducer ( )

override

Definition at line 134 of file HLTRechitInRegionsProducer.cc.

134 {}

Member Function Documentation

◆ fillDescriptions()

template<typename T1 >

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

static

Definition at line 137 of file HLTRechitInRegionsProducer.cc.

                                                                                                 {
   edm::ParameterSetDescription desc;
   std::vector<std::string> productTags;
   productTags.push_back("EcalRegionalRecHitsEB");
   productTags.push_back("EcalRegionalRecHitsEE");
   desc.add<std::vector<std::string>>("productLabels", productTags);
   std::vector<edm::InputTag> inputTags;
   inputTags.push_back(edm::InputTag("hltEcalRegionalEgammaRecHit:EcalRecHitsEB"));
   inputTags.push_back(edm::InputTag("hltEcalRegionalEgammaRecHit:EcalRecHitsEE"));
   inputTags.push_back(edm::InputTag("hltESRegionalEgammaRecHit:EcalRecHitsES"));
   desc.add<std::vector<edm::InputTag>>("ecalhitLabels", inputTags);
   desc.add<edm::InputTag>("l1TagIsolated", edm::InputTag("l1extraParticles", "Isolated"));
   desc.add<edm::InputTag>("l1TagNonIsolated", edm::InputTag("l1extraParticles", "NonIsolated"));
   desc.add<bool>("useUncalib", true);
   desc.add<bool>("doIsolated", true);
   desc.add<double>("l1LowerThr", 5.0);
   desc.add<double>("l1UpperThr", 999.);
   desc.add<double>("l1LowerThrIgnoreIsolation", 0.0);
   desc.add<double>("regionEtaMargin", 0.14);
   desc.add<double>("regionPhiMargin", 0.4);
   descriptions.add(defaultModuleLabel<HLTRechitInRegionsProducer<T1>>(), desc);
 }

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), defaultModuleLabel(), HLT_2018_cff::InputTag, and HLTMuonOfflineAnalyzer_cfi::inputTags.

◆ getEtaPhiRegions() [1/2]

template<typename T1 >

void HLTRechitInRegionsProducer< T1 >::getEtaPhiRegions	(	std::vector< RectangularEtaPhiRegion > *	theRegions,
		T1Collection	theCandidateCollection,
		const L1CaloGeometry &	l1CaloGeom,
		bool	isolatedCase
	)

private

Definition at line 317 of file HLTRechitInRegionsProducer.cc.

                                                                          {
   for (unsigned int candItr = 0; candItr < theCandidateCollection.size(); candItr++) {
     T1 emItr = theCandidateCollection.at(candItr);
     if ((emItr.et() > l1LowerThr_) and (emItr.et() < l1UpperThr_)) {
       double etaLow = emItr.eta() - regionEtaMargin_;
       double etaHigh = emItr.eta() + regionEtaMargin_;
       double phiLow = emItr.phi() - regionPhiMargin_;
       double phiHigh = emItr.phi() + regionPhiMargin_;
  
       theRegions->push_back(RectangularEtaPhiRegion(etaLow, etaHigh, phiLow, phiHigh));
     }
   }
 }

References gemEfficiencyAnalyzer_cfi::etaHigh, gemEfficiencyAnalyzer_cfi::etaLow, and l1tSlwPFPuppiJets_cfi::phiLow.

◆ getEtaPhiRegions() [2/2]

template<>

void HLTRechitInRegionsProducer< l1extra::L1EmParticle >::getEtaPhiRegions	(	std::vector< RectangularEtaPhiRegion > *	theRegions,
		T1Collection	theCandidateCollection,
		const L1CaloGeometry &	l1CaloGeom,
		bool	isolatedCase
	)

private

Definition at line 282 of file HLTRechitInRegionsProducer.cc.

                        {
   for (unsigned int candItr = 0; candItr < theCandidateCollection.size(); candItr++) {
     l1extra::L1EmParticle emItr = theCandidateCollection.at(candItr);
  
     if (!isolatedCase) {
       if (doIsolated_ and (emItr.et() < l1LowerThrIgnoreIsolation_))
         continue;
     }
  
     if ((emItr.et() > l1LowerThr_) and (emItr.et() < l1UpperThr_)) {
       // Access the GCT hardware object corresponding to the L1Extra EM object.
       int etaIndex = emItr.gctEmCand()->etaIndex();
       int phiIndex = emItr.gctEmCand()->phiIndex();
  
       // Use the L1CaloGeometry to find the eta, phi bin boundaries.
       double etaLow = l1CaloGeom.etaBinLowEdge(etaIndex);
       double etaHigh = l1CaloGeom.etaBinHighEdge(etaIndex);
       double phiLow = l1CaloGeom.emJetPhiBinLowEdge(phiIndex);
       double phiHigh = l1CaloGeom.emJetPhiBinHighEdge(phiIndex);
  
       etaLow -= regionEtaMargin_;
       etaHigh += regionEtaMargin_;
       phiLow -= regionPhiMargin_;
       phiHigh += regionPhiMargin_;
  
       theRegions->push_back(RectangularEtaPhiRegion(etaLow, etaHigh, phiLow, phiHigh));
     }
   }
 }

References L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), reco::LeafCandidate::et(), L1CaloGeometry::etaBinHighEdge(), L1CaloGeometry::etaBinLowEdge(), gemEfficiencyAnalyzer_cfi::etaHigh, L1GctEmCand::etaIndex(), gemEfficiencyAnalyzer_cfi::etaLow, l1extra::L1EmParticle::gctEmCand(), L1GctEmCand::phiIndex(), and l1tSlwPFPuppiJets_cfi::phiLow.

◆ produce()

template<typename T1 >

void HLTRechitInRegionsProducer< T1 >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 161 of file HLTRechitInRegionsProducer.cc.

                                                                                    {
   // get the collection geometry:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   const CaloSubdetectorGeometry* geometry_p;
   std::unique_ptr<const CaloSubdetectorTopology> topology;
  
   //Get the L1 EM Particle Collection
   edm::Handle<T1Collection> emIsolColl;
   if (doIsolated_) {
     evt.getByToken(l1TokenIsolated_, emIsolColl);
   }
  
   //Get the L1 EM Particle Collection
   edm::Handle<T1Collection> emNonIsolColl;
   evt.getByToken(l1TokenNonIsolated_, emNonIsolColl);
  
   // Get the CaloGeometry
   edm::ESHandle<L1CaloGeometry> l1CaloGeom;
   es.get<L1CaloGeometryRecord>().get(l1CaloGeom);
  
   std::vector<RectangularEtaPhiRegion> regions;
   if (doIsolated_)
     getEtaPhiRegions(&regions, *emIsolColl, *l1CaloGeom, true);
  
   if (!doIsolated_ or (l1LowerThrIgnoreIsolation_ < 64))
     getEtaPhiRegions(&regions, *emNonIsolColl, *l1CaloGeom, false);
  
   if (useUncalib_) {
     edm::Handle<EcalUncalibratedRecHitCollection> urhcH[3];
     for (unsigned int i = 0; i < hitLabels.size(); i++) {
       auto uhits = std::make_unique<EcalUncalibratedRecHitCollection>();
  
       evt.getByToken(uncalibHitTokens[i], urhcH[i]);
       if (!(urhcH[i].isValid())) {
         edm::LogError("ProductNotFound") << "could not get a handle on the EcalRecHitCollection! ("
                                          << hitLabels[i].encode() << ")" << std::endl;
         return;
       }
       const EcalUncalibratedRecHitCollection* uncalibRecHits = urhcH[i].product();
  
       if (!uncalibRecHits->empty()) {
         if ((*uncalibRecHits)[0].id().subdetId() == EcalBarrel) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
           topology = std::make_unique<EcalBarrelTopology>(*geoHandle);
         } else if ((*uncalibRecHits)[0].id().subdetId() == EcalEndcap) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
           topology = std::make_unique<EcalEndcapTopology>(*geoHandle);
         } else if ((*uncalibRecHits)[0].id().subdetId() == EcalPreshower) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
           topology = std::make_unique<EcalPreshowerTopology>();
         } else
           throw(std::runtime_error("\n\nProducer encountered invalied ecalhitcollection type.\n\n"));
  
         if (!regions.empty()) {
           EcalUncalibratedRecHitCollection::const_iterator it;
  
           for (it = uncalibRecHits->begin(); it != uncalibRecHits->end(); it++) {
             auto this_cell = geometry_p->getGeometry(it->id());
  
             std::vector<RectangularEtaPhiRegion>::const_iterator region;
             for (region = regions.begin(); region != regions.end(); region++) {
               if (region->inRegion(this_cell->etaPos(), this_cell->phiPos())) {
                 uhits->push_back(*it);
                 break;
               }
             }
           }
         }
       }
       evt.put(std::move(uhits), productLabels[i]);
     }
  
   } else {
     edm::Handle<EcalRecHitCollection> rhcH[3];
     for (unsigned int i = 0; i < hitLabels.size(); i++) {
       auto hits = std::make_unique<EcalRecHitCollection>();
  
       evt.getByToken(hitTokens[i], rhcH[i]);
       if (!(rhcH[i].isValid())) {
         edm::LogError("ProductNotFound") << "could not get a handle on the EcalRecHitCollection! ("
                                          << hitLabels[i].encode() << ")" << std::endl;
         return;
       }
       const EcalRecHitCollection* recHits = rhcH[i].product();
  
       if (!recHits->empty()) {
         if ((*recHits)[0].id().subdetId() == EcalBarrel) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
           topology = std::make_unique<EcalBarrelTopology>(*geoHandle);
         } else if ((*recHits)[0].id().subdetId() == EcalEndcap) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
           topology = std::make_unique<EcalEndcapTopology>(*geoHandle);
         } else if ((*recHits)[0].id().subdetId() == EcalPreshower) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
           topology = std::make_unique<EcalPreshowerTopology>();
         } else
           throw(std::runtime_error("\n\nProducer encountered invalied ecalhitcollection type.\n\n"));
  
         if (!regions.empty()) {
           EcalRecHitCollection::const_iterator it;
           for (it = recHits->begin(); it != recHits->end(); it++) {
             auto this_cell = geometry_p->getGeometry(it->id());
  
             std::vector<RectangularEtaPhiRegion>::const_iterator region;
             for (region = regions.begin(); region != regions.end(); region++) {
               if (region->inRegion(this_cell->etaPos(), this_cell->phiPos())) {
                 hits->push_back(*it);
                 break;
               }
             }
           }
         }
       }
       evt.put(std::move(hits), productLabels[i]);
     }
   }
 }