Inheritance diagram for HcalTrigPrimDigiProducer:

Public Member Functions
void	beginRun (const edm::Run &r, const edm::EventSetup &c) override

	HcalTrigPrimDigiProducer (const edm::ParameterSet &ps)

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

	~HcalTrigPrimDigiProducer () 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 Attributes
bool	HFEMB_

std::vector< edm::InputTag >	inputLabel_
	input tags for HCAL digis More...

edm::InputTag	inputTagFEDRaw_
	input tag for FEDRawDataCollection More...

std::vector< edm::InputTag >	inputUpgradeLabel_

bool	legacy_

edm::ParameterSet	LongShortCut_

double	LongShortOffset_

double	LongShortSlope_

double	MinLongEnergy_

double	MinShortEnergy_

bool	overrideDBweightsAndFilterHB_

bool	overrideDBweightsAndFilterHE_

bool	runFrontEndFormatError_

bool	runZS_

HcalTriggerPrimitiveAlgo	theAlgo_

edm::ESGetToken< HcalDbService, HcalDbRecord >	tok_dbService_

edm::ESGetToken< HcalDbService, HcalDbRecord >	tok_dbService_beginRun_

edm::EDGetTokenT< HBHEDigiCollection >	tok_hbhe_

edm::EDGetTokenT< QIE11DigiCollection >	tok_hbhe_up_

edm::ESGetToken< HcalTopology, HcalRecNumberingRecord >	tok_hcalTopo_

edm::EDGetTokenT< HFDigiCollection >	tok_hf_

edm::EDGetTokenT< QIE10DigiCollection >	tok_hf_up_

edm::ESGetToken< HcalLutMetadata, HcalLutMetadataRcd >	tok_lutMetadata_

edm::EDGetTokenT< FEDRawDataCollection >	tok_raw_

edm::ESGetToken< HcalTPGCoder, HcalTPGRecord >	tok_tpgCoder_

edm::ESGetToken< CaloTPGTranscoder, CaloTPGRecord >	tok_tpgTranscoder_

edm::ESGetToken< HcalTrigTowerGeometry, CaloGeometryRecord >	tok_trigTowerGeom_

bool	upgrade_

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

Definition at line 33 of file HcalTrigPrimDigiProducer.cc.

Constructor & Destructor Documentation

◆ HcalTrigPrimDigiProducer()

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

explicit

Definition at line 81 of file HcalTrigPrimDigiProducer.cc.

