#include <HcalHitReconstructor.h>

Inheritance diagram for HcalHitReconstructor:

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

	HcalHitReconstructor (const edm::ParameterSet &ps)

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

	~HcalHitReconstructor () 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 Types
typedef void(HcalSimpleRecAlgo::*	SetCorrectionFcn) (std::shared_ptr< AbsOOTPileupCorrection >)

Private Attributes
std::string	cat_

edm::ESGetToken< HcalDbService, HcalDbRecord >	conditionsToken_

bool	correctTiming_

std::string	corrName_

std::string	dataOOTCorrectionCategory_

std::string	dataOOTCorrectionName_

DetId::Detector	det_

bool	digiTimeFromDB_

edm::ESGetToken< HcalFlagHFDigiTimeParams, HcalFlagHFDigiTimeParamsRcd >	digiTimeToken_

bool	dropZSmarkedPassed_

int	firstAuxTS_

int	firstSample_

HcalHFStatusBitFromDigis *	hfdigibit_

std::unique_ptr< HcalFlagHFDigiTimeParams >	hFDigiTimeParams_

HcalHF_PETalgorithm *	hfPET_

HcalHF_S9S1algorithm *	hfS8S1_

HcalHF_S9S1algorithm *	hfS9S1_

HFTimingTrustFlag *	HFTimingTrustFlagSetter_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	htopoToken_

edm::InputTag	inputLabel_

std::string	mcOOTCorrectionCategory_

std::string	mcOOTCorrectionName_

edm::ESGetToken< HcalRecoParams, HcalRecoParamsRcd >	paramsToken_

std::unique_ptr< HcalRecoParams >	paramTS_

edm::ESGetToken< HcalChannelQuality, HcalChannelQualityRcd >	qualToken_

HcalSimpleRecAlgo	reco_

bool	recoParamsFromDB_

int	samplesToAdd_

HcalADCSaturationFlag *	saturationFlagSetter_

bool	setHSCPFlags_

bool	setNegativeFlags_

bool	setNoiseFlags_

SetCorrectionFcn	setPileupCorrection_

bool	setPulseShapeFlags_

bool	setSaturationFlags_

bool	setTimingTrustFlags_

edm::ESGetToken< HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd >	sevToken_

int	subdet_

HcalOtherSubdetector	subdetOther_

edm::EDGetTokenT< HcalCalibDigiCollection >	tok_calib_

edm::EDGetTokenT< HFDigiCollection >	tok_hf_

edm::EDGetTokenT< HODigiCollection >	tok_ho_

bool	tsFromDB_

bool	useLeakCorrection_

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

Author: J. Temple & E. Yazgan Based on HcalSimpleReconstructor.h by J. Mans

Definition at line 50 of file HcalHitReconstructor.h.

Member Typedef Documentation

◆ SetCorrectionFcn

typedef void(HcalSimpleRecAlgo::* HcalHitReconstructor::SetCorrectionFcn) (std::shared_ptr< AbsOOTPileupCorrection >)

private

Definition at line 60 of file HcalHitReconstructor.h.

Constructor & Destructor Documentation

◆ HcalHitReconstructor()

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

explicit

Definition at line 26 of file HcalHitReconstructor.cc.

