#include <RecoLocalCalo/HcalRecProducers/plugins/HBHEPhase1Reconstructor.cc>

Inheritance diagram for HBHEPhase1Reconstructor:

Public Member Functions
	HBHEPhase1Reconstructor (const edm::ParameterSet &)

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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Private Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

void	endRun (edm::Run const &, edm::EventSetup const &) override

template<class DataFrame , class Collection >
void	processData (const Collection &coll, const HcalTopology &htopo, const HcalDbService &cond, const HcalChannelPropertiesVec &prop, const bool isRealData, HBHEChannelInfo info, HBHEChannelInfoCollection infoColl, HBHERecHitCollection *rechits)

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

void	runHBHENegativeEFilter (const HBHEChannelInfo &info, HBHERecHit *rh)

void	setAsicSpecificBits (const HBHEDataFrame &frame, const HcalCoder &coder, const HBHEChannelInfo &info, const HcalCalibrations &calib, int soi, HBHERecHit *rh)

void	setAsicSpecificBits (const QIE11DataFrame &frame, const HcalCoder &coder, const HBHEChannelInfo &info, const HcalCalibrations &calib, int soi, HBHERecHit *rh)

void	setCommonStatusBits (const HBHEChannelInfo &info, const HcalCalibrations &calib, HBHERecHit *rh)

Private Attributes
std::string	algoConfigClass_

edm::ESGetToken< HcalDbService, HcalDbRecord >	conditionsToken_

bool	dropZSmarkedPassed_

edm::ESGetToken< HcalFrontEndMap, HcalFrontEndMapRcd >	feMapToken_

std::unique_ptr< HBHEStatusBitSetter >	hbheFlagSetterQIE11_

std::unique_ptr< HBHEStatusBitSetter >	hbheFlagSetterQIE8_

std::unique_ptr< HBHEPulseShapeFlagSetter >	hbhePulseShapeFlagSetterQIE11_

std::unique_ptr< HBHEPulseShapeFlagSetter >	hbhePulseShapeFlagSetterQIE8_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	htopoToken_

bool	makeRecHits_

const HBHENegativeEFilter *	negEFilter_

edm::ESGetToken< HBHENegativeEFilter, HBHENegativeEFilterRcd >	negToken_

bool	processQIE11_

bool	processQIE8_

edm::ESGetToken< HcalChannelPropertiesVec, HcalChannelPropertiesRecord >	propertiesToken_

std::unique_ptr< AbsHBHEPhase1Algo >	reco_

std::unique_ptr< AbsHcalAlgoData >	recoConfig_

edm::ESGetToken< HFPhase1PMTParams, HFPhase1PMTParamsRcd >	recoConfigToken_

bool	recoParamsFromDB_

bool	saveDroppedInfos_

bool	saveEffectivePedestal_

bool	saveInfos_

bool	setNegativeFlagsQIE11_

bool	setNegativeFlagsQIE8_

bool	setNoiseFlagsQIE11_

bool	setNoiseFlagsQIE8_

bool	setPulseShapeFlagsQIE11_

bool	setPulseShapeFlagsQIE8_

int	sipmQNTStoSum_

int	sipmQTSShift_

edm::EDGetTokenT< QIE11DigiCollection >	tok_qie11_

edm::EDGetTokenT< HBHEDigiCollection >	tok_qie8_

bool	tsFromDB_

bool	use8ts_

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

Description: Phase 1 reconstruction module for HB/HE

Implementation: [Notes on implementation]

Definition at line 284 of file HBHEPhase1Reconstructor.cc.

Constructor & Destructor Documentation

◆ HBHEPhase1Reconstructor()

HBHEPhase1Reconstructor::HBHEPhase1Reconstructor ( const edm::ParameterSet & conf )

explicit

Definition at line 373 of file HBHEPhase1Reconstructor.cc.

