#include <HGCalUncalibRecHitProducer.h>

Inheritance diagram for HGCalUncalibRecHitProducer:

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

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

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

Private Attributes
const edm::EDGetTokenT< HGCalDigiCollection >	eeDigiCollection_

const std::string	eeHitCollection_

edm::EDGetTokenT< HGCalDigiCollection >	hebDigiCollection_

const std::string	hebHitCollection_

const edm::EDGetTokenT< HGCalDigiCollection >	hefDigiCollection_

const std::string	hefHitCollection_

edm::EDGetTokenT< HGCalDigiCollection >	hfnoseDigiCollection_

const std::string	hfnoseHitCollection_

std::unique_ptr< HGCalUncalibRecHitWorkerBaseClass >	worker_

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

Definition at line 13 of file HGCalUncalibRecHitProducer.h.

Constructor & Destructor Documentation

◆ HGCalUncalibRecHitProducer()

HGCalUncalibRecHitProducer::HGCalUncalibRecHitProducer ( const edm::ParameterSet & ps )

explicit

Definition at line 12 of file HGCalUncalibRecHitProducer.cc.

References get, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

     : eeDigiCollection_(consumes<HGCalDigiCollection>(ps.getParameter<edm::InputTag>("HGCEEdigiCollection"))),
       hefDigiCollection_(consumes<HGCalDigiCollection>(ps.getParameter<edm::InputTag>("HGCHEFdigiCollection"))),
       hebDigiCollection_(consumes<HGCalDigiCollection>(ps.getParameter<edm::InputTag>("HGCHEBdigiCollection"))),
       hfnoseDigiCollection_(consumes<HGCalDigiCollection>(ps.getParameter<edm::InputTag>("HGCHFNosedigiCollection"))),
       eeHitCollection_(ps.getParameter<std::string>("HGCEEhitCollection")),
       hefHitCollection_(ps.getParameter<std::string>("HGCHEFhitCollection")),
       hebHitCollection_(ps.getParameter<std::string>("HGCHEBhitCollection")),
       hfnoseHitCollection_(ps.getParameter<std::string>("HGCHFNosehitCollection")),
       worker_{HGCalUncalibRecHitWorkerFactory::get()->create(
           ps.getParameter<std::string>("algo"), ps, consumesCollector())} {
   produces<HGCeeUncalibratedRecHitCollection>(eeHitCollection_);
   produces<HGChefUncalibratedRecHitCollection>(hefHitCollection_);
   produces<HGChebUncalibratedRecHitCollection>(hebHitCollection_);
   produces<HGChfnoseUncalibratedRecHitCollection>(hfnoseHitCollection_);
 }

◆ ~HGCalUncalibRecHitProducer()

HGCalUncalibRecHitProducer::~HGCalUncalibRecHitProducer ( )

override

Definition at line 29 of file HGCalUncalibRecHitProducer.cc.

29 {}

Member Function Documentation

◆ produce()

void HGCalUncalibRecHitProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

override

Definition at line 31 of file HGCalUncalibRecHitProducer.cc.

References edm::SortedCollection< T, SORT >::begin(), eeDigiCollection_, SimL1EmulatorDM_cff::eeDigis, eeHitCollection_, edm::SortedCollection< T, SORT >::end(), edm::Event::getByToken(), hebDigiCollection_, hebHitCollection_, hefDigiCollection_, hefHitCollection_, hfnoseDigiCollection_, HGCalRawToDigi_cfi::hfnoseDigis, hfnoseHitCollection_, edm::HandleBase::isValid(), eostools::move(), edm::Handle< T >::product(), edm::Event::put(), edm::SortedCollection< T, SORT >::reserve(), edm::SortedCollection< T, SORT >::size(), and worker_.

                                                                                {
   using namespace edm;
 
   // tranparently get things from event setup
   worker_->set(es);
 
   // prepare output
   auto eeUncalibRechits = std::make_unique<HGCeeUncalibratedRecHitCollection>();
   auto hefUncalibRechits = std::make_unique<HGChefUncalibratedRecHitCollection>();
   auto hebUncalibRechits = std::make_unique<HGChebUncalibratedRecHitCollection>();
   auto hfnoseUncalibRechits = std::make_unique<HGChfnoseUncalibratedRecHitCollection>();
 
   // loop over HGCEE digis
   edm::Handle<HGCalDigiCollection> pHGCEEDigis;
   evt.getByToken(eeDigiCollection_, pHGCEEDigis);
   const HGCalDigiCollection* eeDigis = pHGCEEDigis.product();
   eeUncalibRechits->reserve(eeDigis->size());
   for (auto itdg = eeDigis->begin(); itdg != eeDigis->end(); ++itdg) {
     worker_->runHGCEE(itdg, *eeUncalibRechits);
   }
 
   // loop over HGCHEsil digis
   edm::Handle<HGCalDigiCollection> pHGCHEFDigis;
   evt.getByToken(hefDigiCollection_, pHGCHEFDigis);
   const HGCalDigiCollection* hefDigis = pHGCHEFDigis.product();
   hefUncalibRechits->reserve(hefDigis->size());
   for (auto itdg = hefDigis->begin(); itdg != hefDigis->end(); ++itdg) {
     worker_->runHGCHEsil(itdg, *hefUncalibRechits);
   }
 
   // loop over HGCHEscint digis
   edm::Handle<HGCalDigiCollection> pHGCHEBDigis;
   evt.getByToken(hebDigiCollection_, pHGCHEBDigis);
   const HGCalDigiCollection* hebDigis = pHGCHEBDigis.product();
   hebUncalibRechits->reserve(hebDigis->size());
   for (auto itdg = hebDigis->begin(); itdg != hebDigis->end(); ++itdg) {
     worker_->runHGCHEscint(itdg, *hebUncalibRechits);
   }
 
   // loop over HFNose digis
   edm::Handle<HGCalDigiCollection> pHGCHFNoseDigis;
   evt.getByToken(hfnoseDigiCollection_, pHGCHFNoseDigis);
   if (pHGCHFNoseDigis.isValid()) {
     const HGCalDigiCollection* hfnoseDigis = pHGCHFNoseDigis.product();
     if (!(hfnoseDigis->empty())) {
       hfnoseUncalibRechits->reserve(hfnoseDigis->size());
       for (auto itdg = hfnoseDigis->begin(); itdg != hfnoseDigis->end(); ++itdg)
         worker_->runHGCHFNose(itdg, *hfnoseUncalibRechits);
     }
   }
 
   // put the collection of recunstructed hits in the event
   evt.put(std::move(eeUncalibRechits), eeHitCollection_);
   evt.put(std::move(hefUncalibRechits), hefHitCollection_);
   evt.put(std::move(hebUncalibRechits), hebHitCollection_);
   if (pHGCHFNoseDigis.isValid())
     evt.put(std::move(hfnoseUncalibRechits), hfnoseHitCollection_);
 }