References DetId::Calo, conditionsToken_, dataOOTCorrectionCategory_, dataOOTCorrectionName_, det_, digiTimeFromDB_, digiTimeToken_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), HcalCalibration, HcalForward, HcalOther, HcalOuter, hfdigibit_, hfPET_, hfS8S1_, hfS9S1_, HFTimingTrustFlagSetter_, htopoToken_, inputLabel_, mcOOTCorrectionCategory_, mcOOTCorrectionName_, paramsToken_, qualToken_, recoParamsFromDB_, saturationFlagSetter_, setNegativeFlags_, setNoiseFlags_, setPileupCorrection_, setSaturationFlags_, setTimingTrustFlags_, sevToken_, AlCaHLTBitMon_QueryRunRegistry::string, subdet_, HcalZDCDetId::SubdetectorId, subdetOther_, tok_calib_, tok_hf_, tok_ho_, and tsFromDB_.

     : reco_(conf.getParameter<bool>("correctForTimeslew"),
             conf.getParameter<bool>("correctForPhaseContainment"),
             conf.getParameter<double>("correctionPhaseNS"),
             consumesCollector()),
       det_(DetId::Hcal),
       inputLabel_(conf.getParameter<edm::InputTag>("digiLabel")),
       correctTiming_(conf.getParameter<bool>("correctTiming")),
       setNoiseFlags_(conf.getParameter<bool>("setNoiseFlags")),
       setHSCPFlags_(conf.getParameter<bool>("setHSCPFlags")),
       setSaturationFlags_(conf.getParameter<bool>("setSaturationFlags")),
       setTimingTrustFlags_(conf.getParameter<bool>("setTimingTrustFlags")),
       setPulseShapeFlags_(conf.getParameter<bool>("setPulseShapeFlags")),
       setNegativeFlags_(false),
       dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")),
       firstAuxTS_(conf.getParameter<int>("firstAuxTS")),
       firstSample_(conf.getParameter<int>("firstSample")),
       samplesToAdd_(conf.getParameter<int>("samplesToAdd")),
       tsFromDB_(conf.getParameter<bool>("tsFromDB")),
       useLeakCorrection_(conf.getParameter<bool>("useLeakCorrection")),
       dataOOTCorrectionName_(""),
       dataOOTCorrectionCategory_("Data"),
       mcOOTCorrectionName_(""),
       mcOOTCorrectionCategory_("MC"),
       setPileupCorrection_(nullptr) {
   // register for data access
   tok_ho_ = consumes<HODigiCollection>(inputLabel_);
   tok_hf_ = consumes<HFDigiCollection>(inputLabel_);
   tok_calib_ = consumes<HcalCalibDigiCollection>(inputLabel_);
 
   std::string subd = conf.getParameter<std::string>("Subdetector");
   //Set all FlagSetters to 0
   /* Important to do this!  Otherwise, if the setters are turned off,
      the "if (XSetter_) delete XSetter_;" commands can crash
   */
 
   recoParamsFromDB_ = conf.getParameter<bool>("recoParamsFromDB");
   //  recoParamsFromDB_ = false ; //  trun off for now.
 
   // std::cout<<"  HcalHitReconstructor   recoParamsFromDB_ "<<recoParamsFromDB_<<std::endl;
 
   if (conf.existsAs<bool>("setNegativeFlags"))
     setNegativeFlags_ = conf.getParameter<bool>("setNegativeFlags");
 
   hfdigibit_ = nullptr;
 
   hfS9S1_ = nullptr;
   hfS8S1_ = nullptr;
   hfPET_ = nullptr;
   saturationFlagSetter_ = nullptr;
   HFTimingTrustFlagSetter_ = nullptr;
   digiTimeFromDB_ = false;  // only need for HF
 
   if (setSaturationFlags_) {
     const edm::ParameterSet& pssat = conf.getParameter<edm::ParameterSet>("saturationParameters");
     saturationFlagSetter_ = new HcalADCSaturationFlag(pssat.getParameter<int>("maxADCvalue"));
   }
 
   if (!strcasecmp(subd.c_str(), "HO")) {
     subdet_ = HcalOuter;
     // setPileupCorrection_ = &HcalSimpleRecAlgo::setHOPileupCorrection;
     setPileupCorrection_ = nullptr;
     produces<HORecHitCollection>();
   } else if (!strcasecmp(subd.c_str(), "HF")) {
     subdet_ = HcalForward;
     // setPileupCorrection_ = &HcalSimpleRecAlgo::setHFPileupCorrection;
     setPileupCorrection_ = nullptr;
     digiTimeFromDB_ = conf.getParameter<bool>("digiTimeFromDB");
 
     if (setTimingTrustFlags_) {
       const edm::ParameterSet& pstrust = conf.getParameter<edm::ParameterSet>("hfTimingTrustParameters");
       HFTimingTrustFlagSetter_ = new HFTimingTrustFlag(pstrust.getParameter<int>("hfTimingTrustLevel1"),
                                                        pstrust.getParameter<int>("hfTimingTrustLevel2"));
     }
 
     if (setNoiseFlags_) {
       const edm::ParameterSet& psdigi = conf.getParameter<edm::ParameterSet>("digistat");
       const edm::ParameterSet& psTimeWin = conf.getParameter<edm::ParameterSet>("HFInWindowStat");
       hfdigibit_ = new HcalHFStatusBitFromDigis(psdigi, psTimeWin);
 
       const edm::ParameterSet& psS9S1 = conf.getParameter<edm::ParameterSet>("S9S1stat");
       hfS9S1_ = new HcalHF_S9S1algorithm(psS9S1.getParameter<std::vector<double> >("short_optimumSlope"),
                                          psS9S1.getParameter<std::vector<double> >("shortEnergyParams"),
                                          psS9S1.getParameter<std::vector<double> >("shortETParams"),
                                          psS9S1.getParameter<std::vector<double> >("long_optimumSlope"),
                                          psS9S1.getParameter<std::vector<double> >("longEnergyParams"),
                                          psS9S1.getParameter<std::vector<double> >("longETParams"),
                                          psS9S1.getParameter<int>("HcalAcceptSeverityLevel"),
                                          psS9S1.getParameter<bool>("isS8S1"));
 
       const edm::ParameterSet& psS8S1 = conf.getParameter<edm::ParameterSet>("S8S1stat");
       hfS8S1_ = new HcalHF_S9S1algorithm(psS8S1.getParameter<std::vector<double> >("short_optimumSlope"),
                                          psS8S1.getParameter<std::vector<double> >("shortEnergyParams"),
                                          psS8S1.getParameter<std::vector<double> >("shortETParams"),
                                          psS8S1.getParameter<std::vector<double> >("long_optimumSlope"),
                                          psS8S1.getParameter<std::vector<double> >("longEnergyParams"),
                                          psS8S1.getParameter<std::vector<double> >("longETParams"),
                                          psS8S1.getParameter<int>("HcalAcceptSeverityLevel"),
                                          psS8S1.getParameter<bool>("isS8S1"));
 
       const edm::ParameterSet& psPET = conf.getParameter<edm::ParameterSet>("PETstat");
       hfPET_ = new HcalHF_PETalgorithm(psPET.getParameter<std::vector<double> >("short_R"),
                                        psPET.getParameter<std::vector<double> >("shortEnergyParams"),
                                        psPET.getParameter<std::vector<double> >("shortETParams"),
                                        psPET.getParameter<std::vector<double> >("long_R"),
                                        psPET.getParameter<std::vector<double> >("longEnergyParams"),
                                        psPET.getParameter<std::vector<double> >("longETParams"),
                                        psPET.getParameter<int>("HcalAcceptSeverityLevel"),
                                        psPET.getParameter<std::vector<double> >("short_R_29"),
                                        psPET.getParameter<std::vector<double> >("long_R_29"));
     }
     produces<HFRecHitCollection>();
   } else 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 {
     edm::LogWarning("Configuration") << "HcalHitReconstructor is not associated with a specific subdetector!"
                                      << std::endl;
   }
 
   // If no valid OOT pileup correction name specified,
   // disable the correction
   if (conf.existsAs<std::string>("dataOOTCorrectionName"))
     dataOOTCorrectionName_ = conf.getParameter<std::string>("dataOOTCorrectionName");
   if (conf.existsAs<std::string>("dataOOTCorrectionCategory"))
     dataOOTCorrectionCategory_ = conf.getParameter<std::string>("dataOOTCorrectionCategory");
   if (conf.existsAs<std::string>("mcOOTCorrectionName"))
     mcOOTCorrectionName_ = conf.getParameter<std::string>("mcOOTCorrectionName");
   if (conf.existsAs<std::string>("mcOOTCorrectionCategory"))
     mcOOTCorrectionCategory_ = conf.getParameter<std::string>("mcOOTCorrectionCategory");
   if (dataOOTCorrectionName_.empty() && mcOOTCorrectionName_.empty())
     setPileupCorrection_ = nullptr;
 
   // ES tokens
   htopoToken_ = esConsumes<HcalTopology, HcalRecNumberingRecord, edm::Transition::BeginRun>();
   if (tsFromDB_ || recoParamsFromDB_)
     paramsToken_ = esConsumes<HcalRecoParams, HcalRecoParamsRcd, edm::Transition::BeginRun>();
   if (digiTimeFromDB_)
     digiTimeToken_ = esConsumes<HcalFlagHFDigiTimeParams, HcalFlagHFDigiTimeParamsRcd, edm::Transition::BeginRun>();
   conditionsToken_ = esConsumes<HcalDbService, HcalDbRecord>();
   qualToken_ = esConsumes<HcalChannelQuality, HcalChannelQualityRcd>(edm::ESInputTag("", "withTopo"));
   sevToken_ = esConsumes<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd>();
 }