References algoConfigClass_, conditionsToken_, Exception, feMapToken_, edm::ParameterSet::getParameter(), hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, hbhePulseShapeFlagSetterQIE11_, hbhePulseShapeFlagSetterQIE8_, htopoToken_, makeRecHits_, negToken_, processQIE11_, processQIE8_, propertiesToken_, reco_, recoConfigToken_, saveInfos_, setNegativeFlagsQIE11_, setNegativeFlagsQIE8_, setNoiseFlagsQIE11_, setNoiseFlagsQIE8_, setPulseShapeFlagsQIE11_, setPulseShapeFlagsQIE8_, tok_qie11_, and tok_qie8_.

     : algoConfigClass_(conf.getParameter<std::string>("algoConfigClass")),
       processQIE8_(conf.getParameter<bool>("processQIE8")),
       processQIE11_(conf.getParameter<bool>("processQIE11")),
       saveInfos_(conf.getParameter<bool>("saveInfos")),
       saveDroppedInfos_(conf.getParameter<bool>("saveDroppedInfos")),
       makeRecHits_(conf.getParameter<bool>("makeRecHits")),
       dropZSmarkedPassed_(conf.getParameter<bool>("dropZSmarkedPassed")),
       tsFromDB_(conf.getParameter<bool>("tsFromDB")),
       recoParamsFromDB_(conf.getParameter<bool>("recoParamsFromDB")),
       saveEffectivePedestal_(conf.getParameter<bool>("saveEffectivePedestal")),
       use8ts_(conf.getParameter<bool>("use8ts")),
       sipmQTSShift_(conf.getParameter<int>("sipmQTSShift")),
       sipmQNTStoSum_(conf.getParameter<int>("sipmQNTStoSum")),
       setNegativeFlagsQIE8_(conf.getParameter<bool>("setNegativeFlagsQIE8")),
       setNegativeFlagsQIE11_(conf.getParameter<bool>("setNegativeFlagsQIE11")),
       setNoiseFlagsQIE8_(conf.getParameter<bool>("setNoiseFlagsQIE8")),
       setNoiseFlagsQIE11_(conf.getParameter<bool>("setNoiseFlagsQIE11")),
       setPulseShapeFlagsQIE8_(conf.getParameter<bool>("setPulseShapeFlagsQIE8")),
       setPulseShapeFlagsQIE11_(conf.getParameter<bool>("setPulseShapeFlagsQIE11")),
       reco_(parseHBHEPhase1AlgoDescription(conf.getParameter<edm::ParameterSet>("algorithm"), consumesCollector())),
       negEFilter_(nullptr) {
   // Check that the reco algorithm has been successfully configured
   if (!reco_.get())
     throw cms::Exception("HBHEPhase1BadConfig") << "Invalid HBHEPhase1Algo algorithm configuration" << std::endl;
   if (reco_->isConfigurable()) {
     if ("HFPhase1PMTParams" != algoConfigClass_) {
       throw cms::Exception("HBHEPhase1BadConfig")
           << "Invalid HBHEPhase1Reconstructor \"algoConfigClass\" parameter value \"" << algoConfigClass_ << '"'
           << std::endl;
     }
     recoConfigToken_ = esConsumes<edm::Transition::BeginRun>();
   }
 
   // Configure the status bit setters that have been turned on
   if (setNoiseFlagsQIE8_)
     hbheFlagSetterQIE8_ = parse_HBHEStatusBitSetter(conf.getParameter<edm::ParameterSet>("flagParametersQIE8"));
 
   if (setNoiseFlagsQIE11_)
     hbheFlagSetterQIE11_ = parse_HBHEStatusBitSetter(conf.getParameter<edm::ParameterSet>("flagParametersQIE11"));
 
   if (setPulseShapeFlagsQIE8_)
     hbhePulseShapeFlagSetterQIE8_ =
         parse_HBHEPulseShapeFlagSetter(conf.getParameter<edm::ParameterSet>("pulseShapeParametersQIE8"),
                                        conf.getParameter<bool>("setLegacyFlagsQIE8"));
 
   if (setPulseShapeFlagsQIE11_)
     hbhePulseShapeFlagSetterQIE11_ =
         parse_HBHEPulseShapeFlagSetter(conf.getParameter<edm::ParameterSet>("pulseShapeParametersQIE11"),
                                        conf.getParameter<bool>("setLegacyFlagsQIE11"));
 
   // Consumes and produces statements
   if (processQIE8_)
     tok_qie8_ = consumes<HBHEDigiCollection>(conf.getParameter<edm::InputTag>("digiLabelQIE8"));
 
   if (processQIE11_)
     tok_qie11_ = consumes<QIE11DigiCollection>(conf.getParameter<edm::InputTag>("digiLabelQIE11"));
 
   if (saveInfos_)
     produces<HBHEChannelInfoCollection>();
 
   if (makeRecHits_)
     produces<HBHERecHitCollection>();
 
   // ES tokens
   htopoToken_ = esConsumes<HcalTopology, HcalRecNumberingRecord>();
   conditionsToken_ = esConsumes<HcalDbService, HcalDbRecord>();
   propertiesToken_ = esConsumes<HcalChannelPropertiesVec, HcalChannelPropertiesRecord>();
   if (setNegativeFlagsQIE8_ || setNegativeFlagsQIE11_)
     negToken_ = esConsumes<HBHENegativeEFilter, HBHENegativeEFilterRcd>();
   if (setNoiseFlagsQIE8_ || setNoiseFlagsQIE11_)
     feMapToken_ = esConsumes<HcalFrontEndMap, HcalFrontEndMapRcd, edm::Transition::BeginRun>();
 }

