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

	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 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 edm::ESGetToken < CaloGeometry, CaloGeometryRecord >	caloGeometryToken_

const bool	doIsolated_

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

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

const edm::ESGetToken < L1CaloGeometry, L1CaloGeometryRecord >	l1CaloGeometryToken_

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<>
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 HLTRechitInRegionsProducer< T1 >

Definition at line 72 of file HLTRechitInRegionsProducer.cc.

Member Typedef Documentation

template<typename T1 >

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

private

Definition at line 73 of file HLTRechitInRegionsProducer.cc.

template<typename T1 >

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

private

Definition at line 74 of file HLTRechitInRegionsProducer.cc.

Constructor & Destructor Documentation

template<typename T1 >

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

Definition at line 110 of file HLTRechitInRegionsProducer.cc.

References DeDxTools::esConsumes().

     : 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")),
       caloGeometryToken_{esConsumes()},
       l1CaloGeometryToken_{esConsumes()} {
   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]);
     }
   }
 }

template<typename T1 >

HLTRechitInRegionsProducer< T1 >::~HLTRechitInRegionsProducer ( )

override

Definition at line 139 of file HLTRechitInRegionsProducer.cc.

139 {}

Member Function Documentation

template<typename T1 >

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

static

Definition at line 142 of file HLTRechitInRegionsProducer.cc.

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

                                                                                                 {
   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);
 }

template<typename T1 >

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

private

Definition at line 315 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));
     }
   }
 }

template<>

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

private

Definition at line 280 of file HLTRechitInRegionsProducer.cc.

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

                        {
   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));
     }
   }
 }

template<typename T1 >

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

override

Definition at line 166 of file HLTRechitInRegionsProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, edm::SortedCollection< T, SORT >::empty(), edm::SortedCollection< T, SORT >::end(), relativeConstraints::geometry, edm::Event::get(), edm::Event::getByToken(), edm::EventSetup::getData(), CaloSubdetectorGeometry::getGeometry(), mps_fire::i, sistrip::SpyUtilities::isValid(), eostools::move(), or, edm::Handle< T >::product(), HLT_FULL_cff::productLabels, edm::Event::put(), HLT_FULL_cff::recHits, and HLT_FULL_cff::region.

                                                                                            {
   // get the collection geometry:
   auto const& geometry = eventSetup.getData(caloGeometryToken_);
   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 CaloGeometry
   auto const& l1CaloGeom = eventSetup.getData(l1CaloGeometryToken_);
 
   std::vector<RectangularEtaPhiRegion> regions;
   if (doIsolated_)
     getEtaPhiRegions(&regions, *emIsolColl, l1CaloGeom, true);
 
   if (!doIsolated_ or (l1LowerThrIgnoreIsolation_ < 64))
     getEtaPhiRegions(&regions, evt.get(l1TokenNonIsolated_), 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>(geometry);
         } else if ((*uncalibRecHits)[0].id().subdetId() == EcalEndcap) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
           topology = std::make_unique<EcalEndcapTopology>(geometry);
         } 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>(geometry);
         } else if ((*recHits)[0].id().subdetId() == EcalEndcap) {
           geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
           topology = std::make_unique<EcalEndcapTopology>(geometry);
         } 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]);
     }
   }
 }