◆ ~HcalHitReconstructor()

HcalHitReconstructor::~HcalHitReconstructor ( )

override

Definition at line 175 of file HcalHitReconstructor.cc.

References hfdigibit_, hfPET_, hfS8S1_, hfS9S1_, HFTimingTrustFlagSetter_, and saturationFlagSetter_.

                                             {
   delete hfdigibit_;
 
   delete hfS9S1_;
   delete hfS8S1_;
   delete hfPET_;
   delete saturationFlagSetter_;
   delete HFTimingTrustFlagSetter_;
 }

Member Function Documentation

◆ beginRun()

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

final

Definition at line 185 of file HcalHitReconstructor.cc.

References HcalSimpleRecAlgo::beginRun(), digiTimeFromDB_, digiTimeToken_, edm::EventSetup::getData(), hFDigiTimeParams_, htopoToken_, AlCaHLTBitMon_ParallelJobs::p, paramsToken_, paramTS_, reco_, recoParamsFromDB_, and tsFromDB_.

                                                                             {
   const HcalTopology& htopo = es.getData(htopoToken_);
 
   if (tsFromDB_ || recoParamsFromDB_) {
     const HcalRecoParams& p = es.getData(paramsToken_);
     paramTS_ = std::make_unique<HcalRecoParams>(p);
     paramTS_->setTopo(&htopo);
 
     // std::cout<<" skdump in HcalHitReconstructor::beginRun   dupm RecoParams "<<std::endl;
     // std::ofstream skfile("skdumpRecoParamsNewFormat.txt");
     // HcalDbASCIIIO::dumpObject(skfile, (*paramTS_) );
   }
 
   if (digiTimeFromDB_) {
     const HcalFlagHFDigiTimeParams& p = es.getData(digiTimeToken_);
     hFDigiTimeParams_ = std::make_unique<HcalFlagHFDigiTimeParams>(p);
     hFDigiTimeParams_->setTopo(&htopo);
   }
 
   reco_.beginRun(es);
 }