References a, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HFEMB_, inputLabel_, inputTagFEDRaw_, inputUpgradeLabel_, legacy_, LongShortCut_, LongShortOffset_, LongShortSlope_, MinLongEnergy_, MinShortEnergy_, overrideDBweightsAndFilterHB_, overrideDBweightsAndFilterHE_, HcalTriggerPrimitiveAlgo::overrideParameters(), muonDTDigis_cfi::pset, runFrontEndFormatError_, HcalTriggerPrimitiveAlgo::setFixSaturationFlag(), HcalTriggerPrimitiveAlgo::setNCTScaleShift(), HcalTriggerPrimitiveAlgo::setPeakFinderAlgorithm(), HcalTriggerPrimitiveAlgo::setRCTScaleShift(), HcalTriggerPrimitiveAlgo::setUpgradeFlags(), HcalTriggerPrimitiveAlgo::setWeightsQIE11(), theAlgo_, tok_dbService_, tok_dbService_beginRun_, tok_hbhe_, tok_hbhe_up_, tok_hcalTopo_, tok_hf_, tok_hf_up_, tok_lutMetadata_, tok_raw_, tok_tpgCoder_, tok_tpgTranscoder_, tok_trigTowerGeom_, and upgrade_.

     : theAlgo_(ps.getParameter<bool>("peakFilter"),
                ps.getParameter<std::vector<double> >("weights"),
                ps.getParameter<int>("latency"),
                ps.getParameter<uint32_t>("FG_threshold"),
                ps.getParameter<std::vector<uint32_t> >("FG_HF_thresholds"),
                ps.getParameter<uint32_t>("ZS_threshold"),
                ps.getParameter<int>("numberOfSamples"),
                ps.getParameter<int>("numberOfPresamples"),
                ps.getParameter<int>("numberOfFilterPresamplesHBQIE11"),
                ps.getParameter<int>("numberOfFilterPresamplesHEQIE11"),
                ps.getParameter<int>("numberOfSamplesHF"),
                ps.getParameter<int>("numberOfPresamplesHF"),
                ps.getParameter<bool>("useTDCInMinBiasBits"),
                ps.getParameter<uint32_t>("MinSignalThreshold"),
                ps.getParameter<uint32_t>("PMTNoiseThreshold")),
       inputLabel_(ps.getParameter<std::vector<edm::InputTag> >("inputLabel")),
       inputUpgradeLabel_(ps.getParameter<std::vector<edm::InputTag> >("inputUpgradeLabel")),
       inputTagFEDRaw_(ps.getParameter<edm::InputTag>("InputTagFEDRaw")),
       runZS_(ps.getParameter<bool>("RunZS")),
       runFrontEndFormatError_(ps.getParameter<bool>("FrontEndFormatError")) {
   std::vector<bool> upgrades = {
       ps.getParameter<bool>("upgradeHB"), ps.getParameter<bool>("upgradeHE"), ps.getParameter<bool>("upgradeHF")};
   upgrade_ = std::any_of(std::begin(upgrades), std::end(upgrades), [](bool a) { return a; });
   legacy_ = std::any_of(std::begin(upgrades), std::end(upgrades), [](bool a) { return !a; });
 
   overrideDBweightsAndFilterHE_ = ps.getParameter<bool>("overrideDBweightsAndFilterHE");
   overrideDBweightsAndFilterHB_ = ps.getParameter<bool>("overrideDBweightsAndFilterHB");
 
   theAlgo_.setWeightsQIE11(ps.getParameter<edm::ParameterSet>("weightsQIE11"));
 
   if (ps.exists("parameters")) {
     auto pset = ps.getUntrackedParameter<edm::ParameterSet>("parameters");
     theAlgo_.overrideParameters(pset);
   }
   theAlgo_.setUpgradeFlags(upgrades[0], upgrades[1], upgrades[2]);
   theAlgo_.setFixSaturationFlag(ps.getParameter<bool>("applySaturationFix"));
 
   HFEMB_ = false;
   if (ps.exists("LSConfig")) {
     LongShortCut_ = ps.getUntrackedParameter<edm::ParameterSet>("LSConfig");
     HFEMB_ = LongShortCut_.getParameter<bool>("HcalFeatureHFEMBit");
     MinLongEnergy_ = LongShortCut_.getParameter<double>("Min_Long_Energy");    //minimum long energy
     MinShortEnergy_ = LongShortCut_.getParameter<double>("Min_Short_Energy");  //minimum short energy
     LongShortSlope_ =
         LongShortCut_.getParameter<double>("Long_vrs_Short_Slope");  //slope of the line that cuts are based on
     LongShortOffset_ = LongShortCut_.getParameter<double>("Long_Short_Offset");  //offset of line
   }
   tok_tpgCoder_ = esConsumes<HcalTPGCoder, HcalTPGRecord>();
   tok_tpgTranscoder_ = esConsumes<CaloTPGTranscoder, CaloTPGRecord>();
   tok_lutMetadata_ = esConsumes<HcalLutMetadata, HcalLutMetadataRcd>();
   tok_trigTowerGeom_ = esConsumes<HcalTrigTowerGeometry, CaloGeometryRecord>();
   tok_hcalTopo_ = esConsumes<HcalTopology, HcalRecNumberingRecord, edm::Transition::BeginRun>();
 
   // register for data access
   if (runFrontEndFormatError_) {
     tok_raw_ = consumes<FEDRawDataCollection>(inputTagFEDRaw_);
   }
 
   if (legacy_) {
     tok_hbhe_ = consumes<HBHEDigiCollection>(inputLabel_[0]);
     tok_hf_ = consumes<HFDigiCollection>(inputLabel_[1]);
   }
 
   if (upgrade_) {
     tok_hbhe_up_ = consumes<QIE11DigiCollection>(inputUpgradeLabel_[0]);
     tok_hf_up_ = consumes<QIE10DigiCollection>(inputUpgradeLabel_[1]);
   }
   tok_dbService_ = esConsumes<HcalDbService, HcalDbRecord>();
   tok_dbService_beginRun_ = esConsumes<HcalDbService, HcalDbRecord, edm::Transition::BeginRun>();
   produces<HcalTrigPrimDigiCollection>();
   theAlgo_.setPeakFinderAlgorithm(ps.getParameter<int>("PeakFinderAlgorithm"));
 
   edm::ParameterSet hfSS = ps.getParameter<edm::ParameterSet>("tpScales").getParameter<edm::ParameterSet>("HF");
 
   theAlgo_.setNCTScaleShift(hfSS.getParameter<int>("NCTShift"));
   theAlgo_.setRCTScaleShift(hfSS.getParameter<int>("RCTShift"));
 }

