#include <ZdcSimpleReconstructor.h>

Inheritance diagram for ZdcSimpleReconstructor:

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

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

	ZdcSimpleReconstructor (const edm::ParameterSet &ps)

	~ZdcSimpleReconstructor () override

Public Member Functions inherited from edm::stream::EDProducer< T >
	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
edm::ESGetToken< HcalDbService, HcalDbRecord >	conditionsToken_

DetId::Detector	det_

bool	dropZSmarkedPassed_

const HcalTimeSlew *	hcalTimeSlew_delay_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	htopoToken_

std::unique_ptr < HcalLongRecoParams >	longRecoParams_

edm::ESGetToken < HcalLongRecoParams, HcalLongRecoParamsRcd >	paramsToken_

ZdcSimpleRecAlgo	reco_

int	subdet_

HcalOtherSubdetector	subdetOther_

edm::ESGetToken< HcalTimeSlew, HcalTimeSlewRecord >	timeSlewToken_

edm::EDGetTokenT < ZDCDigiCollection >	tok_input_castor

edm::EDGetTokenT < ZDCDigiCollection >	tok_input_hcal

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< T >
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 34 of file ZdcSimpleReconstructor.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 13 of file ZdcSimpleReconstructor.cc.

References DetId::Calo, conditionsToken_, gather_cfg::cout, det_, edm::ParameterSet::getParameter(), HcalCalibration, HcalOther, hcalTimeSlew_delay_, htopoToken_, paramsToken_, AlCaHLTBitMon_QueryRunRegistry::string, subdet_, HcalZDCDetId::SubdetectorId, subdetOther_, timeSlewToken_, tok_input_castor, and tok_input_hcal.

     : reco_(conf.getParameter<bool>("correctForTimeslew"),
             conf.getParameter<bool>("correctForPhaseContainment"),
             conf.getParameter<double>("correctionPhaseNS"),
             conf.getParameter<int>("recoMethod"),
             conf.getParameter<int>("lowGainOffset"),
             conf.getParameter<double>("lowGainFrac")),
       det_(DetId::Hcal),
       dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")) {
   tok_input_castor = consumes<ZDCDigiCollection>(conf.getParameter<edm::InputTag>("digiLabelcastor"));
   tok_input_hcal = consumes<ZDCDigiCollection>(conf.getParameter<edm::InputTag>("digiLabelhcal"));
 
   std::string subd = conf.getParameter<std::string>("Subdetector");
   if (!strcasecmp(subd.c_str(), "ZDC")) {
     det_ = DetId::Calo;
     subdet_ = HcalZDCDetId::SubdetectorId;
     produces<ZDCRecHitCollection>();
   } else if (!strcasecmp(subd.c_str(), "CALIB")) {
     subdet_ = HcalOther;
     subdetOther_ = HcalCalibration;
     produces<HcalCalibRecHitCollection>();
   } else {
     std::cout << "ZdcSimpleReconstructor is not associated with a specific subdetector!" << std::endl;
   }
 
   hcalTimeSlew_delay_ = nullptr;
 
   // ES tokens
   htopoToken_ = esConsumes<HcalTopology, HcalRecNumberingRecord, edm::Transition::BeginRun>();
   paramsToken_ = esConsumes<HcalLongRecoParams, HcalLongRecoParamsRcd, edm::Transition::BeginRun>();
   conditionsToken_ = esConsumes<HcalDbService, HcalDbRecord>();
   timeSlewToken_ = esConsumes<HcalTimeSlew, HcalTimeSlewRecord>(edm::ESInputTag("", "HBHE"));
 }

ZdcSimpleReconstructor::~ZdcSimpleReconstructor ( )

override

Definition at line 47 of file ZdcSimpleReconstructor.cc.

47 {}

Member Function Documentation

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

final

Definition at line 49 of file ZdcSimpleReconstructor.cc.

References edm::EventSetup::getData(), hcalTimeSlew_delay_, htopoToken_, longRecoParams_, AlCaHLTBitMon_ParallelJobs::p, paramsToken_, and timeSlewToken_.

                                                                               {
   const HcalTopology& htopo = es.getData(htopoToken_);
   const HcalLongRecoParams& p = es.getData(paramsToken_);
   longRecoParams_ = std::make_unique<HcalLongRecoParams>(p);
   longRecoParams_->setTopo(&htopo);
 
   hcalTimeSlew_delay_ = &es.getData(timeSlewToken_);
 }

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

final

Definition at line 58 of file ZdcSimpleReconstructor.cc.

58 {}

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

override

Definition at line 60 of file ZdcSimpleReconstructor.cc.

References DetId::Calo, submitPVValidationJobs::conditions, conditionsToken_, det_, dropZSmarkedPassed_, edm::Event::getByToken(), edm::EventSetup::getData(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), hcalTimeSlew_delay_, mps_fire::i, ZdcSimpleRecAlgo::initPulseCorr(), longRecoParams_, eostools::move(), HcalLongRecoParam::noiseTS(), edm::Event::put(), reco_, ZdcSimpleRecAlgo::reconstruct(), HcalLongRecoParam::signalTS(), subdet_, HcalZDCDetId::SubdetectorId, tok_input_castor, and tok_input_hcal.

                                                                                  {
   // get conditions
   const HcalDbService* conditions = &eventSetup.getData(conditionsToken_);
 
   // define vectors to pass noiseTS and signalTS
   std::vector<unsigned int> mySignalTS;
   std::vector<unsigned int> myNoiseTS;
 
   if (det_ == DetId::Calo && subdet_ == HcalZDCDetId::SubdetectorId) {
     edm::Handle<ZDCDigiCollection> digi;
     e.getByToken(tok_input_hcal, digi);
 
     if (digi->empty()) {
       e.getByToken(tok_input_castor, digi);
       if (digi->empty())
         edm::LogInfo("ZdcHitReconstructor") << "No ZDC info found in either castorDigis or hcalDigis." << std::endl;
     }
 
     // create empty output
     auto rec = std::make_unique<ZDCRecHitCollection>();
     rec->reserve(digi->size());
     // run the algorithm
     unsigned int toaddMem = 0;
 
     ZDCDigiCollection::const_iterator i;
     for (i = digi->begin(); i != digi->end(); i++) {
       HcalZDCDetId cell = i->id();
       DetId detcell = (DetId)cell;
       // rof 27.03.09: drop ZS marked and passed digis:
       if (dropZSmarkedPassed_)
         if (i->zsMarkAndPass())
           continue;
 
       // get db values for signalTSs and noiseTSs
       const HcalLongRecoParam* myParams = longRecoParams_->getValues(detcell);
       mySignalTS.clear();
       myNoiseTS.clear();
       mySignalTS = myParams->signalTS();
       myNoiseTS = myParams->noiseTS();
       // warning: the PulseCorrection is not used by ZDC. If it gets a non-contingious set of
       // signal TS, it may not work properly. Assume contiguous here....
       unsigned int toadd = mySignalTS.size();
       if (toaddMem != toadd) {
         reco_.initPulseCorr(toadd, hcalTimeSlew_delay_);
         toaddMem = toadd;
       }
       const HcalCalibrations& calibrations = conditions->getHcalCalibrations(cell);
       const HcalQIECoder* channelCoder = conditions->getHcalCoder(cell);
       const HcalQIEShape* shape = conditions->getHcalShape(channelCoder);
       HcalCoderDb coder(*channelCoder, *shape);
       rec->push_back(reco_.reconstruct(*i, myNoiseTS, mySignalTS, coder, calibrations));
     }
     // return result
     e.put(std::move(rec));
   }
 }