◆ endRun()

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

final

Definition at line 207 of file HcalHitReconstructor.cc.

References HcalSimpleRecAlgo::endRun(), and reco_.

207 { reco_.endRun(); }

HcalSimpleRecAlgo::endRun

void endRun()

Definition: HcalSimpleRecAlgo.cc:41

HcalHitReconstructor::reco_

HcalSimpleRecAlgo reco_

Definition: HcalHitReconstructor.h:62

◆ produce()

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

override

Definition at line 209 of file HcalHitReconstructor.cc.

References funct::abs(), edm::SortedCollection< T, SORT >::begin(), AlignmentProducer_cff::calibrations, submitPVValidationJobs::conditions, conditionsToken_, HcalTimingCorrector::Correct(), HcalRecoParam::correctForPhaseContainment(), castor_dqm_sourceclient-live_cfg::correctForPhaseContainment, HcalRecoParam::correctForTimeslew(), castor_dqm_sourceclient-live_cfg::correctForTimeslew, HcalRecoParam::correctionPhaseNS(), HcalRecoParam::correctTiming(), correctTiming_, LEDCalibrationChannels::depth, det_, digiTimeFromDB_, HcalSeverityLevelComputer::dropChannel(), dropZSmarkedPassed_, MillePedeFileConverter_cfg::e, edm::SortedCollection< T, SORT >::end(), options_cfi::eventSetup, dqmdumpme::first, HcalRecoParam::firstAuxTS(), firstAuxTS_, HcalRecoParam::firstSample(), firstSample_, HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalCalibration, HcalForward, HcalOther, HcalOuter, hfdigibit_, HcalFlagHFDigiTimeParam::HFdigiflagCoefficients(), HcalFlagHFDigiTimeParam::HFdigiflagExpectedPeak(), HcalFlagHFDigiTimeParam::HFdigiflagFirstSample(), HcalFlagHFDigiTimeParam::HFdigiflagMinEThreshold(), HcalFlagHFDigiTimeParam::HFdigiflagSamplesToAdd(), hFDigiTimeParams_, hfPET_, hfS8S1_, hfS9S1_, HcalHFStatusBitFromDigis::hfSetFlagFromDigi(), HcalHF_PETalgorithm::HFSetFlagFromPET(), HcalHF_S9S1algorithm::HFSetFlagFromS9S1(), HFTimingTrustFlagSetter_, mps_fire::i, LEDCalibrationChannels::ieta, dqmdumpme::k, eostools::move(), paramTS_, HcalRecoParam::pileupCleaningID(), HcalCaloFlagLabels::PresampleADC, qualToken_, DetId::rawId(), reco_, HcalSimpleRecAlgo::reconstruct(), recoParamsFromDB_, HcalHFStatusBitFromDigis::resetParamsFromDB(), HcalRecoParam::samplesToAdd(), samplesToAdd_, saturationFlagSetter_, HFTimingTrustFlag::setHFTimingTrustFlag(), HcalSimpleRecAlgo::setLeakCorrection(), setNoiseFlags_, HcalSimpleRecAlgo::setRecoParams(), HcalADCSaturationFlag::setSaturationFlag(), setSaturationFlags_, setTimingTrustFlags_, sevToken_, l1trig_cff::shape, edm::SortedCollection< T, SORT >::size(), subdet_, subdetOther_, tok_calib_, tok_hf_, tok_ho_, tsFromDB_, HcalRecoParam::useLeakCorrection(), useLeakCorrection_, and geometryCSVtoXML::xx.

                                                                                {
   // get conditions
   const HcalDbService* conditions = &eventSetup.getData(conditionsToken_);
   const HcalChannelQuality* myqual = &eventSetup.getData(qualToken_);
   const HcalSeverityLevelComputer* mySeverity = &eventSetup.getData(sevToken_);
 
   if (useLeakCorrection_)
     reco_.setLeakCorrection();
 
   // GET THE BEAM CROSSING INFO HERE, WHEN WE UNDERSTAND HOW THINGS WORK.
   // Then, call "setBXInfo" method of the reco_ object.
   // Also remember to call SetBXInfo in the negative energy flag setter.
 
   if (det_ == DetId::Hcal) {
     //  HO ------------------------------------------------------------------
     if (subdet_ == HcalOuter) {
       edm::Handle<HODigiCollection> digi;
       e.getByToken(tok_ho_, digi);
 
       // create empty output
       auto rec = std::make_unique<HORecHitCollection>();
       rec->reserve(digi->size());
       // run the algorithm
       HODigiCollection::const_iterator i;
 
       // Vote on majority TS0 CapId
       int favorite_capid = 0;
       if (correctTiming_) {
         long capid_votes[4] = {0, 0, 0, 0};
         for (i = digi->begin(); i != digi->end(); i++) {
           capid_votes[(*i)[0].capid()]++;
         }
         for (int k = 0; k < 4; k++)
           if (capid_votes[k] > capid_votes[favorite_capid])
             favorite_capid = k;
       }
 
       for (i = digi->begin(); i != digi->end(); i++) {
         HcalDetId cell = i->id();
         DetId detcell = (DetId)cell;
         // firstSample & samplesToAdd
         if (tsFromDB_ || recoParamsFromDB_) {
           const HcalRecoParam* param_ts = paramTS_->getValues(detcell.rawId());
           if (tsFromDB_) {
             firstSample_ = param_ts->firstSample();
             samplesToAdd_ = param_ts->samplesToAdd();
           }
           if (recoParamsFromDB_) {
             bool correctForTimeslew = param_ts->correctForTimeslew();
             bool correctForPhaseContainment = param_ts->correctForPhaseContainment();
             float phaseNS = param_ts->correctionPhaseNS();
             useLeakCorrection_ = param_ts->useLeakCorrection();
             correctTiming_ = param_ts->correctTiming();
             firstAuxTS_ = param_ts->firstAuxTS();
             int pileupCleaningID = param_ts->pileupCleaningID();
             reco_.setRecoParams(
                 correctForTimeslew, correctForPhaseContainment, useLeakCorrection_, pileupCleaningID, phaseNS);
           }
         }
 
         int first = firstSample_;
         int toadd = samplesToAdd_;
 
         if (first >= i->size() || first < 0)
           edm::LogWarning("Configuration")
               << "HcalHitReconstructor: illegal firstSample" << first << "  in subdet " << subdet_ << std::endl;
 
         // check on cells to be ignored and dropped: (rof,20.Feb.09)
         const HcalChannelStatus* mydigistatus = myqual->getValues(detcell.rawId());
         if (mySeverity->dropChannel(mydigistatus->getValue()))
           continue;
         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);
 
         rec->push_back(reco_.reconstruct(*i, first, toadd, coder, calibrations));
 
         // Set auxiliary flag
         int auxflag = 0;
         int fTS = firstAuxTS_;
         if (fTS < 0)
           fTS = 0;  //silly protection against negative time slice values
         for (int xx = fTS; xx < fTS + 4 && xx < i->size(); ++xx)
           auxflag += (i->sample(xx).adc())
                      << (7 *
                          (xx - fTS));  // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
         // bits 28 and 29 are reserved for capid of the first time slice saved in aux
         auxflag += ((i->sample(fTS).capid()) << 28);
         (rec->back()).setAux(auxflag);
         // (rec->back()).setFlags(0);  Don't want to do this because the algorithm
         //                             can already set some flags
         // Fill Presample ADC flag
         if (fTS > 0)
           (rec->back()).setFlagField((i->sample(fTS - 1).adc()), HcalCaloFlagLabels::PresampleADC, 7);
 
         if (setSaturationFlags_)
           saturationFlagSetter_->setSaturationFlag(rec->back(), *i);
         if (correctTiming_)
           HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
       }
       // return result
       e.put(std::move(rec));
 
       // HF -------------------------------------------------------------------
     } else if (subdet_ == HcalForward) {
       edm::Handle<HFDigiCollection> digi;
       e.getByToken(tok_hf_, digi);
 
       // create empty output
       auto rec = std::make_unique<HFRecHitCollection>();
       rec->reserve(digi->size());
       // run the algorithm
       HFDigiCollection::const_iterator i;
 
       // Vote on majority TS0 CapId
       int favorite_capid = 0;
       if (correctTiming_) {
         long capid_votes[4] = {0, 0, 0, 0};
         for (i = digi->begin(); i != digi->end(); i++) {
           capid_votes[(*i)[0].capid()]++;
         }
         for (int k = 0; k < 4; k++)
           if (capid_votes[k] > capid_votes[favorite_capid])
             favorite_capid = k;
       }
 
       for (i = digi->begin(); i != digi->end(); i++) {
         HcalDetId cell = i->id();
         DetId detcell = (DetId)cell;
 
         if (tsFromDB_ || recoParamsFromDB_) {
           const HcalRecoParam* param_ts = paramTS_->getValues(detcell.rawId());
           if (tsFromDB_) {
             firstSample_ = param_ts->firstSample();
             samplesToAdd_ = param_ts->samplesToAdd();
           }
           if (recoParamsFromDB_) {
             bool correctForTimeslew = param_ts->correctForTimeslew();
             bool correctForPhaseContainment = param_ts->correctForPhaseContainment();
             float phaseNS = param_ts->correctionPhaseNS();
             useLeakCorrection_ = param_ts->useLeakCorrection();
             correctTiming_ = param_ts->correctTiming();
             firstAuxTS_ = param_ts->firstAuxTS();
             int pileupCleaningID = param_ts->pileupCleaningID();
             reco_.setRecoParams(
                 correctForTimeslew, correctForPhaseContainment, useLeakCorrection_, pileupCleaningID, phaseNS);
           }
         }
 
         int first = firstSample_;
         int toadd = samplesToAdd_;
 
         if (first >= i->size() || first < 0)
           edm::LogWarning("Configuration")
               << "HcalHitReconstructor: illegal firstSample" << first << "  in subdet " << subdet_ << std::endl;
 
         // check on cells to be ignored and dropped: (rof,20.Feb.09)
         const HcalChannelStatus* mydigistatus = myqual->getValues(detcell.rawId());
         if (mySeverity->dropChannel(mydigistatus->getValue()))
           continue;
         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);
 
         // Set HFDigiTime flag values from digiTimeFromDB_
         if (digiTimeFromDB_ && hfdigibit_) {
           const HcalFlagHFDigiTimeParam* hfDTparam = hFDigiTimeParams_->getValues(detcell.rawId());
           hfdigibit_->resetParamsFromDB(hfDTparam->HFdigiflagFirstSample(),
                                         hfDTparam->HFdigiflagSamplesToAdd(),
                                         hfDTparam->HFdigiflagExpectedPeak(),
                                         hfDTparam->HFdigiflagMinEThreshold(),
                                         hfDTparam->HFdigiflagCoefficients());
         }
 
         //std::cout << "TOADDHF " << toadd << " " << first << " " << std::endl;
         rec->push_back(reco_.reconstruct(*i, first, toadd, coder, calibrations));
 
         // Set auxiliary flag
         int auxflag = 0;
         int fTS = firstAuxTS_;
         if (fTS < 0)
           fTS = 0;  // silly protection against negative time slice values
         for (int xx = fTS; xx < fTS + 4 && xx < i->size(); ++xx)
           auxflag += (i->sample(xx).adc())
                      << (7 *
                          (xx - fTS));  // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
         // bits 28 and 29 are reserved for capid of the first time slice saved in aux
         auxflag += ((i->sample(fTS).capid()) << 28);
         (rec->back()).setAux(auxflag);
 
         // (rec->back()).setFlags(0);  Don't want to do this because the algorithm
         //                             can already set some flags
 
         // Fill Presample ADC flag
         if (fTS > 0)
           (rec->back()).setFlagField((i->sample(fTS - 1).adc()), HcalCaloFlagLabels::PresampleADC, 7);
 
         // This calls the code for setting the HF noise bit determined from digi shape
         if (setNoiseFlags_)
           hfdigibit_->hfSetFlagFromDigi(rec->back(), *i, coder, calibrations);
         if (setSaturationFlags_)
           saturationFlagSetter_->setSaturationFlag(rec->back(), *i);
         if (setTimingTrustFlags_)
           HFTimingTrustFlagSetter_->setHFTimingTrustFlag(rec->back(), *i);
         if (correctTiming_)
           HcalTimingCorrector::Correct(rec->back(), *i, favorite_capid);
       }  // for (i=digi->begin(); i!=digi->end(); i++) -- loop on all HF digis
 
       // The following flags require the full set of rechits
       // These need to be set consecutively, so an energy check should be the first
       // test performed on these hits (to minimize the loop time)
       if (setNoiseFlags_) {
         // Step 1:  Set PET flag  (short fibers of |ieta|==29)
         // Neighbor/partner channels that are flagged by Pulse Shape algorithm (HFDigiTime)
         // won't be considered in these calculations
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i) {
           int depth = i->id().depth();
           int ieta = i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth == 2 || abs(ieta) == 29)
             hfPET_->HFSetFlagFromPET(*i, *rec, myqual, mySeverity);
         }
 
         // Step 2:  Set S8S1 flag (short fibers or |ieta|==29)
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i) {
           int depth = i->id().depth();
           int ieta = i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth == 2 || abs(ieta) == 29)
             hfS8S1_->HFSetFlagFromS9S1(*i, *rec, myqual, mySeverity);
         }
 
         // Set 3:  Set S9S1 flag (long fibers)
         for (HFRecHitCollection::iterator i = rec->begin(); i != rec->end(); ++i) {
           int depth = i->id().depth();
           int ieta = i->id().ieta();
           // Short fibers and all channels at |ieta|=29 use PET settings in Algo 3
           if (depth == 1 && abs(ieta) != 29)
             hfS9S1_->HFSetFlagFromS9S1(*i, *rec, myqual, mySeverity);
         }
       }
 
       // return result
       e.put(std::move(rec));
     } else if (subdet_ == HcalOther && subdetOther_ == HcalCalibration) {
       edm::Handle<HcalCalibDigiCollection> digi;
       e.getByToken(tok_calib_, digi);
 
       // create empty output
       auto rec = std::make_unique<HcalCalibRecHitCollection>();
       rec->reserve(digi->size());
       // run the algorithm
       int first = firstSample_;
       int toadd = samplesToAdd_;
 
       HcalCalibDigiCollection::const_iterator i;
       for (i = digi->begin(); i != digi->end(); i++) {
         HcalCalibDetId cell = i->id();
         //  HcalDetId cellh = i->id();
         DetId detcell = (DetId)cell;
         // check on cells to be ignored and dropped: (rof,20.Feb.09)
         const HcalChannelStatus* mydigistatus = myqual->getValues(detcell.rawId());
         if (mySeverity->dropChannel(mydigistatus->getValue()))
           continue;
         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));
 
         /*
       // Flag setting not available for calibration rechits
     // Set auxiliary flag
     int auxflag=0;
         int fTS = firstAuxTS_;
     for (int xx=fTS; xx<fTS+4 && xx<i->size();++xx)
       auxflag+=(i->sample(xx).adc())<<(7*(xx-fTS)); // store the time slices in the first 28 bits of aux, a set of 4 7-bit adc values
     // bits 28 and 29 are reserved for capid of the first time slice saved in aux
     auxflag+=((i->sample(fTS).capid())<<28);
     (rec->back()).setAux(auxflag);
 
     (rec->back()).setFlags(0); // Not yet implemented for HcalCalibRecHit
     */
       }
       // return result
       e.put(std::move(rec));
     }
   }
   //DL  delete myqual;
 }  // void HcalHitReconstructor::produce(...)