◆ ~HBHEPhase1Reconstructor()

HBHEPhase1Reconstructor::~HBHEPhase1Reconstructor ( )

override

Definition at line 447 of file HBHEPhase1Reconstructor.cc.

                                                   {
   // do anything here that needs to be done at destruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ beginRun()

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

overrideprivate

Definition at line 739 of file HBHEPhase1Reconstructor.cc.

References Exception, feMapToken_, edm::EventSetup::getData(), edm::EventSetup::getHandle(), patZpeak::handle, hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, alignCSCRings::r, reco_, recoConfig_, recoConfigToken_, setNoiseFlagsQIE11_, and setNoiseFlagsQIE8_.

                                                                                {
   if (reco_->isConfigurable()) {
     recoConfig_ = std::make_unique<HFPhase1PMTParams>(es.getData(recoConfigToken_));
     if (!reco_->configure(recoConfig_.get()))
       throw cms::Exception("HBHEPhase1BadConfig")
           << "Failed to configure HBHEPhase1Algo algorithm from EventSetup" << std::endl;
   }
 
   if (setNoiseFlagsQIE8_ || setNoiseFlagsQIE11_) {
     if (auto handle = es.getHandle(feMapToken_)) {
       const HcalFrontEndMap& hfemap = *handle;
       if (setNoiseFlagsQIE8_)
         hbheFlagSetterQIE8_->SetFrontEndMap(&hfemap);
       if (setNoiseFlagsQIE11_)
         hbheFlagSetterQIE11_->SetFrontEndMap(&hfemap);
     } else {
       edm::LogWarning("EventSetup") << "HBHEPhase1Reconstructor failed to get HcalFrontEndMap!" << std::endl;
     }
   }
 
   reco_->beginRun(r, es);
 }

◆ endRun()

void HBHEPhase1Reconstructor::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

overrideprivate

Definition at line 762 of file HBHEPhase1Reconstructor.cc.

References reco_.

762 { reco_->endRun(); }

HBHEPhase1Reconstructor::reco_

std::unique_ptr< AbsHBHEPhase1Algo > reco_

Definition: HBHEPhase1Reconstructor.cc:322

◆ fillDescriptions()

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

static

Definition at line 770 of file HBHEPhase1Reconstructor.cc.

References add_param_set, edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, fillDescriptionForParseHBHEPhase1Algo(), HLT_2024v11_cff::flagParametersQIE11, HLT_2024v11_cff::flagParametersQIE8, HLT_2024v11_cff::pulseShapeParametersQIE11, HLT_2024v11_cff::pulseShapeParametersQIE8, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   edm::ParameterSetDescription desc;
 
   desc.add<edm::InputTag>("digiLabelQIE8");
   desc.add<edm::InputTag>("digiLabelQIE11");
   desc.add<std::string>("algoConfigClass");
   desc.add<bool>("processQIE8");
   desc.add<bool>("processQIE11");
   desc.add<bool>("saveInfos");
   desc.add<bool>("saveDroppedInfos");
   desc.add<bool>("makeRecHits");
   desc.add<bool>("dropZSmarkedPassed");
   desc.add<bool>("tsFromDB");
   desc.add<bool>("recoParamsFromDB");
   desc.add<bool>("saveEffectivePedestal", false);
   desc.add<bool>("use8ts", false);
   desc.add<int>("sipmQTSShift", 0);
   desc.add<int>("sipmQNTStoSum", 3);
   desc.add<bool>("setNegativeFlagsQIE8");
   desc.add<bool>("setNegativeFlagsQIE11");
   desc.add<bool>("setNoiseFlagsQIE8");
   desc.add<bool>("setNoiseFlagsQIE11");
   desc.add<bool>("setPulseShapeFlagsQIE8");
   desc.add<bool>("setPulseShapeFlagsQIE11");
   desc.add<bool>("setLegacyFlagsQIE8");
   desc.add<bool>("setLegacyFlagsQIE11");
 
   desc.add<edm::ParameterSetDescription>("algorithm", fillDescriptionForParseHBHEPhase1Algo());
   add_param_set(flagParametersQIE8);
   add_param_set(flagParametersQIE11);
   add_param_set(pulseShapeParametersQIE8);
   add_param_set(pulseShapeParametersQIE11);
 
   descriptions.addDefault(desc);
 }

