#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	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () 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(), edm::ParameterSetDescription::add(), HLT_2018_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;
 }