#include <HcalSimpleReconstructor.h>

Inheritance diagram for HcalSimpleReconstructor:

Public Member Functions
void	beginRun (edm::Run const &r, edm::EventSetup const &es) final

void	endRun (edm::Run const &r, edm::EventSetup const &es) final

	HcalSimpleReconstructor (const edm::ParameterSet &ps)

void	produce (edm::Event &e, const edm::EventSetup &c) final

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

Private Member Functions
template<class DIGICOLL , class RECHITCOLL >
void	process (edm::Event &e, const edm::EventSetup &c, const edm::EDGetTokenT< DIGICOLL > &tok)

Private Attributes
DetId::Detector	det_

bool	dropZSmarkedPassed_

int	firstSample_

edm::InputTag	inputLabel_

HcalRecoParams *	paramTS

HcalSimpleRecAlgo	reco_

int	samplesToAdd_

int	subdet_

HcalOtherSubdetector	subdetOther_

HcalTopology *	theTopology

edm::EDGetTokenT< HcalCalibDigiCollection >	tok_calib_

edm::EDGetTokenT< HFDigiCollection >	tok_hf_

edm::EDGetTokenT< HODigiCollection >	tok_ho_

bool	tsFromDB_

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

Author: J. Mans - Minnesota; E. Garcia - CSU Based on HcalSimpleReconstructor.h by J. Mans

Definition at line 26 of file HcalSimpleReconstructor.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 16 of file HcalSimpleReconstructor.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), HcalForward, HcalOuter, inputLabel_, AlCaHLTBitMon_QueryRunRegistry::string, subdet_, tok_calib_, tok_hf_, and tok_ho_.

     : reco_(conf.getParameter<bool>("correctForTimeslew"),
             conf.getParameter<bool>("correctForPhaseContainment"),
             conf.getParameter<double>("correctionPhaseNS")),
       det_(DetId::Hcal),
       inputLabel_(conf.getParameter<edm::InputTag>("digiLabel")),
       dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")),
       firstSample_(conf.getParameter<int>("firstSample")),
       samplesToAdd_(conf.getParameter<int>("samplesToAdd")),
       tsFromDB_(conf.getParameter<bool>("tsFromDB")),
       paramTS(nullptr),
       theTopology(nullptr) {
   // register for data access
   tok_hf_ = consumes<HFDigiCollection>(inputLabel_);
   tok_ho_ = consumes<HODigiCollection>(inputLabel_);
   tok_calib_ = consumes<HcalCalibDigiCollection>(inputLabel_);
 
   std::string subd = conf.getParameter<std::string>("Subdetector");
   if (!strcasecmp(subd.c_str(), "HO")) {
     subdet_ = HcalOuter;
     produces<HORecHitCollection>();
   } else if (!strcasecmp(subd.c_str(), "HF")) {
     subdet_ = HcalForward;
     produces<HFRecHitCollection>();
   } else {
     std::cout << "HcalSimpleReconstructor is not associated with a specific subdetector!" << std::endl;
   }
 }

HcalSimpleReconstructor::~HcalSimpleReconstructor ( )

override

Definition at line 45 of file HcalSimpleReconstructor.cc.

References paramTS, and theTopology.

                                                   {
   delete paramTS;
   delete theTopology;
 }

Member Function Documentation

void HcalSimpleReconstructor::beginRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

final

Definition at line 50 of file HcalSimpleReconstructor.cc.

References HcalSimpleRecAlgo::beginRun(), edm::EventSetup::get(), AlCaHLTBitMon_ParallelJobs::p, paramTS, edm::ESHandle< T >::product(), reco_, HcalCondObjectContainerBase::setTopo(), theTopology, and tsFromDB_.

                                                                                {
   if (tsFromDB_) {
     edm::ESHandle<HcalRecoParams> p;
     es.get<HcalRecoParamsRcd>().get(p);
     paramTS = new HcalRecoParams(*p.product());
 
     edm::ESHandle<HcalTopology> htopo;
     es.get<HcalRecNumberingRecord>().get(htopo);
     theTopology = new HcalTopology(*htopo);
     paramTS->setTopo(theTopology);
   }
   reco_.beginRun(es);
 }

void HcalSimpleReconstructor::endRun	(	edm::Run const &	r,
		edm::EventSetup const &	es
	)

final

Definition at line 64 of file HcalSimpleReconstructor.cc.

References HcalSimpleRecAlgo::endRun(), paramTS, reco_, and tsFromDB_.

                                                                              {
   if (tsFromDB_ && paramTS) {
     delete paramTS;
     paramTS = nullptr;
     reco_.endRun();
   }
 }

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

static

