HcalHitReconstructor Class Reference

#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_.

{ reco_.endRun(); }

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, 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_, 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().