HGCalRecHitProducer Class Reference

Inheritance diagram for HGCalRecHitProducer:

Public Member Functions
	HGCalRecHitProducer (const edm::ParameterSet &ps)
void	produce (edm::Event &evt, const edm::EventSetup &es) override
	~HGCalRecHitProducer () 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

Private Attributes
const std::string	eeRechitCollection_
const edm::EDGetTokenT< HGCeeUncalibratedRecHitCollection >	eeUncalibRecHitCollection_
const std::string	hebRechitCollection_
const edm::EDGetTokenT< HGChebUncalibratedRecHitCollection >	hebUncalibRecHitCollection_
const std::string	hefRechitCollection_
const edm::EDGetTokenT< HGChefUncalibratedRecHitCollection >	hefUncalibRecHitCollection_
const std::string	hfnoseRechitCollection_
const edm::EDGetTokenT< HGChfnoseUncalibratedRecHitCollection >	hfnoseUncalibRecHitCollection_
std::unique_ptr< HGCalRecHitWorkerBaseClass >	worker_

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

Detailed Description

produce HGCAL rechits from uncalibrated rechits

simplified version of Ecal code

Author

Valeri Andreev (ported to 76X by L. Gray, add HFNose by Sunanda)

Definition at line 26 of file HGCalRecHitProducer.cc.

Constructor & Destructor Documentation

HGCalRecHitProducer()

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

explicit

Definition at line 45 of file HGCalRecHitProducer.cc.

    : eeUncalibRecHitCollection_(
          consumes<HGCeeUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("HGCEEuncalibRecHitCollection"))),
      hefUncalibRecHitCollection_(consumes<HGChefUncalibratedRecHitCollection>(
          ps.getParameter<edm::InputTag>("HGCHEFuncalibRecHitCollection"))),
      hebUncalibRecHitCollection_(consumes<HGChebUncalibratedRecHitCollection>(
          ps.getParameter<edm::InputTag>("HGCHEBuncalibRecHitCollection"))),
      hfnoseUncalibRecHitCollection_(consumes<HGChfnoseUncalibratedRecHitCollection>(
          ps.getParameter<edm::InputTag>("HGCHFNoseuncalibRecHitCollection"))),
      eeRechitCollection_(ps.getParameter<std::string>("HGCEErechitCollection")),
      hefRechitCollection_(ps.getParameter<std::string>("HGCHEFrechitCollection")),
      hebRechitCollection_(ps.getParameter<std::string>("HGCHEBrechitCollection")),
      hfnoseRechitCollection_(ps.getParameter<std::string>("HGCHFNoserechitCollection")),
      worker_{HGCalRecHitWorkerFactory::get()->create(ps.getParameter<std::string>("algo"), ps)} {
  produces<HGCeeRecHitCollection>(eeRechitCollection_);
  produces<HGChefRecHitCollection>(hefRechitCollection_);
  produces<HGChebRecHitCollection>(hebRechitCollection_);
  produces<HGChfnoseRecHitCollection>(hfnoseRechitCollection_);
}

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

~HGCalRecHitProducer()

HGCalRecHitProducer::~HGCalRecHitProducer ( )

override

Definition at line 65 of file HGCalRecHitProducer.cc.

{}

Member Function Documentation

produce()

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

override