Definition at line 127 of file HcalSimpleReconstructor.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   // horeco
   edm::ParameterSetDescription descHO;
   descHO.add<double>("correctionPhaseNS", 13.0);
   descHO.add<edm::InputTag>("digiLabel", edm::InputTag("hcalDigis"));
   descHO.add<bool>("tsFromDB", true);
   descHO.add<int>("samplesToAdd", 4);
   descHO.add<std::string>("Subdetector", "HO");
   descHO.add<bool>("correctForTimeslew", true);
   descHO.add<bool>("dropZSmarkedPassed", true);
   descHO.add<bool>("correctForPhaseContainment", true);
   descHO.add<int>("firstSample", 4);
   descriptions.add("hosimplereco", descHO);
 
   // hfreco
   edm::ParameterSetDescription descHF;
   descHF.add<double>("correctionPhaseNS", 0.0);
   descHF.add<edm::InputTag>("digiLabel", edm::InputTag("hcalDigis"));
   descHF.add<bool>("tsFromDB", true);
   descHF.add<int>("samplesToAdd", 2);
   descHF.add<std::string>("Subdetector", "HF");
   descHF.add<bool>("correctForTimeslew", false);
   descHF.add<bool>("dropZSmarkedPassed", true);
   descHF.add<bool>("correctForPhaseContainment", false);
   descHF.add<int>("firstSample", 4);
   descriptions.add("hfsimplereco", descHF);
 }

template<class DIGICOLL , class RECHITCOLL >

void HcalSimpleReconstructor::process	(	edm::Event &	e,
		const edm::EventSetup &	c,
		const edm::EDGetTokenT< DIGICOLL > &	tok
	)

private

Definition at line 73 of file HcalSimpleReconstructor.cc.

References AlignmentProducer_cff::calibrations, dropZSmarkedPassed_, dqmdumpme::first, HcalRecoParam::firstSample(), firstSample_, edm::EventSetup::get(), edm::Event::getByToken(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HcalCondObjectContainer< Item >::getValues(), mps_fire::i, eostools::move(), paramTS, edm::Event::put(), DetId::rawId(), reco_, HcalSimpleRecAlgo::reconstruct(), HcalRecoParam::samplesToAdd(), samplesToAdd_, and tsFromDB_.

                                                                            {
   // get conditions
   edm::ESHandle<HcalDbService> conditions;
   eventSetup.get<HcalDbRecord>().get(conditions);
 
   edm::Handle<DIGICOLL> digi;
   e.getByToken(tok, digi);
 
   // create empty output
   auto rec = std::make_unique<RECHITCOLL>();
   rec->reserve(digi->size());
   // run the algorithm
   int first = firstSample_;
   int toadd = samplesToAdd_;
   typename DIGICOLL::const_iterator i;
   for (i = digi->begin(); i != digi->end(); i++) {
     HcalDetId cell = i->id();
     DetId detcell = (DetId)cell;
     // rof 27.03.09: drop ZS marked and passed digis:
     if (dropZSmarkedPassed_)
       if (i->zsMarkAndPass())
         continue;
 
     const HcalCalibrations& calibrations = conditions->getHcalCalibrations(cell);
     const HcalQIECoder* channelCoder = conditions->getHcalCoder(cell);
     const HcalQIEShape* shape = conditions->getHcalShape(channelCoder);
     HcalCoderDb coder(*channelCoder, *shape);
 
     //>>> firstSample & samplesToAdd
     if (tsFromDB_) {
       const HcalRecoParam* param_ts = paramTS->getValues(detcell.rawId());
       first = param_ts->firstSample();
       toadd = param_ts->samplesToAdd();
     }
     rec->push_back(reco_.reconstruct(*i, first, toadd, coder, calibrations));
   }
   // return result
   e.put(std::move(rec));
 }

void HcalSimpleReconstructor::produce	(	edm::Event &	e,
		const edm::EventSetup &	c
	)

final

Definition at line 115 of file HcalSimpleReconstructor.cc.

References det_, MillePedeFileConverter_cfg::e, DetId::Hcal, HcalCalibration, HcalForward, HcalOther, HcalOuter, subdet_, subdetOther_, tok_calib_, tok_hf_, and tok_ho_.

                                                                                   {
   if (det_ == DetId::Hcal) {
     if (subdet_ == HcalForward) {
       process<HFDigiCollection, HFRecHitCollection>(e, eventSetup, tok_hf_);
     } else if (subdet_ == HcalOuter) {
       process<HODigiCollection, HORecHitCollection>(e, eventSetup, tok_ho_);
     } else if (subdet_ == HcalOther && subdetOther_ == HcalCalibration) {
       process<HcalCalibDigiCollection, HcalCalibRecHitCollection>(e, eventSetup, tok_calib_);
     }
   }
 }