Member Data Documentation

◆ cat_

std::string HcalHitReconstructor::cat_

private

Definition at line 109 of file HcalHitReconstructor.h.

◆ conditionsToken_

edm::ESGetToken<HcalDbService, HcalDbRecord> HcalHitReconstructor::conditionsToken_

private

Definition at line 115 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ correctTiming_

bool HcalHitReconstructor::correctTiming_

private

Definition at line 78 of file HcalHitReconstructor.h.

Referenced by produce().

◆ corrName_

std::string HcalHitReconstructor::corrName_

private

Definition at line 109 of file HcalHitReconstructor.h.

◆ dataOOTCorrectionCategory_

std::string HcalHitReconstructor::dataOOTCorrectionCategory_

private

Definition at line 101 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ dataOOTCorrectionName_

std::string HcalHitReconstructor::dataOOTCorrectionName_

private

Definition at line 100 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ det_

DetId::Detector HcalHitReconstructor::det_

private

Definition at line 70 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ digiTimeFromDB_

bool HcalHitReconstructor::digiTimeFromDB_

private

Definition at line 94 of file HcalHitReconstructor.h.

Referenced by beginRun(), HcalHitReconstructor(), and produce().

◆ digiTimeToken_

edm::ESGetToken<HcalFlagHFDigiTimeParams, HcalFlagHFDigiTimeParamsRcd> HcalHitReconstructor::digiTimeToken_

