#include <HLTRechitInRegionsProducer.h>

Inheritance diagram for HLTRechitInRegionsProducer< T1 >:

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

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

	~HLTRechitInRegionsProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
typedef std::vector< T1 >	T1Collection

typedef T1::const_iterator	T1iterator

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

template<>
void	getEtaPhiRegions (std::vector< EcalEtaPhiRegion > *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::InputTag	l1TagIsolated_

const edm::InputTag	l1TagNonIsolated_

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

template<typename T1>
class HLTRechitInRegionsProducer< T1 >

Definition at line 35 of file HLTRechitInRegionsProducer.h.

Member Typedef Documentation

template<typename T1 >

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

private

Definition at line 36 of file HLTRechitInRegionsProducer.h.

template<typename T1 >

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

private

Definition at line 37 of file HLTRechitInRegionsProducer.h.

Constructor & Destructor Documentation

template<typename T1 >

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

Definition at line 45 of file HLTRechitInRegionsProducer.cc.

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

                                                                                    :
   useUncalib_      (ps.getParameter<bool>("useUncalib")),
   l1TagIsolated_   (ps.getParameter< edm::InputTag > ("l1TagIsolated")),
   l1TagNonIsolated_(ps.getParameter< edm::InputTag > ("l1TagNonIsolated")),
   doIsolated_      (ps.getParameter<bool>("doIsolated")),
   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]);
     }
   }
 }

template<typename T1 >

HLTRechitInRegionsProducer< T1 >::~HLTRechitInRegionsProducer ( )

Definition at line 72 of file HLTRechitInRegionsProducer.cc.

73 {}

Member Function Documentation

template<typename T1 >

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

static

Definition at line 76 of file HLTRechitInRegionsProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), defaultModuleLabel(), and HLT_25ns14e33_v1_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< EcalEtaPhiRegion > *	theRegions,
		T1Collection	theCandidateCollection,
		const L1CaloGeometry &	l1CaloGeom,
		bool	isolatedCase
	)

private

Definition at line 255 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(EcalEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));
         }
     }
 }

template<>

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

private

Definition at line 222 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(EcalEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));
         }
     }
 }

template<typename T1 >

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 100 of file HLTRechitInRegionsProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, edm::SortedCollection< T, SORT >::end(), geometry, edm::EventSetup::get(), edm::Event::getByLabel(), edm::Event::getByToken(), CaloCellGeometry::getPosition(), CaloGeometry::getSubdetectorGeometry(), i, or, position, edm::Handle< T >::product(), HLT_25ns14e33_v1_cff::productLabels, edm::Event::put(), edm::SortedCollection< T, SORT >::size(), and ecaldqm::topology().

                                                                                    {
 
   // get the collection geometry:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   const CaloSubdetectorGeometry *geometry_p;
   std::auto_ptr<const CaloSubdetectorTopology> topology;
     
   //Get the L1 EM Particle Collection
   edm::Handle< T1Collection > emIsolColl ;
   if(doIsolated_) 
     evt.getByLabel(l1TagIsolated_, emIsolColl);
 
   //Get the L1 EM Particle Collection
   edm::Handle< T1Collection > emNonIsolColl ;
   evt.getByLabel(l1TagNonIsolated_, emNonIsolColl);
   
   // Get the CaloGeometry
   edm::ESHandle<L1CaloGeometry> l1CaloGeom ;
   es.get<L1CaloGeometryRecord>().get(l1CaloGeom) ;
 
   std::vector<EcalEtaPhiRegion> 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++) {
       std::auto_ptr<EcalUncalibratedRecHitCollection> uhits(new 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->size() > 0) {
     if ((*uncalibRecHits)[0].id().subdetId() == EcalBarrel) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
       topology.reset(new EcalBarrelTopology(geoHandle));
     } else if ((*uncalibRecHits)[0].id().subdetId() == EcalEndcap) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
       topology.reset(new EcalEndcapTopology(geoHandle));
     } else if ((*uncalibRecHits)[0].id().subdetId() == EcalPreshower) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
       topology.reset(new EcalPreshowerTopology (geoHandle));
     } else throw(std::runtime_error("\n\nProducer encountered invalied ecalhitcollection type.\n\n"));
     
     if(regions.size() != 0) {
       EcalUncalibratedRecHitCollection::const_iterator it;
       
       for (it = uncalibRecHits->begin(); it != uncalibRecHits->end(); it++){
         const CaloCellGeometry *this_cell = (*geometry_p).getGeometry(it->id());
         GlobalPoint position = this_cell->getPosition();
         
         std::vector<EcalEtaPhiRegion>::const_iterator region;
         for (region=regions.begin(); region!=regions.end(); region++) {
           if (region->inRegion(position)) {
         uhits->push_back(*it);
         break;
           }
         }
       }
     }
       }
       evt.put(uhits, productLabels[i]);
 
     }
 
   } else {
 
     edm::Handle<EcalRecHitCollection> rhcH[3];
     for (unsigned int i=0; i<hitLabels.size(); i++) {
       std::auto_ptr<EcalRecHitCollection> hits(new 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->size() > 0) {
     if ((*recHits)[0].id().subdetId() == EcalBarrel) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
       topology.reset(new EcalBarrelTopology(geoHandle));
     } else if ((*recHits)[0].id().subdetId() == EcalEndcap) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
       topology.reset(new EcalEndcapTopology(geoHandle));
     } else if ((*recHits)[0].id().subdetId() == EcalPreshower) {
       geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
       topology.reset(new EcalPreshowerTopology (geoHandle));
     } else throw(std::runtime_error("\n\nProducer encountered invalied ecalhitcollection type.\n\n"));
     
     if(regions.size() != 0) {
       EcalRecHitCollection::const_iterator it;  
       for (it = recHits->begin(); it != recHits->end(); it++){
         const CaloCellGeometry *this_cell = (*geometry_p).getGeometry(it->id());
         GlobalPoint position = this_cell->getPosition();
         
         std::vector<EcalEtaPhiRegion>::const_iterator region;
         for (region=regions.begin(); region!=regions.end(); region++) {
           if (region->inRegion(position)) {
         hits->push_back(*it);
         break;
           }
         }
       }
     }
       }
       evt.put(hits, productLabels[i]);
 
     }
   }
 }