◆ ~HcalTrigPrimDigiProducer()

HcalTrigPrimDigiProducer::~HcalTrigPrimDigiProducer ( )

inlineoverride

Definition at line 36 of file HcalTrigPrimDigiProducer.cc.

36 {}

Member Function Documentation

◆ beginRun()

void HcalTrigPrimDigiProducer::beginRun	(	const edm::Run &	r,
		const edm::EventSetup &	c
	)

override

Produces the EDM products,

Definition at line 160 of file HcalTrigPrimDigiProducer.cc.

References funct::abs(), HcalElectronicsMap::allElectronicsIdTrigger(), dqmiodatasetharvest::db, options_cfi::eventSetup, HcalTopology::lastHBRing(), HcalTopology::lastHERing(), HcalElectronicsMap::lookupTrigger(), overrideDBweightsAndFilterHB_, overrideDBweightsAndFilterHE_, HcalTriggerPrimitiveAlgo::setNumFilterPresamplesHBQIE11(), HcalTriggerPrimitiveAlgo::setNumFilterPresamplesHEQIE11(), HcalTriggerPrimitiveAlgo::setWeightQIE11(), theAlgo_, tok_dbService_beginRun_, and tok_hcalTopo_.

                                                                                           {
   edm::ESHandle<HcalDbService> db = eventSetup.getHandle(tok_dbService_beginRun_);
   const HcalTopology* topo = &eventSetup.getData(tok_hcalTopo_);
 
   const HcalElectronicsMap* emap = db->getHcalMapping();
 
   int lastHERing = topo->lastHERing();
   int lastHBRing = topo->lastHBRing();
 
   std::vector<HcalElectronicsId> vIds = emap->allElectronicsIdTrigger();
   for (std::vector<HcalElectronicsId>::const_iterator eId = vIds.begin(); eId != vIds.end(); eId++) {
     HcalTrigTowerDetId hcalTTDetId(emap->lookupTrigger(*eId));
     if (hcalTTDetId.null())
       continue;
 
     int aieta = abs(hcalTTDetId.ieta());
 
     // Filter weight represented in fixed point 8 bit
     int fixedPointWeight = -1;
 
     // The absence of TT channels in the HcalTPChannelParameters
     // is intepreted as to not use the new filter
     auto tpParam = db->getHcalTPChannelParameter(hcalTTDetId, false);
     if (tpParam)
       fixedPointWeight = tpParam->getauxi1();
 
     // Do not let ieta 29 in the map
     // If the aieta already has a weight in the map, then move on
     if (aieta <= lastHBRing) {
       // Fix number of filter presamples to one if we are using DB weights
       // Size of filter is already known when using DB weights
       // Weight from DB represented as 8-bit integer
       if (!overrideDBweightsAndFilterHB_) {
         if (fixedPointWeight != -1) {
           theAlgo_.setNumFilterPresamplesHBQIE11(1);
           theAlgo_.setWeightQIE11(aieta, fixedPointWeight);
         } else {
           theAlgo_.setNumFilterPresamplesHBQIE11(0);
           theAlgo_.setWeightQIE11(aieta, 255);
         }
       }
     } else if (aieta < lastHERing) {
       if (!overrideDBweightsAndFilterHE_) {
         if (fixedPointWeight != -1) {
           theAlgo_.setNumFilterPresamplesHEQIE11(1);
           theAlgo_.setWeightQIE11(aieta, fixedPointWeight);
         } else {
           theAlgo_.setNumFilterPresamplesHEQIE11(0);
           theAlgo_.setWeightQIE11(aieta, 255);
         }
       }
     }
   }
 }

