#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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

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 HcalDbService &cond, const HcalChannelQuality &qual, const HcalSeverityLevelComputer &severity, const bool isRealData, HBHEChannelInfo info, HBHEChannelInfoCollection infoColl, HBHERecHitCollection *rechits, const bool use8ts)

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, HBHERecHit *rh)

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

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

Private Attributes
std::string	algoConfigClass_

bool	dropZSmarkedPassed_

std::unique_ptr< HBHEStatusBitSetter >	hbheFlagSetterQIE11_

std::unique_ptr< HBHEStatusBitSetter >	hbheFlagSetterQIE8_

std::unique_ptr< HBHEPulseShapeFlagSetter >	hbhePulseShapeFlagSetterQIE11_

std::unique_ptr< HBHEPulseShapeFlagSetter >	hbhePulseShapeFlagSetterQIE8_

bool	makeRecHits_

const HBHENegativeEFilter *	negEFilter_

std::unique_ptr< HcalRecoParams >	paramTS_

bool	processQIE11_

bool	processQIE8_

std::unique_ptr< AbsHBHEPhase1Algo >	reco_

std::unique_ptr< AbsHcalAlgoData >	recoConfig_

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<>
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

Description: Phase 1 reconstruction module for HB/HE

Implementation: [Notes on implementation]

Definition at line 250 of file HBHEPhase1Reconstructor.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 331 of file HBHEPhase1Reconstructor.cc.

References edm::ParameterSet::getParameter(), hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, hbhePulseShapeFlagSetterQIE11_, hbhePulseShapeFlagSetterQIE8_, makeRecHits_, processQIE11_, processQIE8_, reco_, saveInfos_, 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"))),
       negEFilter_(nullptr) {
   // Check that the reco algorithm has been successfully configured
   if (!reco_.get())
     throw cms::Exception("HBHEPhase1BadConfig") << "Invalid HBHEPhase1Algo algorithm configuration" << std::endl;
 
   // 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>();
 }

HBHEPhase1Reconstructor::~HBHEPhase1Reconstructor ( )

override

Definition at line 388 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

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

overrideprivate

Definition at line 659 of file HBHEPhase1Reconstructor.cc.

References algoConfigClass_, Exception, fetchHcalAlgoData(), edm::EventSetup::get(), hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, edm::ESHandleBase::isValid(), AlCaHLTBitMon_ParallelJobs::p, paramTS_, edm::ESHandle< T >::product(), reco_, recoConfig_, setNoiseFlagsQIE11_, and setNoiseFlagsQIE8_.

                                                                                {
   edm::ESHandle<HcalRecoParams> p;
   es.get<HcalRecoParamsRcd>().get(p);
   paramTS_ = std::make_unique<HcalRecoParams>(*p.product());
 
   if (reco_->isConfigurable()) {
     recoConfig_ = fetchHcalAlgoData(algoConfigClass_, es);
     if (!recoConfig_.get())
       throw cms::Exception("HBHEPhase1BadConfig")
           << "Invalid HBHEPhase1Reconstructor \"algoConfigClass\" parameter value \"" << algoConfigClass_ << '"'
           << std::endl;
     if (!reco_->configure(recoConfig_.get()))
       throw cms::Exception("HBHEPhase1BadConfig")
           << "Failed to configure HBHEPhase1Algo algorithm from EventSetup" << std::endl;
   }
 
   if (setNoiseFlagsQIE8_ || setNoiseFlagsQIE11_) {
     edm::ESHandle<HcalFrontEndMap> hfemap;
     es.get<HcalFrontEndMapRcd>().get(hfemap);
     if (hfemap.isValid()) {
       if (setNoiseFlagsQIE8_)
         hbheFlagSetterQIE8_->SetFrontEndMap(hfemap.product());
       if (setNoiseFlagsQIE11_)
         hbheFlagSetterQIE11_->SetFrontEndMap(hfemap.product());
     } else
       edm::LogWarning("EventSetup") << "HBHEPhase1Reconstructor failed to get HcalFrontEndMap!" << std::endl;
   }
 
   reco_->beginRun(r, es);
 }

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

overrideprivate

Definition at line 690 of file HBHEPhase1Reconstructor.cc.

References reco_.

690 { reco_->endRun(); }

HBHEPhase1Reconstructor::reco_

std::unique_ptr< AbsHBHEPhase1Algo > reco_

Definition: HBHEPhase1Reconstructor.cc:288

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

static

Definition at line 698 of file HBHEPhase1Reconstructor.cc.

References edm::ParameterSetDescription::add(), add_param_set, edm::ConfigurationDescriptions::addDefault(), DEFINE_FWK_MODULE, fillDescriptionForParseHBHEPhase1Algo(), HLT_2018_cff::flagParametersQIE11, HLT_2018_cff::flagParametersQIE8, HLT_2018_cff::pulseShapeParametersQIE11, HLT_2018_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);
 }

template<class DFrame , class Collection >