private

Definition at line 114 of file HcalHitReconstructor.h.

Referenced by beginRun(), and HcalHitReconstructor().

◆ dropZSmarkedPassed_

bool HcalHitReconstructor::dropZSmarkedPassed_

private

Definition at line 85 of file HcalHitReconstructor.h.

Referenced by produce().

◆ firstAuxTS_

int HcalHitReconstructor::firstAuxTS_

private

Definition at line 87 of file HcalHitReconstructor.h.

Referenced by produce().

◆ firstSample_

int HcalHitReconstructor::firstSample_

private

Definition at line 90 of file HcalHitReconstructor.h.

Referenced by produce().

◆ hfdigibit_

HcalHFStatusBitFromDigis* HcalHitReconstructor::hfdigibit_

private

Definition at line 65 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ hFDigiTimeParams_

std::unique_ptr<HcalFlagHFDigiTimeParams> HcalHitReconstructor::hFDigiTimeParams_

private

Definition at line 107 of file HcalHitReconstructor.h.

Referenced by beginRun(), and produce().

◆ hfPET_

HcalHF_PETalgorithm* HcalHitReconstructor::hfPET_

private

Definition at line 68 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ hfS8S1_

HcalHF_S9S1algorithm* HcalHitReconstructor::hfS8S1_

