#include <HLTrigger/special/plugins/HLTRechitsToDigis.cc>

Inheritance diagram for HLTRechitsToDigis:

Public Types
enum	ecalRegion { invalidRegion = 0, barrel, endcap }

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 Member Functions
	HLTRechitsToDigis (const edm::ParameterSet &)

	~HLTRechitsToDigis () 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

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

static const HLTRechitsToDigis::ecalRegion	stringToRegion (const std::string &region)

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

Private Attributes
edm::EDGetTokenT< EBDigiCollection >	digisEBInToken_

edm::EDGetTokenT< EEDigiCollection >	digisEEInToken_

edm::InputTag	digisIn_

std::string	digisOut_

edm::InputTag	recHits_

edm::EDGetTokenT< EcalRecHitCollection >	recHitsToken_

ecalRegion	region_

edm::EDGetTokenT< EBSrFlagCollection >	srFlagsEBInToken_

edm::EDGetTokenT< EESrFlagCollection >	srFlagsEEInToken_

edm::InputTag	srFlagsIn_

std::string	srFlagsOut_

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 46 of file HLTRechitsToDigis.cc.

Member Enumeration Documentation

◆ ecalRegion

enum HLTRechitsToDigis::ecalRegion

Enumerator
invalidRegion
barrel
endcap

Definition at line 51 of file HLTRechitsToDigis.cc.

51 { invalidRegion = 0, barrel, endcap };

Constructor & Destructor Documentation

◆ HLTRechitsToDigis()

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

explicit

Definition at line 83 of file HLTRechitsToDigis.cc.

                                                                    {
   //region to do rechit digi matching
   region_ = stringToRegion(iConfig.getParameter<std::string>("region"));
  
   // digis to match to hit collections
   digisIn_ = iConfig.getParameter<edm::InputTag>("digisIn");
   digisOut_ = iConfig.getParameter<std::string>("digisOut");
  
   // hit collections to save digis for
   recHits_ = iConfig.getParameter<edm::InputTag>("recHits");
  
   // srFlags matched to digis to be saved
   srFlagsIn_ = iConfig.getParameter<edm::InputTag>("srFlagsIn");
   srFlagsOut_ = iConfig.getParameter<std::string>("srFlagsOut");
  
   // region specific tokens
   switch (region_) {
     case barrel:
       digisEBInToken_ = consumes<EBDigiCollection>(digisIn_);
       produces<EBDigiCollection>(digisOut_);
       // protection against empty InputTag to allow for backward compatibility
       if (not srFlagsIn_.label().empty()) {
         srFlagsEBInToken_ = consumes<EBSrFlagCollection>(srFlagsIn_);
         produces<EBSrFlagCollection>(srFlagsOut_);
       }
       break;
     case endcap:
       digisEEInToken_ = consumes<EEDigiCollection>(digisIn_);
       produces<EEDigiCollection>(digisOut_);
       // protection against empty InputTag to allow for backward compatibility
       if (not srFlagsIn_.label().empty()) {
         srFlagsEEInToken_ = consumes<EESrFlagCollection>(srFlagsIn_);
         produces<EESrFlagCollection>(srFlagsOut_);
       }
       break;
     case invalidRegion:
       break;
   }
  
   recHitsToken_ = consumes<EcalRecHitCollection>(recHits_);
 }

References barrel, digisEBInToken_, digisEEInToken_, digisIn_, digisOut_, endcap, edm::ParameterSet::getParameter(), invalidRegion, edm::InputTag::label(), recHits_, recHitsToken_, region_, srFlagsEBInToken_, srFlagsEEInToken_, srFlagsIn_, srFlagsOut_, AlCaHLTBitMon_QueryRunRegistry::string, and stringToRegion().

◆ ~HLTRechitsToDigis()

HLTRechitsToDigis::~HLTRechitsToDigis ( )

override

