#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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)

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_

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 280 of file HBHEPhase1Reconstructor.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 357 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")),
       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 421 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 700 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 739 of file HBHEPhase1Reconstructor.cc.

References reco_.

 {
     reco_->endRun();
 }

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

static

Definition at line 751 of file HBHEPhase1Reconstructor.cc.

References edm::ParameterSetDescription::add(), add_param_set, edm::ConfigurationDescriptions::addDefault(), electronCleaner_cfi::algorithm, DEFINE_FWK_MODULE, HBHEPhase1Reconstructor_cfi::flagParametersQIE11, HBHEPhase1Reconstructor_cfi::flagParametersQIE8, HBHEPhase1Reconstructor_cfi::pulseShapeParametersQIE11, hcalLocalReco_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<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");
 
     add_param_set(algorithm);
     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
	)

private

Definition at line 432 of file HBHEPhase1Reconstructor.cc.

References QIE11DataFrame::Sample::adc(), HcalCoderDb::adc2fC(), QIE11DataFrame::Sample::capid(), fwrapper::cs, HcalSeverityLevelComputer::dropChannel(), dropZSmarkedPassed_, HcalCalibrationWidths::effpedestal(), HcalCalibrations::effpedestal(), HcalRecoParam::firstSample(), HcalCalibrationWidths::gain(), muonCSCDigis_cfi::gain, HcalSiPMCharacteristics::getCrossTalk(), HcalSiPMParameter::getDarkCurrent(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalCalibrationWidths(), HcalDbService::getHcalCoder(), HcalDbService::getHcalShape(), HcalDbService::getHcalSiPMCharacteristics(), HcalDbService::getHcalSiPMParameter(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), HBHEChannelInfo::hasTimeInfo(), HcalBarrel, HcalEndcap, HcalOuter, HBHERecHit::id(), HBHEChannelInfo::isDropped(), HBHEChannelInfo::MAXSAMPLES, hcaldqm::utilities::maxTS(), min(), paramTS_, HcalCalibrationWidths::pedestal(), HcalCalibrations::pedestal(), HcalRecoParam::pulseShapeID(), edm::SortedCollection< T, SORT >::push_back(), DetId::rawId(), reco_, recoParamsFromDB_, HcalCalibrations::respcorrgain(), alignCSCRings::s, saveDroppedInfos_, saveEffectivePedestal_, setAsicSpecificBits(), HBHEChannelInfo::setChannelInfo(), setCommonStatusBits(), HBHEChannelInfo::setSample(), sipmQNTStoSum_, sipmQTSShift_, CaloSamples::size(), HcalDetId::subdet(), lumiQTWidget::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 ||
               subdet == HcalSubdetector::HcalOuter))
             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);
 
         // needed for the dark current in the M2
         const HcalSiPMParameter& siPMParameter(*cond.getHcalSiPMParameter(cell));
         const double darkCurrent = siPMParameter.getDarkCurrent();
         const double fcByPE = siPMParameter.getFCByPE();
         const double 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;
 
         // Go over time slices and fill the samples
         for (int ts = 0; ts < maxTS; ++ts)
         {
             auto s(frame[ts]);
             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 = saveEffectivePedestal_ ? calib.effpedestal(capid) : calib.pedestal(capid);
             const double pedestalWidth = saveEffectivePedestal_ ? 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[ts], calib.pedestal(capid));
             const float t = getTDCTimeFromSample(s);
             const float dfc = getDifferentialChargeGain(*channelCoder, *shape, adc,
                                                         capid, channelInfo->hasTimeInfo());
             channelInfo->setSample(ts, adc, dfc, rawCharge,
                                    pedestal, pedestalWidth,
                                    gain, gainWidth, t);
             if (ts == soi)
                 soiCapid = capid;
         }
 
         // Fill the overall channel info items
         const int pulseShapeID = param_ts->pulseShapeID();
         const std::pair<bool,bool> hwerr = findHWErrors(frame, maxTS);
         channelInfo->setChannelInfo(cell, pulseShapeID, maxTS, soi, 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 607 of file HBHEPhase1Reconstructor.cc.

References edm::EventSetup::get(), edm::Event::getByToken(), hbheFlagSetterQIE11_, hbheFlagSetterQIE8_, benchmark_cfg::infos, 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_, and tok_qie8_.

 {
     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());
         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());
         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 593 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 563 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 578 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);
 }