private

Definition at line 67 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ hfS9S1_

HcalHF_S9S1algorithm* HcalHitReconstructor::hfS9S1_

private

Definition at line 66 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ HFTimingTrustFlagSetter_

HFTimingTrustFlag* HcalHitReconstructor::HFTimingTrustFlagSetter_

private

Definition at line 64 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ htopoToken_

edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> HcalHitReconstructor::htopoToken_

private

Definition at line 112 of file HcalHitReconstructor.h.

Referenced by beginRun(), and HcalHitReconstructor().

◆ inputLabel_

edm::InputTag HcalHitReconstructor::inputLabel_

private

Definition at line 73 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ mcOOTCorrectionCategory_

std::string HcalHitReconstructor::mcOOTCorrectionCategory_

private

Definition at line 103 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ mcOOTCorrectionName_

std::string HcalHitReconstructor::mcOOTCorrectionName_

private

Definition at line 102 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ paramsToken_

edm::ESGetToken<HcalRecoParams, HcalRecoParamsRcd> HcalHitReconstructor::paramsToken_

private

Definition at line 113 of file HcalHitReconstructor.h.

Referenced by beginRun(), and HcalHitReconstructor().

◆ paramTS_

std::unique_ptr<HcalRecoParams> HcalHitReconstructor::paramTS_

