#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
std::string	cat_

bool	correctTiming_

std::string	corrName_

std::string	dataOOTCorrectionCategory_

std::string	dataOOTCorrectionName_

DetId::Detector	det_

bool	digiTimeFromDB_

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::InputTag	inputLabel_

std::string	mcOOTCorrectionCategory_

std::string	mcOOTCorrectionName_

HcalRecoParams *	paramTS

HcalSimpleRecAlgo	reco_

bool	recoParamsFromDB_

int	samplesToAdd_

HcalADCSaturationFlag *	saturationFlagSetter_

bool	setHSCPFlags_

bool	setNegativeFlags_

bool	setNoiseFlags_

SetCorrectionFcn	setPileupCorrection_

bool	setPulseShapeFlags_

bool	setSaturationFlags_

bool	setTimingTrustFlags_

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<>
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. Temple & E. Yazgan Based on HcalSimpleReconstructor.h by J. Mans

Definition at line 41 of file HcalHitReconstructor.h.

Member Typedef Documentation

◆ SetCorrectionFcn

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

private

Definition at line 51 of file HcalHitReconstructor.h.

Constructor & Destructor Documentation

◆ HcalHitReconstructor()

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

explicit

Definition at line 26 of file HcalHitReconstructor.cc.

     : reco_(conf.getParameter<bool>("correctForTimeslew"),
             conf.getParameter<bool>("correctForPhaseContainment"),
             conf.getParameter<double>("correctionPhaseNS")),
       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),
       paramTS(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;
 }

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

◆ ~HcalHitReconstructor()

HcalHitReconstructor::~HcalHitReconstructor ( )

override

Definition at line 167 of file HcalHitReconstructor.cc.

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

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

Member Function Documentation

◆ beginRun()

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

final

Definition at line 179 of file HcalHitReconstructor.cc.

                                                                             {
   edm::ESHandle<HcalTopology> htopo;
   es.get<HcalRecNumberingRecord>().get(htopo);
  
   if (tsFromDB_ == true || recoParamsFromDB_ == true) {
     edm::ESHandle<HcalRecoParams> p;
     es.get<HcalRecoParamsRcd>().get(p);
     paramTS = new HcalRecoParams(*p.product());
     paramTS->setTopo(htopo.product());
  
     // std::cout<<" skdump in HcalHitReconstructor::beginRun   dupm RecoParams "<<std::endl;
     // std::ofstream skfile("skdumpRecoParamsNewFormat.txt");
     // HcalDbASCIIIO::dumpObject(skfile, (*paramTS) );
   }
  
   if (digiTimeFromDB_ == true) {
     edm::ESHandle<HcalFlagHFDigiTimeParams> p;
     es.get<HcalFlagHFDigiTimeParamsRcd>().get(p);
     HFDigiTimeParams.reset(new HcalFlagHFDigiTimeParams(*p));
     HFDigiTimeParams->setTopo(htopo.product());
   }
  
   reco_.beginRun(es);
 }

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

◆ endRun()

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

final

Definition at line 204 of file HcalHitReconstructor.cc.

                                                                           {
   if (tsFromDB_ == true) {
     delete paramTS;
     paramTS = nullptr;
   }
   if (digiTimeFromDB_ == true) {
     //DL delete HFDigiTimeParams; HFDigiTimeParams = 0;
   }
   reco_.endRun();
 }

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

◆ produce()

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

override