Definition at line 67 of file HGCalRecHitProducer.cc.

                                                                        {
  using namespace edm;
 
  Handle<HGCeeUncalibratedRecHitCollection> pHGCeeUncalibRecHits;
  Handle<HGChefUncalibratedRecHitCollection> pHGChefUncalibRecHits;
  Handle<HGChebUncalibratedRecHitCollection> pHGChebUncalibRecHits;
  Handle<HGChfnoseUncalibratedRecHitCollection> pHGChfnoseUncalibRecHits;
 
  const HGCeeUncalibratedRecHitCollection* eeUncalibRecHits = nullptr;
  const HGChefUncalibratedRecHitCollection* hefUncalibRecHits = nullptr;
  const HGChebUncalibratedRecHitCollection* hebUncalibRecHits = nullptr;
  const HGChfnoseUncalibratedRecHitCollection* hfnoseUncalibRecHits = nullptr;
 
  // get the HGC uncalib rechit collection
  evt.getByToken(eeUncalibRecHitCollection_, pHGCeeUncalibRecHits);
  eeUncalibRecHits = pHGCeeUncalibRecHits.product();
 
  evt.getByToken(hefUncalibRecHitCollection_, pHGChefUncalibRecHits);
  hefUncalibRecHits = pHGChefUncalibRecHits.product();
 
  evt.getByToken(hebUncalibRecHitCollection_, pHGChebUncalibRecHits);
  hebUncalibRecHits = pHGChebUncalibRecHits.product();
 
  evt.getByToken(hfnoseUncalibRecHitCollection_, pHGChfnoseUncalibRecHits);
  if (pHGChfnoseUncalibRecHits.isValid())
    hfnoseUncalibRecHits = pHGChfnoseUncalibRecHits.product();
 
  // collection of rechits to put in the event
  auto eeRecHits = std::make_unique<HGCeeRecHitCollection>();
  auto hefRecHits = std::make_unique<HGChefRecHitCollection>();
  auto hebRecHits = std::make_unique<HGChebRecHitCollection>();
 
  worker_->set(es);
 
  // loop over uncalibrated rechits to make calibrated ones
  for (auto it = eeUncalibRecHits->begin(); it != eeUncalibRecHits->end(); ++it) {
    worker_->run(evt, *it, *eeRecHits);
  }
 
  // loop over uncalibrated rechits to make calibrated ones
  for (auto it = hefUncalibRecHits->begin(); it != hefUncalibRecHits->end(); ++it) {
    worker_->run(evt, *it, *hefRecHits);
  }
 
  // loop over uncalibrated rechits to make calibrated ones
  for (auto it = hebUncalibRecHits->begin(); it != hebUncalibRecHits->end(); ++it) {
    worker_->run(evt, *it, *hebRecHits);
  }
 
  // sort collections before attempting recovery, to avoid insertion of double recHits
  eeRecHits->sort();
  hefRecHits->sort();
  hebRecHits->sort();
 
  // put the collection of recunstructed hits in the event
  LogInfo("HGCalRecHitInfo") << "total # HGCee calibrated rechits: " << eeRecHits->size();
  LogInfo("HGCalRecHitInfo") << "total # HGChef calibrated rechits: " << hefRecHits->size();
  LogInfo("HGCalRecHitInfo") << "total # HGCheb calibrated rechits: " << hebRecHits->size();
 
  evt.put(std::move(eeRecHits), eeRechitCollection_);
  evt.put(std::move(hefRecHits), hefRechitCollection_);
  evt.put(std::move(hebRecHits), hebRechitCollection_);
 
  // do the same for HFNose hits
  if (pHGChfnoseUncalibRecHits.isValid()) {
    auto hfnoseRecHits = std::make_unique<HGChfnoseRecHitCollection>();
    for (auto it = hfnoseUncalibRecHits->begin(); it != hfnoseUncalibRecHits->end(); ++it) {
      worker_->run(evt, *it, *hfnoseRecHits);
    }
    hfnoseRecHits->sort();
    LogInfo("HGCalRecHitInfo") << "total # HGChfnose calibrated rechits: " << hfnoseRecHits->size();
    evt.put(std::move(hfnoseRecHits), hfnoseRechitCollection_);
  }
}

References edm::SortedCollection< T, SORT >::begin(), eeRechitCollection_, eeUncalibRecHitCollection_, edm::SortedCollection< T, SORT >::end(), edm::Event::getByToken(), hebRechitCollection_, hebUncalibRecHitCollection_, hefRechitCollection_, hefUncalibRecHitCollection_, hfnoseRechitCollection_, hfnoseUncalibRecHitCollection_, edm::HandleBase::isValid(), eostools::move(), edm::Handle< T >::product(), edm::Event::put(), and worker_.

Member Data Documentation

eeRechitCollection_

const std::string HGCalRecHitProducer::eeRechitCollection_

private

Definition at line 37 of file HGCalRecHitProducer.cc.

Referenced by produce().

eeUncalibRecHitCollection_

const edm::EDGetTokenT<HGCeeUncalibratedRecHitCollection> HGCalRecHitProducer::eeUncalibRecHitCollection_

private

Definition at line 33 of file HGCalRecHitProducer.cc.

Referenced by produce().

hebRechitCollection_

const std::string HGCalRecHitProducer::hebRechitCollection_

private

Definition at line 39 of file HGCalRecHitProducer.cc.

Referenced by produce().

hebUncalibRecHitCollection_

const edm::EDGetTokenT<HGChebUncalibratedRecHitCollection> HGCalRecHitProducer::hebUncalibRecHitCollection_

private

Definition at line 35 of file HGCalRecHitProducer.cc.

Referenced by produce().

hefRechitCollection_

const std::string HGCalRecHitProducer::hefRechitCollection_

private

Definition at line 38 of file HGCalRecHitProducer.cc.

Referenced by produce().

hefUncalibRecHitCollection_

const edm::EDGetTokenT<HGChefUncalibratedRecHitCollection> HGCalRecHitProducer::hefUncalibRecHitCollection_

private

Definition at line 34 of file HGCalRecHitProducer.cc.

Referenced by produce().

hfnoseRechitCollection_

const std::string HGCalRecHitProducer::hfnoseRechitCollection_

private

Definition at line 40 of file HGCalRecHitProducer.cc.

Referenced by produce().

hfnoseUncalibRecHitCollection_

const edm::EDGetTokenT<HGChfnoseUncalibratedRecHitCollection> HGCalRecHitProducer::hfnoseUncalibRecHitCollection_

private

Definition at line 36 of file HGCalRecHitProducer.cc.

Referenced by produce().

worker_

std::unique_ptr<HGCalRecHitWorkerBaseClass> HGCalRecHitProducer::worker_

private

Definition at line 42 of file HGCalRecHitProducer.cc.

Referenced by produce().