◆ produce()

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

override

Definition at line 215 of file HcalTrigPrimDigiProducer.cc.

References options_cfi::eventSetup, CaloTPGTranscoder::getHcalCompressor(), HcalDbService::getHcalMapping(), HcalLutMetadata::getRctLsb(), hcaltpdigi_cfi::HcalFeatureHFEMBit, HFEMB_, iEvent, inputLabel_, inputTagFEDRaw_, inputUpgradeLabel_, edm::HandleBase::isValid(), legacy_, LongShortOffset_, LongShortSlope_, MinLongEnergy_, MinShortEnergy_, eostools::move(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), mps_fire::result, HcalTriggerPrimitiveAlgo::run(), HcalTriggerPrimitiveAlgo::runFEFormatError(), runFrontEndFormatError_, HcalTriggerPrimitiveAlgo::runZS(), runZS_, theAlgo_, tok_dbService_, tok_hbhe_, tok_hbhe_up_, tok_hf_, tok_hf_up_, tok_lutMetadata_, tok_raw_, tok_tpgCoder_, tok_tpgTranscoder_, tok_trigTowerGeom_, and upgrade_.

                                                                                         {
   // Step A: get the conditions, for the decoding
   edm::ESHandle<HcalTPGCoder> inputCoder = eventSetup.getHandle(tok_tpgCoder_);
 
   edm::ESHandle<CaloTPGTranscoder> outTranscoder = eventSetup.getHandle(tok_tpgTranscoder_);
 
   edm::ESHandle<HcalLutMetadata> lutMetadata = eventSetup.getHandle(tok_lutMetadata_);
   float rctlsb = lutMetadata->getRctLsb();
 
   edm::ESHandle<HcalTrigTowerGeometry> pG = eventSetup.getHandle(tok_trigTowerGeom_);
 
   // Step B: Create empty output
   std::unique_ptr<HcalTrigPrimDigiCollection> result(new HcalTrigPrimDigiCollection());
 
   edm::Handle<HBHEDigiCollection> hbheDigis;
   edm::Handle<HFDigiCollection> hfDigis;
 
   edm::Handle<QIE11DigiCollection> hbheUpDigis;
   edm::Handle<QIE10DigiCollection> hfUpDigis;
 
   if (legacy_) {
     iEvent.getByToken(tok_hbhe_, hbheDigis);
     iEvent.getByToken(tok_hf_, hfDigis);
 
     // protect here against missing input collections
     // there is no protection in HcalTriggerPrimitiveAlgo
 
     if (!hbheDigis.isValid() and legacy_) {
       edm::LogInfo("HcalTrigPrimDigiProducer") << "\nWarning: HBHEDigiCollection with input tag " << inputLabel_[0]
                                                << "\nrequested in configuration, but not found in the event."
                                                << "\nQuit returning empty product." << std::endl;
 
       // put empty HcalTrigPrimDigiCollection in the event
       iEvent.put(std::move(result));
 
       return;
     }
 
     if (!hfDigis.isValid() and legacy_) {
       edm::LogInfo("HcalTrigPrimDigiProducer") << "\nWarning: HFDigiCollection with input tag " << inputLabel_[1]
                                                << "\nrequested in configuration, but not found in the event."
                                                << "\nQuit returning empty product." << std::endl;
 
       // put empty HcalTrigPrimDigiCollection in the event
       iEvent.put(std::move(result));
 
       return;
     }
   }
 
   if (upgrade_) {
     iEvent.getByToken(tok_hbhe_up_, hbheUpDigis);
     iEvent.getByToken(tok_hf_up_, hfUpDigis);
 
     if (!hbheUpDigis.isValid() and upgrade_) {
       edm::LogInfo("HcalTrigPrimDigiProducer")
           << "\nWarning: Upgrade HBHEDigiCollection with input tag " << inputUpgradeLabel_[0]
           << "\nrequested in configuration, but not found in the event."
           << "\nQuit returning empty product." << std::endl;
 
       // put empty HcalTrigPrimDigiCollection in the event
       iEvent.put(std::move(result));
 
       return;
     }
 
     if (!hfUpDigis.isValid() and upgrade_) {
       edm::LogInfo("HcalTrigPrimDigiProducer") << "\nWarning: HFDigiCollection with input tag " << inputUpgradeLabel_[1]
                                                << "\nrequested in configuration, but not found in the event."
                                                << "\nQuit returning empty product." << std::endl;
 
       // put empty HcalTrigPrimDigiCollection in the event
       iEvent.put(std::move(result));
 
       return;
     }
   }
 
   edm::ESHandle<HcalDbService> pSetup = eventSetup.getHandle(tok_dbService_);
 
   HcalFeatureBit* hfembit = nullptr;
 
   if (HFEMB_) {
     hfembit = new HcalFeatureHFEMBit(MinShortEnergy_,
                                      MinLongEnergy_,
                                      LongShortSlope_,
                                      LongShortOffset_,
                                      *pSetup);  //inputs values that cut will be based on
   }
 
   // Step C: Invoke the algorithm, passing in inputs and getting back outputs.
   if (legacy_ and not upgrade_) {
     theAlgo_.run(inputCoder.product(),
                  outTranscoder->getHcalCompressor().get(),
                  pSetup.product(),
                  *result,
                  &(*pG),
                  rctlsb,
                  hfembit,
                  *hbheDigis,
                  *hfDigis);
   } else if (legacy_ and upgrade_) {
     theAlgo_.run(inputCoder.product(),
                  outTranscoder->getHcalCompressor().get(),
                  pSetup.product(),
                  *result,
                  &(*pG),
                  rctlsb,
                  hfembit,
                  *hbheDigis,
                  *hfDigis,
                  *hbheUpDigis,
                  *hfUpDigis);
   } else {
     theAlgo_.run(inputCoder.product(),
                  outTranscoder->getHcalCompressor().get(),
                  pSetup.product(),
                  *result,
                  &(*pG),
                  rctlsb,
                  hfembit,
                  *hbheUpDigis,
                  *hfUpDigis);
   }
 
   // Step C.1: Run FE Format Error / ZS for real data.
   if (runFrontEndFormatError_) {
     const HcalElectronicsMap* emap = pSetup->getHcalMapping();
 
     edm::Handle<FEDRawDataCollection> fedHandle;
     iEvent.getByToken(tok_raw_, fedHandle);
 
     if (fedHandle.isValid() && emap != nullptr) {
       theAlgo_.runFEFormatError(fedHandle.product(), emap, *result);
     } else {
       edm::LogInfo("HcalTrigPrimDigiProducer") << "\nWarning: FEDRawDataCollection with input tag " << inputTagFEDRaw_
                                                << "\nrequested in configuration, but not found in the event."
                                                << "\nQuit returning empty product." << std::endl;
 
       // produce empty HcalTrigPrimDigiCollection and put it in the event
       std::unique_ptr<HcalTrigPrimDigiCollection> emptyResult(new HcalTrigPrimDigiCollection());
 
       iEvent.put(std::move(emptyResult));
 
       return;
     }
   }
 
   if (runZS_)
     theAlgo_.runZS(*result);
 
   //  edm::LogInfo("HcalTrigPrimDigiProducer") << "HcalTrigPrims: " << result->size();
 
   // Step D: Put outputs into event
   iEvent.put(std::move(result));
 }