◆ processData()

template<class DFrame , class Collection >

void HBHEPhase1Reconstructor::processData	(	const Collection &	coll,
		const HcalTopology &	htopo,
		const HcalDbService &	cond,
		const HcalChannelPropertiesVec &	prop,
		const bool	isRealData,
		HBHEChannelInfo *	info,
		HBHEChannelInfoCollection *	infoColl,
		HBHERecHitCollection *	rechits
	)

private

Definition at line 456 of file HBHEPhase1Reconstructor.cc.

References gpuClustering::adc, HcalCoderDb::adc2fC(), HcalChannelProperties::calib, HcalChannelProperties::channelCoder, callgraph::cs, HcalTopology::detId2denseId(), dropZSmarkedPassed_, HcalRecoParam::firstSample(), amptDefault_cfi::frame, HcalSiPMParameter::getauxi2(), HcalSiPMParameter::getDarkCurrent(), HcalSiPMParameter::getFCByPE(), HcalSiPMParameter::getType(), HBHEChannelInfo::hasEffectivePedestals(), HBHEChannelInfo::hasTimeInfo(), HcalBarrel, HcalEndcap, HBHERecHit::id(), submitPVValidationJobs::infos, HBHEChannelInfo::isDropped(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, HBHEChannelInfo::MAXSAMPLES, hcaldqm::utilities::maxTS(), SiStripPI::min, HcalChannelProperties::paramTs, HcalChannelProperties::pedsAndGains, HcalRecoParam::pulseShapeID(), DetId::rawId(), HI_PhotonSkim_cff::rechits, reco_, recoParamsFromDB_, alignCSCRings::s, saveDroppedInfos_, saveInfos_, setAsicSpecificBits(), HBHEChannelInfo::setChannelInfo(), setCommonStatusBits(), HBHEChannelInfo::setSample(), HcalChannelProperties::shape, HcalChannelProperties::siPMParameter, sipmQNTStoSum_, sipmQTSShift_, HcalDetId::subdet(), submitPVValidationJobs::t, HcalChannelProperties::taggedBadByDb, tsFromDB_, and use8ts_.

                                                                          {
   // If "saveDroppedInfos_" flag is set, fill the info with something
   // meaningful even if the database tells us to drop this channel.
   // Note that this flag affects only "infos", the rechits are still
   // not going to be constructed from such channels.
   const bool skipDroppedChannels = !(infos && saveDroppedInfos_);
 
   // Iterate over the input collection
   for (typename Collection::const_iterator it = coll.begin(); it != coll.end(); ++it) {
     const DFrame& frame(*it);
     const HcalDetId cell(frame.id());
 
     // Protection against calibration channels which are not
     // in the database but can still come in the QIE11DataFrame
     // in the laser calibs, etc.
     const HcalSubdetector subdet = cell.subdet();
     if (!(subdet == HcalSubdetector::HcalBarrel || subdet == HcalSubdetector::HcalEndcap))
       continue;
 
     // Look up the channel properties. This lookup is O(1).
     const HcalChannelProperties& properties(prop.at(htopo.detId2denseId(cell)));
 
     // Check if the database tells us to drop this channel
     if (properties.taggedBadByDb && skipDroppedChannels)
       continue;
 
     // Check if the channel is zero suppressed
     bool dropByZS = false;
     if (dropZSmarkedPassed_)
       if (frame.zsMarkAndPass())
         dropByZS = true;
     if (dropByZS && skipDroppedChannels)
       continue;
 
     // ADC decoding tool
     const HcalCoderDb coder(*properties.channelCoder, *properties.shape);
 
     const bool saveEffectivePeds = channelInfo->hasEffectivePedestals();
     const double fcByPE = properties.siPMParameter->getFCByPE();
     double darkCurrent = 0.;
     double lambda = 0.;
     const double noisecorr = properties.siPMParameter->getauxi2();
     if (!saveEffectivePeds || saveInfos_) {
       // needed for the dark current in the M2 in alternative of the effectivePed
       darkCurrent = properties.siPMParameter->getDarkCurrent();
       lambda = cond.getHcalSiPMCharacteristics()->getCrossTalk(properties.siPMParameter->getType());
     }
 
     // ADC to fC conversion
     CaloSamples cs;
     coder.adc2fC(frame, cs);
 
     // Prepare to iterate over time slices
     const int nRead = cs.size();
     const int maxTS = std::min(nRead, static_cast<int>(HBHEChannelInfo::MAXSAMPLES));
     const int soi = tsFromDB_ ? properties.paramTs->firstSample() : frame.presamples();
     const bool badSOI = !(maxTS >= 3 && soi > 0 && soi < maxTS - 1);
     if (badSOI) {
       edm::LogWarning("HBHEDigi") << " bad SOI/maxTS in cell " << cell
                                   << "\n expect maxTS >= 3 && soi > 0 && soi < maxTS - 1"
                                   << "\n got maxTS = " << maxTS << ", SOI = " << soi;
     }
 
     const RawChargeFromSample<DFrame> rcfs(sipmQTSShift_, sipmQNTStoSum_, cond, properties, cs, soi, frame, maxTS);
     int soiCapid = 4;
 
     // Typical expected cases:
     //   maxTS = 10, SOI = 4 (typical 10-TS situation, in data or MC)
     //   maxTS = 10, SOI = 5 (new, for better modeling of SiPM noise in MC)
     //   maxTS = 8,  SOI = 3 (typical 8-TS situation in data)
     //
     // We want to fill the HBHEChannelInfo object with either
     // 8 or 10 time slices, depending on the maxTS value and
     // on the "use8ts_" parameter setting. If we want 8 time
     // slices in the HBHEChannelInfo, we want the SOI to fall
     // on the time slice number 3. For now, this number is not
     // expected to change and will be hardwired.
     //
     int nTSToCopy = maxTS;
     int tsShift = 0;
     if (maxTS > 8 && use8ts_) {
       const int soiWanted = 3;
 
       // We need to chop off the excess time slices
       // and configure the TS shift for filling
       // HBHEChannelInfo from the data frame.
       nTSToCopy = 8;
       tsShift = determineIndexShift(soi, nRead, soiWanted, nTSToCopy);
     }
 
     // Go over time slices and fill the samples
     for (int copyTS = 0; copyTS < nTSToCopy; ++copyTS) {
       const int inputTS = copyTS + tsShift;
       auto s(frame[inputTS]);
       const uint8_t adc = s.adc();
       const int capid = s.capid();
       const HcalPipelinePedestalAndGain& pAndGain(properties.pedsAndGains.at(capid));
 
       // Always use QIE-only pedestal for this computation
       const double rawCharge = rcfs.getRawCharge(cs[inputTS], pAndGain.pedestal(false));
       const float t = getTDCTimeFromSample(s);
       const float dfc = getDifferentialChargeGain(
           *properties.channelCoder, *properties.shape, adc, capid, channelInfo->hasTimeInfo());
       channelInfo->setSample(copyTS,
                              adc,
                              dfc,
                              rawCharge,
                              pAndGain.pedestal(saveEffectivePeds),
                              pAndGain.pedestalWidth(saveEffectivePeds),
                              pAndGain.gain(),
                              pAndGain.gainWidth(),
                              t);
       if (inputTS == soi)
         soiCapid = capid;
     }
 
     // Fill the overall channel info items
     const int fitSoi = soi - tsShift;
     const int pulseShapeID = properties.paramTs->pulseShapeID();
     const std::pair<bool, bool> hwerr = findHWErrors(frame, maxTS);
     channelInfo->setChannelInfo(cell,
                                 pulseShapeID,
                                 nTSToCopy,
                                 fitSoi,
                                 soiCapid,
                                 darkCurrent,
                                 fcByPE,
                                 lambda,
                                 noisecorr,
                                 hwerr.first,
                                 hwerr.second,
                                 properties.taggedBadByDb || dropByZS || badSOI);
 
     // If needed, add the channel info to the output collection
     const bool makeThisRechit = !channelInfo->isDropped();
     if (infos && (saveDroppedInfos_ || makeThisRechit))
       infos->push_back(*channelInfo);
 
     // Reconstruct the rechit
     if (rechits && makeThisRechit) {
       const HcalRecoParam* pptr = nullptr;
       if (recoParamsFromDB_)
         pptr = properties.paramTs;
       HBHERecHit rh = reco_->reconstruct(*channelInfo, pptr, *properties.calib, isRealData);
       if (rh.id().rawId()) {
         setAsicSpecificBits(frame, coder, *channelInfo, *properties.calib, soi, &rh);
         setCommonStatusBits(*channelInfo, *properties.calib, &rh);
         rechits->push_back(rh);
       }
     }
   }
 }

◆ produce()

void HBHEPhase1Reconstructor::produce	(	edm::Event &	e,
		const edm::EventSetup &	eventSetup
	)

overrideprivate

Definition at line 667 of file HBHEPhase1Reconstructor.cc.

References submitPVValidationJobs::conditions, conditionsToken_, MillePedeFileConverter_cfg::e, options_cfi::eventSetup, hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, htopoToken_, submitPVValidationJobs::infos, HLTBitAnalyser_cfi::isData, makeRecHits_, eostools::move(), negEFilter_, negToken_, MillePedeFileConverter_cfg::out, processQIE11_, processQIE8_, propertiesToken_, saveEffectivePedestal_, saveInfos_, setNegativeFlagsQIE11_, setNegativeFlagsQIE8_, setNoiseFlagsQIE11_, setNoiseFlagsQIE8_, edm::SortedCollection< T, SORT >::size(), edm::DataFrameContainer::size(), tok_qie11_, and tok_qie8_.

                                                                                   {
   using namespace edm;
 
   // Get the Hcal topology
   const HcalTopology* htopo = &eventSetup.getData(htopoToken_);
 
   // Fetch the calibrations
   const HcalDbService* conditions = &eventSetup.getData(conditionsToken_);
   const HcalChannelPropertiesVec* prop = &eventSetup.getData(propertiesToken_);
 
   // Configure the negative energy filter
   if (setNegativeFlagsQIE8_ || setNegativeFlagsQIE11_) {
     negEFilter_ = &eventSetup.getData(negToken_);
   }
 
   // Find the input data
   unsigned maxOutputSize = 0;
   Handle<HBHEDigiCollection> hbDigis;
   if (processQIE8_) {
     e.getByToken(tok_qie8_, hbDigis);
     maxOutputSize += hbDigis->size();
   }
 
   Handle<QIE11DigiCollection> heDigis;
   if (processQIE11_) {
     e.getByToken(tok_qie11_, heDigis);
     maxOutputSize += heDigis->size();
   }
 
   // Create new output collections
   std::unique_ptr<HBHEChannelInfoCollection> infos;
   if (saveInfos_) {
     infos = std::make_unique<HBHEChannelInfoCollection>();
     infos->reserve(maxOutputSize);
   }
 
   std::unique_ptr<HBHERecHitCollection> out;
   if (makeRecHits_) {
     out = std::make_unique<HBHERecHitCollection>();
     out->reserve(maxOutputSize);
   }
 
   // Process the input collections, filling the output ones
   const bool isData = e.isRealData();
   if (processQIE8_) {
     if (setNoiseFlagsQIE8_)
       hbheFlagSetterQIE8_->Clear();
 
     HBHEChannelInfo channelInfo(false, false);
     processData<HBHEDataFrame>(*hbDigis, *htopo, *conditions, *prop, isData, &channelInfo, infos.get(), out.get());
     if (setNoiseFlagsQIE8_)
       hbheFlagSetterQIE8_->SetFlagsFromRecHits(*out);
   }
 
   if (processQIE11_) {
     if (setNoiseFlagsQIE11_)
       hbheFlagSetterQIE11_->Clear();
 
     HBHEChannelInfo channelInfo(true, saveEffectivePedestal_);
     processData<QIE11DataFrame>(*heDigis, *htopo, *conditions, *prop, isData, &channelInfo, infos.get(), out.get());
     if (setNoiseFlagsQIE11_)
       hbheFlagSetterQIE11_->SetFlagsFromRecHits(*out);
   }
 
   // Add the output collections to the event record
   if (saveInfos_)
     e.put(std::move(infos));
   if (makeRecHits_)
     e.put(std::move(out));
 }

◆ runHBHENegativeEFilter()

void HBHEPhase1Reconstructor::runHBHENegativeEFilter	(	const HBHEChannelInfo &	info,
		HBHERecHit *	rh
	)

private

Definition at line 656 of file HBHEPhase1Reconstructor.cc.

References HBHENegativeEFilter::checkPassFilter(), HcalPhase1FlagLabels::HBHENegativeNoise, mps_fire::i, info(), HBHEChannelInfo::MAXSAMPLES, negEFilter_, and CaloRecHit::setFlagField().

Referenced by setAsicSpecificBits().

                                                                                                 {
   double ts[HBHEChannelInfo::MAXSAMPLES];
   const unsigned nRead = info.nSamples();
   for (unsigned i = 0; i < nRead; ++i)
     ts[i] = info.tsCharge(i);
   const bool passes = negEFilter_->checkPassFilter(info.id(), &ts[0], nRead);
   if (!passes)
     rh->setFlagField(1, HcalPhase1FlagLabels::HBHENegativeNoise);
 }

◆ setAsicSpecificBits() [1/2]

void HBHEPhase1Reconstructor::setAsicSpecificBits	(	const HBHEDataFrame &	frame,
		const HcalCoder &	coder,
		const HBHEChannelInfo &	info,
		const HcalCalibrations &	calib,
		int	soi,
		HBHERecHit *	rh
	)

private

Definition at line 620 of file HBHEPhase1Reconstructor.cc.

References hbheFlagSetterQIE8_, hbhePulseShapeFlagSetterQIE8_, info(), runHBHENegativeEFilter(), HBHERecHit::setAuxTDC(), setNegativeFlagsQIE8_, setNoiseFlagsQIE8_, setPulseShapeFlagsQIE8_, and mitigatedMETSequence_cff::U.

Referenced by processData().

                                                                   {
   if (setNoiseFlagsQIE8_)
     hbheFlagSetterQIE8_->rememberHit(*rh);
 
   if (setPulseShapeFlagsQIE8_)
     hbhePulseShapeFlagSetterQIE8_->SetPulseShapeFlags(*rh, frame, coder, calib);
 
   if (setNegativeFlagsQIE8_)
     runHBHENegativeEFilter(info, rh);
 
   rh->setAuxTDC(0U);
 }

◆ setAsicSpecificBits() [2/2]

void HBHEPhase1Reconstructor::setAsicSpecificBits	(	const QIE11DataFrame &	frame,
		const HcalCoder &	coder,
		const HBHEChannelInfo &	info,
		const HcalCalibrations &	calib,
		int	soi,
		HBHERecHit *	rh
	)

private

Definition at line 638 of file HBHEPhase1Reconstructor.cc.

References hbheFlagSetterQIE11_, hbhePulseShapeFlagSetterQIE11_, info(), runHBHENegativeEFilter(), HBHERecHit::setAuxTDC(), setNegativeFlagsQIE11_, setNoiseFlagsQIE11_, and setPulseShapeFlagsQIE11_.

                                                                   {
   if (setNoiseFlagsQIE11_)
     hbheFlagSetterQIE11_->rememberHit(*rh);
 
   if (setPulseShapeFlagsQIE11_)
     hbhePulseShapeFlagSetterQIE11_->SetPulseShapeFlags(*rh, frame, coder, calib);
 
   if (setNegativeFlagsQIE11_)
     runHBHENegativeEFilter(info, rh);
 
   rh->setAuxTDC(packTDCData(frame, soi));
 }