private

Definition at line 106 of file HcalHitReconstructor.h.

Referenced by beginRun(), and produce().

◆ qualToken_

edm::ESGetToken<HcalChannelQuality, HcalChannelQualityRcd> HcalHitReconstructor::qualToken_

private

Definition at line 116 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ reco_

HcalSimpleRecAlgo HcalHitReconstructor::reco_

private

Definition at line 62 of file HcalHitReconstructor.h.

Referenced by beginRun(), endRun(), and produce().

◆ recoParamsFromDB_

bool HcalHitReconstructor::recoParamsFromDB_

private

Definition at line 93 of file HcalHitReconstructor.h.

Referenced by beginRun(), HcalHitReconstructor(), and produce().

◆ samplesToAdd_

int HcalHitReconstructor::samplesToAdd_

private

Definition at line 91 of file HcalHitReconstructor.h.

Referenced by produce().

◆ saturationFlagSetter_

HcalADCSaturationFlag* HcalHitReconstructor::saturationFlagSetter_

private

Definition at line 63 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), produce(), and ~HcalHitReconstructor().

◆ setHSCPFlags_

bool HcalHitReconstructor::setHSCPFlags_

private

Definition at line 80 of file HcalHitReconstructor.h.

◆ setNegativeFlags_

bool HcalHitReconstructor::setNegativeFlags_

private

Definition at line 84 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ setNoiseFlags_

bool HcalHitReconstructor::setNoiseFlags_

private

Definition at line 79 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ setPileupCorrection_

SetCorrectionFcn HcalHitReconstructor::setPileupCorrection_

private

Definition at line 104 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ setPulseShapeFlags_

bool HcalHitReconstructor::setPulseShapeFlags_

private

Definition at line 83 of file HcalHitReconstructor.h.

◆ setSaturationFlags_

bool HcalHitReconstructor::setSaturationFlags_

private

Definition at line 81 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ setTimingTrustFlags_

bool HcalHitReconstructor::setTimingTrustFlags_

private

Definition at line 82 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ sevToken_

edm::ESGetToken<HcalSeverityLevelComputer, HcalSeverityLevelComputerRcd> HcalHitReconstructor::sevToken_

private

Definition at line 117 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ subdet_

int HcalHitReconstructor::subdet_

private

Definition at line 71 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ subdetOther_

HcalOtherSubdetector HcalHitReconstructor::subdetOther_

private

Definition at line 72 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_calib_

edm::EDGetTokenT<HcalCalibDigiCollection> HcalHitReconstructor::tok_calib_

private

Definition at line 76 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_hf_

edm::EDGetTokenT<HFDigiCollection> HcalHitReconstructor::tok_hf_

private

Definition at line 75 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_ho_

edm::EDGetTokenT<HODigiCollection> HcalHitReconstructor::tok_ho_

private

Definition at line 74 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tsFromDB_

bool HcalHitReconstructor::tsFromDB_

private

Definition at line 92 of file HcalHitReconstructor.h.

Referenced by beginRun(), HcalHitReconstructor(), and produce().

◆ useLeakCorrection_

bool HcalHitReconstructor::useLeakCorrection_

private

Definition at line 97 of file HcalHitReconstructor.h.

Referenced by produce().

Public Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SetCorrectionFcn

Constructor & Destructor Documentation

◆ HcalHitReconstructor()

◆ ~HcalHitReconstructor()

Member Function Documentation

◆ beginRun()

◆ endRun()

◆ produce()

Member Data Documentation

◆ cat_

◆ conditionsToken_

◆ correctTiming_

◆ corrName_

◆ dataOOTCorrectionCategory_

◆ dataOOTCorrectionName_

◆ det_

◆ digiTimeFromDB_

◆ digiTimeToken_

◆ dropZSmarkedPassed_

◆ firstAuxTS_

◆ firstSample_

◆ hfdigibit_

◆ hFDigiTimeParams_

◆ hfPET_

◆ hfS8S1_

◆ hfS9S1_

◆ HFTimingTrustFlagSetter_

◆ htopoToken_

◆ inputLabel_

◆ mcOOTCorrectionCategory_

◆ mcOOTCorrectionName_

◆ paramsToken_

◆ paramTS_

◆ qualToken_

◆ reco_

◆ recoParamsFromDB_

◆ samplesToAdd_

◆ saturationFlagSetter_

◆ setHSCPFlags_

◆ setNegativeFlags_

◆ setNoiseFlags_

◆ setPileupCorrection_

◆ setPulseShapeFlags_

◆ setSaturationFlags_

◆ setTimingTrustFlags_

◆ sevToken_

◆ subdet_

◆ subdetOther_

◆ tok_calib_

◆ tok_hf_

◆ tok_ho_

◆ tsFromDB_

◆ useLeakCorrection_