void HBHEPhase1Reconstructor::processData	(	const Collection &	coll,
		const HcalDbService &	cond,
		const HcalChannelQuality &	qual,
		const HcalSeverityLevelComputer &	severity,
		const bool	isRealData,
		HBHEChannelInfo *	info,
		HBHEChannelInfoCollection *	infoColl,
		HBHERecHitCollection *	rechits,
		const bool	use8ts
	)

private

Definition at line 397 of file HBHEPhase1Reconstructor.cc.

References QIE11DataFrame::Sample::adc(), HcalCoderDb::adc2fC(), QIE11DataFrame::Sample::capid(), fwrapper::cs, HcalSeverityLevelComputer::dropChannel(), dropZSmarkedPassed_, HcalCalibrationWidths::effpedestal(), HcalCalibrations::effpedestal(), HcalRecoParam::firstSample(), amptDefault_cfi::frame, HcalCalibrationWidths::gain(), PedestalClient_cfi::gain, HcalSiPMCharacteristics::getCrossTalk(), HcalSiPMParameter::getFCByPE(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalCalibrationWidths(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HcalDbService::getHcalSiPMCharacteristics(), HcalDbService::getHcalSiPMParameter(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), HBHEChannelInfo::hasEffectivePedestals(), HBHEChannelInfo::hasTimeInfo(), HcalBarrel, HcalEndcap, HBHERecHit::id(), HBHEChannelInfo::isDropped(), HBHEChannelInfo::MAXSAMPLES, min(), paramTS_, HcalCalibrationWidths::pedestal(), HcalCalibrations::pedestal(), HcalRecoParam::pulseShapeID(), edm::SortedCollection< T, SORT >::push_back(), DetId::rawId(), reco_, recoParamsFromDB_, HcalCalibrations::respcorrgain(), alignCSCRings::s, saveDroppedInfos_, saveInfos_, setAsicSpecificBits(), HBHEChannelInfo::setChannelInfo(), setCommonStatusBits(), HBHEChannelInfo::setSample(), sipmQNTStoSum_, sipmQTSShift_, CaloSamples::size(), HcalDetId::subdet(), OrderedSet::t, and tsFromDB_.

                                                               {
   // 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;
 
     // Check if the database tells us to drop this channel
     const HcalChannelStatus* mydigistatus = qual.getValues(cell.rawId());
     const bool taggedBadByDb = severity.dropChannel(mydigistatus->getValue());
     if (taggedBadByDb && skipDroppedChannels)
       continue;
 
     // Check if the channel is zero suppressed
     bool dropByZS = false;
     if (dropZSmarkedPassed_)
       if (frame.zsMarkAndPass())
         dropByZS = true;
     if (dropByZS && skipDroppedChannels)
       continue;
 
     // Basic ADC decoding tools
     const HcalRecoParam* param_ts = paramTS_->getValues(cell.rawId());
     const HcalCalibrations& calib = cond.getHcalCalibrations(cell);
     const HcalCalibrationWidths& calibWidth = cond.getHcalCalibrationWidths(cell);
     const HcalQIECoder* channelCoder = cond.getHcalCoder(cell);
     const HcalQIEShape* shape = cond.getHcalShape(channelCoder);
     const HcalCoderDb coder(*channelCoder, *shape);
 
     const bool saveEffectivePeds = channelInfo->hasEffectivePedestals();
     const HcalSiPMParameter& siPMParameter(*cond.getHcalSiPMParameter(cell));
     const double fcByPE = siPMParameter.getFCByPE();
     double darkCurrent = 0.;
     double lambda = 0.;
     if (!saveEffectivePeds || saveInfos_) {
       // needed for the dark current in the M2 in alternative of the effectivePed
       darkCurrent = siPMParameter.getDarkCurrent();
       lambda = cond.getHcalSiPMCharacteristics()->getCrossTalk(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_ ? param_ts->firstSample() : frame.presamples();
     const RawChargeFromSample<DFrame> rcfs(sipmQTSShift_, sipmQNTStoSum_, cond, cell, cs, soi, frame, maxTS);
     int soiCapid = 4;
 
     // Use only 8 TSs when there are 10 TSs
     const int shiftOneTS = use8ts_ && maxTS == static_cast<int>(HBHEChannelInfo::MAXSAMPLES) ? 1 : 0;
     const int nCycles = maxTS - shiftOneTS;
 
     // Go over time slices and fill the samples
     for (int inputTS = shiftOneTS; inputTS < nCycles; ++inputTS) {
       auto s(frame[inputTS]);
       const uint8_t adc = s.adc();
       const int capid = s.capid();
       //optionally store "effective" pedestal (measured with bias voltage on)
       // = QIE contribution + SiPM contribution (from dark current + crosstalk)
       const double pedestal = saveEffectivePeds ? calib.effpedestal(capid) : calib.pedestal(capid);
       const double pedestalWidth = saveEffectivePeds ? calibWidth.effpedestal(capid) : calibWidth.pedestal(capid);
       const double gain = calib.respcorrgain(capid);
       const double gainWidth = calibWidth.gain(capid);
       //always use QIE-only pedestal for this computation
       const double rawCharge = rcfs.getRawCharge(cs[inputTS], calib.pedestal(capid));
       const float t = getTDCTimeFromSample(s);
       const float dfc = getDifferentialChargeGain(*channelCoder, *shape, adc, capid, channelInfo->hasTimeInfo());
       const int fitTS = inputTS - shiftOneTS;
       channelInfo->setSample(fitTS, adc, dfc, rawCharge, pedestal, pedestalWidth, gain, gainWidth, t);
       if (inputTS == soi)
         soiCapid = capid;
     }
 
     // Fill the overall channel info items
     const int maxFitTS = maxTS - 2 * shiftOneTS;
     const int fitSoi = soi - shiftOneTS;
     const int pulseShapeID = param_ts->pulseShapeID();
     const std::pair<bool, bool> hwerr = findHWErrors(frame, maxTS);
     channelInfo->setChannelInfo(cell,
                                 pulseShapeID,
                                 maxFitTS,
                                 fitSoi,
                                 soiCapid,
                                 darkCurrent,
                                 fcByPE,
                                 lambda,
                                 hwerr.first,
                                 hwerr.second,
                                 taggedBadByDb || dropByZS);
 
     // 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 = param_ts;
       HBHERecHit rh = reco_->reconstruct(*channelInfo, pptr, calib, isRealData);
       if (rh.id().rawId()) {
         setAsicSpecificBits(frame, coder, *channelInfo, calib, &rh);
         setCommonStatusBits(*channelInfo, calib, &rh);
         rechits->push_back(rh);
       }
     }
   }
 }

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

overrideprivate

Definition at line 575 of file HBHEPhase1Reconstructor.cc.

References edm::EventSetup::get(), edm::Event::getByToken(), hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, MessageLogger_cfi::infos, HLTBitAnalyser_cfi::isData, edm::EventBase::isRealData(), makeRecHits_, eostools::move(), negEFilter_, MillePedeFileConverter_cfg::out, AlCaHLTBitMon_ParallelJobs::p, paramTS_, processQIE11_, processQIE8_, edm::ESHandle< T >::product(), edm::Event::put(), saveEffectivePedestal_, saveInfos_, setNegativeFlagsQIE11_, setNegativeFlagsQIE8_, setNoiseFlagsQIE11_, setNoiseFlagsQIE8_, edm::SortedCollection< T, SORT >::size(), edm::DataFrameContainer::size(), tok_qie11_, tok_qie8_, and use8ts_.

                                                                                   {
   using namespace edm;
 
   // Get the Hcal topology
   ESHandle<HcalTopology> htopo;
   eventSetup.get<HcalRecNumberingRecord>().get(htopo);
   paramTS_->setTopo(htopo.product());
 
   // Fetch the calibrations
   ESHandle<HcalDbService> conditions;
   eventSetup.get<HcalDbRecord>().get(conditions);
 
   ESHandle<HcalChannelQuality> p;
   eventSetup.get<HcalChannelQualityRcd>().get("withTopo", p);
 
   ESHandle<HcalSeverityLevelComputer> mycomputer;
   eventSetup.get<HcalSeverityLevelComputerRcd>().get(mycomputer);
 
   // Configure the negative energy filter
   ESHandle<HBHENegativeEFilter> negEHandle;
   if (setNegativeFlagsQIE8_ || setNegativeFlagsQIE11_) {
     eventSetup.get<HBHENegativeEFilterRcd>().get(negEHandle);
     negEFilter_ = negEHandle.product();
   }
 
   // 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, *conditions, *p, *mycomputer, isData, &channelInfo, infos.get(), out.get(), use8ts_);
     if (setNoiseFlagsQIE8_)
       hbheFlagSetterQIE8_->SetFlagsFromRecHits(*out);
   }
 
   if (processQIE11_) {
     if (setNoiseFlagsQIE11_)
       hbheFlagSetterQIE11_->Clear();
 
     HBHEChannelInfo channelInfo(true, saveEffectivePedestal_);
     processData<QIE11DataFrame>(
         *heDigis, *conditions, *p, *mycomputer, isData, &channelInfo, infos.get(), out.get(), use8ts_);
     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));
 }

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

private

Definition at line 564 of file HBHEPhase1Reconstructor.cc.

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

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);
 }

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

private

Definition at line 534 of file HBHEPhase1Reconstructor.cc.

References hbheFlagSetterQIE8_, hbhePulseShapeFlagSetterQIE8_, runHBHENegativeEFilter(), setNegativeFlagsQIE8_, setNoiseFlagsQIE8_, and setPulseShapeFlagsQIE8_.

Referenced by processData().

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

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

private

Definition at line 549 of file HBHEPhase1Reconstructor.cc.

References hbheFlagSetterQIE11_, hbhePulseShapeFlagSetterQIE11_, runHBHENegativeEFilter(), setNegativeFlagsQIE11_, setNoiseFlagsQIE11_, and setPulseShapeFlagsQIE11_.

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