Definition at line 125 of file HLTRechitsToDigis.cc.

                                       {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ fillDescriptions()

void HLTRechitsToDigis::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 295 of file HLTRechitsToDigis.cc.

                                                                                    {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
  
   desc.add<std::string>("region", "barrel")
       ->setComment("Region of rechits to save Digis for. Allowed values: barrel or endcap.");
   desc.add<edm::InputTag>("digisIn", edm::InputTag("ecalDigis", "ebDigis"))
       ->setComment("The collection of either barrel or endcap digis which correspond to the rechit collection");
   desc.add<std::string>("digisOut", "pi0EBDigis")->setComment("Name for the collection of Digis saved by the module");
   desc.add<edm::InputTag>("recHits", edm::InputTag("hltAlCaPi0EBUncalibrator", "pi0EcalRecHitsEB"))
       ->setComment("Collection of rechits to match Digis to");
   desc.add<edm::InputTag>("srFlagsIn", edm::InputTag())
       ->setComment("The collection of either barrel or endcap srFlags which correspond to the rechit collection");
   desc.add<std::string>("srFlagsOut", "pi0EBSrFlags")
       ->setComment("Name for the collection of SrFlags saved by the module");
   descriptions.add("hltFindMatchingECALDigisToRechits", desc);
 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ produce()

void HLTRechitsToDigis::produce	(	edm::Event &	iEvent,
		edm::EventSetup const &	setup
	)

overrideprivate

Definition at line 143 of file HLTRechitsToDigis.cc.

                                                                             {
   using namespace edm;
   // handles for digis
   Handle<EBDigiCollection> digisEBHandle;
   Handle<EEDigiCollection> digisEEHandle;
  
   // output collections
   std::unique_ptr<EBDigiCollection> outputEBDigiCollection(new EBDigiCollection);
   std::unique_ptr<EEDigiCollection> outputEEDigiCollection(new EEDigiCollection);
  
   // handles for srFlags
   Handle<EBSrFlagCollection> srFlagsEBHandle;
   Handle<EESrFlagCollection> srFlagsEEHandle;
  
   // output collections
   std::unique_ptr<EBSrFlagCollection> outputEBSrFlagCollection(new EBSrFlagCollection);
   std::unique_ptr<EESrFlagCollection> outputEESrFlagCollection(new EESrFlagCollection);
   EcalReadoutTools ecalReadOutTool(iEvent, setup);
  
   // calibrated rechits
   Handle<EcalRecHitCollection> recHitsHandle;
   iEvent.getByToken(recHitsToken_, recHitsHandle);
  
   // match the digis based on the region
   switch (region_) {
     case barrel: {
       iEvent.getByToken(digisEBInToken_, digisEBHandle);
       const EBDigiCollection* digisEB = digisEBHandle.product();
  
       const EBSrFlagCollection* srFlagsEB = nullptr;
       // protection against uninitialized token (empty InputTag) to allow for backward compatibility
       if (not srFlagsEBInToken_.isUninitialized()) {
         iEvent.getByToken(srFlagsEBInToken_, srFlagsEBHandle);
         srFlagsEB = srFlagsEBHandle.product();
       }
  
       // loop over the collection of rechits and match to digis
       // at the same time, create the new sfFlags collection from the original one, keeping only the flags matched to digis
       EcalRecHitCollection::const_iterator ituneEB;
       for (ituneEB = recHitsHandle->begin(); ituneEB != recHitsHandle->end(); ituneEB++) {
         EcalRecHit const& hit = (*ituneEB);
         EcalDigiCollection::const_iterator digiLookUp = digisEB->find(hit.id());
         // protect against a digi not existing
         if (digiLookUp == digisEB->end())
           continue;
         outputEBDigiCollection->push_back(digiLookUp->id(), digiLookUp->begin());
  
         EBSrFlagCollection::const_iterator srFlagLookUp;
         if (not srFlagsEBInToken_.isUninitialized()) {
           // same matching for srFlags
           // firstly, get the tower id
           const EcalTrigTowerDetId& ttId = ecalReadOutTool.readOutUnitOf(static_cast<EBDetId>(hit.id()));
           // avoid inserting the same tower twice in the output collection (all the digis in the same tower will have the same SR flag)
           if (outputEBSrFlagCollection->find(ttId) != outputEBSrFlagCollection->end())
             continue;
           srFlagLookUp = srFlagsEB->find(ttId);
           // protect against a srFlag not existing
           if (srFlagLookUp == srFlagsEB->end())
             continue;
           outputEBSrFlagCollection->push_back(*srFlagLookUp);
         }
       }
  
       // add the built collection to the event
       iEvent.put(std::move(outputEBDigiCollection), digisOut_);
       if (not srFlagsEBInToken_.isUninitialized())
         iEvent.put(std::move(outputEBSrFlagCollection), srFlagsOut_);
       break;
     }
     case endcap: {
       iEvent.getByToken(digisEEInToken_, digisEEHandle);
       const EEDigiCollection* digisEE = digisEEHandle.product();
  
       const EESrFlagCollection* srFlagsEE = nullptr;
       // protection against uninitialized token (empty InputTag) to allow for backward compatibility
       if (not srFlagsEEInToken_.isUninitialized()) {
         iEvent.getByToken(srFlagsEEInToken_, srFlagsEEHandle);
         srFlagsEE = srFlagsEEHandle.product();
       }
  
       // loop over the collection of rechits and match to digis
       // at the same time, create the new sfFlags collection from the original one, keeping only the flags matched to digis
       EcalRecHitCollection::const_iterator ituneEE;
       for (ituneEE = recHitsHandle->begin(); ituneEE != recHitsHandle->end(); ituneEE++) {
         EcalRecHit const& hit = (*ituneEE);
         EcalDigiCollection::const_iterator digiLookUp = digisEE->find(hit.id());
         // protect against a digi not existing for the saved rechit
         if (digiLookUp == digisEE->end())
           continue;
         outputEEDigiCollection->push_back(digiLookUp->id(), digiLookUp->begin());
  
         EESrFlagCollection::const_iterator srFlagLookUp;
         if (not srFlagsEEInToken_.isUninitialized()) {
           // same matching for srFlags
           // firstly, get the tower id
           const EcalScDetId& scId = ecalReadOutTool.readOutUnitOf(static_cast<EEDetId>(hit.id()));
           // avoid inserting the same tower twice in the output collection (all the digis in the same tower will have the same SR flag)
           if (outputEESrFlagCollection->find(scId) != outputEESrFlagCollection->end())
             continue;
           srFlagLookUp = srFlagsEE->find(scId);
           // protect against an srFlag not existing for the saved rechit
           if (srFlagLookUp == srFlagsEE->end())
             continue;
           outputEESrFlagCollection->push_back(*srFlagLookUp);
         }
       }  // end loop over endcap rechits
  
       // add the built collection to the event
       iEvent.put(std::move(outputEEDigiCollection), digisOut_);
       if (not srFlagsEEInToken_.isUninitialized())
         iEvent.put(std::move(outputEESrFlagCollection), srFlagsOut_);
       break;
     }
     case invalidRegion: {
       break;
     }
   }  // end switch statement for the region (barrel, endcap, invalid)
 }

References barrel, edm::SortedCollection< T, SORT >::begin(), digisEBInToken_, digisEEInToken_, digisOut_, edm::SortedCollection< T, SORT >::end(), edm::DataFrameContainer::end(), endcap, edm::SortedCollection< T, SORT >::find(), edm::DataFrameContainer::find(), hit::id, iEvent, invalidRegion, eostools::move(), edm::Handle< T >::product(), EcalReadoutTools::readOutUnitOf(), recHitsToken_, region_, singleTopDQM_cfi::setup, srFlagsEBInToken_, srFlagsEEInToken_, srFlagsOut_, and ecaldqm::ttId().

◆ stringToRegion()

const HLTRechitsToDigis::ecalRegion HLTRechitsToDigis::stringToRegion ( const std::string & region )

static

Definition at line 133 of file HLTRechitsToDigis.cc.

                                                                                            {
   if (region == "barrel")
     return barrel;
   else if (region == "endcap")
     return endcap;
   else
     return invalidRegion;
 }