Definition at line 215 of file HcalHitReconstructor.cc.

                                                                                {
   // get conditions
   edm::ESHandle<HcalTopology> topo;
   eventSetup.get<HcalRecNumberingRecord>().get(topo);
  
   edm::ESHandle<HcalDbService> conditions;
   eventSetup.get<HcalDbRecord>().get(conditions);
  
   if (useLeakCorrection_)
     reco_.setLeakCorrection();
  
   edm::ESHandle<HcalChannelQuality> p;
   eventSetup.get<HcalChannelQualityRcd>().get("withTopo", p);
   const HcalChannelQuality* myqual = p.product();
  
   edm::ESHandle<HcalSeverityLevelComputer> mycomputer;
   eventSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
   const HcalSeverityLevelComputer* mySeverity = mycomputer.product();
  
   // 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_ == true && hfdigibit_ != nullptr) {
           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(...)

References funct::abs(), edm::SortedCollection< T, SORT >::begin(), AlignmentProducer_cff::calibrations, 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(), dqmdumpme::first, HcalRecoParam::firstAuxTS(), firstAuxTS_, HcalRecoParam::firstSample(), firstSample_, edm::EventSetup::get(), get, HcalDbService::getHcalCalibrations(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), 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(), AlCaHLTBitMon_ParallelJobs::p, paramTS, HcalRecoParam::pileupCleaningID(), HcalCaloFlagLabels::PresampleADC, edm::ESHandle< T >::product(), DetId::rawId(), reco_, HcalSimpleRecAlgo::reconstruct(), recoParamsFromDB_, HcalHFStatusBitFromDigis::resetParamsFromDB(), HcalRecoParam::samplesToAdd(), samplesToAdd_, saturationFlagSetter_, HFTimingTrustFlag::setHFTimingTrustFlag(), HcalSimpleRecAlgo::setLeakCorrection(), setNoiseFlags_, HcalSimpleRecAlgo::setRecoParams(), HcalADCSaturationFlag::setSaturationFlag(), setSaturationFlags_, setTimingTrustFlags_, edm::SortedCollection< T, SORT >::size(), subdet_, subdetOther_, tok_calib_, tok_hf_, tok_ho_, tsFromDB_, HcalRecoParam::useLeakCorrection(), useLeakCorrection_, and geometryCSVtoXML::xx.

Member Data Documentation

◆ cat_

std::string HcalHitReconstructor::cat_

private

Definition at line 100 of file HcalHitReconstructor.h.

◆ correctTiming_

bool HcalHitReconstructor::correctTiming_

private

Definition at line 69 of file HcalHitReconstructor.h.

Referenced by produce().

◆ corrName_

std::string HcalHitReconstructor::corrName_

private

Definition at line 100 of file HcalHitReconstructor.h.

◆ dataOOTCorrectionCategory_

std::string HcalHitReconstructor::dataOOTCorrectionCategory_

private

Definition at line 92 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ dataOOTCorrectionName_

std::string HcalHitReconstructor::dataOOTCorrectionName_

private

Definition at line 91 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ det_

DetId::Detector HcalHitReconstructor::det_

private

Definition at line 61 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ digiTimeFromDB_

bool HcalHitReconstructor::digiTimeFromDB_

private

Definition at line 85 of file HcalHitReconstructor.h.

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

◆ dropZSmarkedPassed_

bool HcalHitReconstructor::dropZSmarkedPassed_

private

Definition at line 76 of file HcalHitReconstructor.h.

Referenced by produce().

◆ firstAuxTS_

int HcalHitReconstructor::firstAuxTS_

private

Definition at line 78 of file HcalHitReconstructor.h.

Referenced by produce().

◆ firstSample_

int HcalHitReconstructor::firstSample_

private

Definition at line 81 of file HcalHitReconstructor.h.

Referenced by produce().

◆ hfdigibit_

HcalHFStatusBitFromDigis* HcalHitReconstructor::hfdigibit_

private

Definition at line 56 of file HcalHitReconstructor.h.

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

◆ HFDigiTimeParams

std::unique_ptr<HcalFlagHFDigiTimeParams> HcalHitReconstructor::HFDigiTimeParams

private

Definition at line 98 of file HcalHitReconstructor.h.

Referenced by beginRun(), and produce().

◆ hfPET_

HcalHF_PETalgorithm* HcalHitReconstructor::hfPET_

private

Definition at line 59 of file HcalHitReconstructor.h.

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

◆ hfS8S1_

HcalHF_S9S1algorithm* HcalHitReconstructor::hfS8S1_

private

Definition at line 58 of file HcalHitReconstructor.h.

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

◆ hfS9S1_

HcalHF_S9S1algorithm* HcalHitReconstructor::hfS9S1_

private

Definition at line 57 of file HcalHitReconstructor.h.

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

◆ HFTimingTrustFlagSetter_

HFTimingTrustFlag* HcalHitReconstructor::HFTimingTrustFlagSetter_

private

Definition at line 55 of file HcalHitReconstructor.h.

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

◆ inputLabel_

edm::InputTag HcalHitReconstructor::inputLabel_

private

Definition at line 64 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ mcOOTCorrectionCategory_

std::string HcalHitReconstructor::mcOOTCorrectionCategory_

private

Definition at line 94 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ mcOOTCorrectionName_

std::string HcalHitReconstructor::mcOOTCorrectionName_

private

Definition at line 93 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ paramTS

HcalRecoParams* HcalHitReconstructor::paramTS

private

Definition at line 97 of file HcalHitReconstructor.h.

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

◆ reco_

HcalSimpleRecAlgo HcalHitReconstructor::reco_

private

Definition at line 53 of file HcalHitReconstructor.h.

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

◆ recoParamsFromDB_

bool HcalHitReconstructor::recoParamsFromDB_

private

Definition at line 84 of file HcalHitReconstructor.h.

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

◆ samplesToAdd_

int HcalHitReconstructor::samplesToAdd_

private

Definition at line 82 of file HcalHitReconstructor.h.

Referenced by produce().

◆ saturationFlagSetter_

HcalADCSaturationFlag* HcalHitReconstructor::saturationFlagSetter_

private

Definition at line 54 of file HcalHitReconstructor.h.

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

◆ setHSCPFlags_

bool HcalHitReconstructor::setHSCPFlags_

private

Definition at line 71 of file HcalHitReconstructor.h.

◆ setNegativeFlags_

bool HcalHitReconstructor::setNegativeFlags_

private

Definition at line 75 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ setNoiseFlags_

bool HcalHitReconstructor::setNoiseFlags_

private

Definition at line 70 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ setPileupCorrection_

SetCorrectionFcn HcalHitReconstructor::setPileupCorrection_

private

Definition at line 95 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor().

◆ setPulseShapeFlags_

bool HcalHitReconstructor::setPulseShapeFlags_

private

Definition at line 74 of file HcalHitReconstructor.h.

◆ setSaturationFlags_

bool HcalHitReconstructor::setSaturationFlags_

private

Definition at line 72 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ setTimingTrustFlags_

bool HcalHitReconstructor::setTimingTrustFlags_

private

Definition at line 73 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ subdet_

int HcalHitReconstructor::subdet_

private

Definition at line 62 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ subdetOther_

HcalOtherSubdetector HcalHitReconstructor::subdetOther_

private

Definition at line 63 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_calib_

edm::EDGetTokenT<HcalCalibDigiCollection> HcalHitReconstructor::tok_calib_

private

Definition at line 67 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_hf_

edm::EDGetTokenT<HFDigiCollection> HcalHitReconstructor::tok_hf_

private

Definition at line 66 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tok_ho_

edm::EDGetTokenT<HODigiCollection> HcalHitReconstructor::tok_ho_

private

Definition at line 65 of file HcalHitReconstructor.h.

Referenced by HcalHitReconstructor(), and produce().

◆ tsFromDB_

bool HcalHitReconstructor::tsFromDB_

private

Definition at line 83 of file HcalHitReconstructor.h.

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

◆ useLeakCorrection_

bool HcalHitReconstructor::useLeakCorrection_

private

Definition at line 88 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_

◆ correctTiming_

◆ corrName_

◆ dataOOTCorrectionCategory_

◆ dataOOTCorrectionName_

◆ det_

◆ digiTimeFromDB_

◆ dropZSmarkedPassed_

◆ firstAuxTS_

◆ firstSample_

◆ hfdigibit_

◆ HFDigiTimeParams

◆ hfPET_

◆ hfS8S1_

◆ hfS9S1_

◆ HFTimingTrustFlagSetter_

◆ inputLabel_

◆ mcOOTCorrectionCategory_

◆ mcOOTCorrectionName_

◆ paramTS

◆ reco_

◆ recoParamsFromDB_

◆ samplesToAdd_

◆ saturationFlagSetter_

◆ setHSCPFlags_

◆ setNegativeFlags_

◆ setNoiseFlags_

◆ setPileupCorrection_

◆ setPulseShapeFlags_

◆ setSaturationFlags_

◆ setTimingTrustFlags_

◆ subdet_

◆ subdetOther_

◆ tok_calib_

◆ tok_hf_

◆ tok_ho_

◆ tsFromDB_

◆ useLeakCorrection_