#include <HcalTrigPrimDigiProducer.h>

Inheritance diagram for HcalTrigPrimDigiProducer:

Public Member Functions
	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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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	runFrontEndFormatError_

bool	runZS_

HcalTriggerPrimitiveAlgo	theAlgo_

edm::EDGetTokenT< HBHEDigiCollection >	tok_hbhe_

edm::EDGetTokenT< QIE11DigiCollection >	tok_hbhe_up_

edm::EDGetTokenT< HFDigiCollection >	tok_hf_

edm::EDGetTokenT< QIE10DigiCollection >	tok_hf_up_

edm::EDGetTokenT< FEDRawDataCollection >	tok_raw_

bool	upgrade_

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

Definition at line 12 of file HcalTrigPrimDigiProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 28 of file HcalTrigPrimDigiProducer.cc.

References a, begin, end, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HFEMB_, inputLabel_, inputTagFEDRaw_, inputUpgradeLabel_, legacy_, LongShortCut_, LongShortOffset_, LongShortSlope_, MinLongEnergy_, MinShortEnergy_, HcalTriggerPrimitiveAlgo::overrideParameters(), muonDTDigis_cfi::pset, runFrontEndFormatError_, HcalTriggerPrimitiveAlgo::setNCTScaleShift(), HcalTriggerPrimitiveAlgo::setPeakFinderAlgorithm(), HcalTriggerPrimitiveAlgo::setRCTScaleShift(), HcalTriggerPrimitiveAlgo::setUpgradeFlags(), theAlgo_, tok_hbhe_, tok_hbhe_up_, tok_hf_, tok_hf_up_, tok_raw_, 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>("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; });
 
    if (ps.exists("parameters")) {
       auto pset = ps.getUntrackedParameter<edm::ParameterSet>("parameters");
       theAlgo_.overrideParameters(pset);
    }
    theAlgo_.setUpgradeFlags(upgrades[0], upgrades[1], upgrades[2]);
 
     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
     }
   // 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]);
   }
 
    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 ( )

inlineoverride

Definition at line 17 of file HcalTrigPrimDigiProducer.h.

References EnergyCorrector::c, MillePedeFileConverter_cfg::e, and produce().

17 {}

Member Function Documentation

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

override

Produces the EDM products,

Definition at line 95 of file HcalTrigPrimDigiProducer.cc.

References edm::EventSetup::get(), edm::Event::getByToken(), CaloTPGTranscoder::getHcalCompressor(), HcalDbService::getHcalMapping(), HcalLutMetadata::getRctLsb(), hcaltpdigi_cfi::HcalFeatureHFEMBit, HFEMB_, inputLabel_, inputTagFEDRaw_, inputUpgradeLabel_, edm::HandleBase::isValid(), legacy_, LongShortOffset_, LongShortSlope_, MinLongEnergy_, MinShortEnergy_, eostools::move(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::Event::put(), mps_fire::result, HcalTriggerPrimitiveAlgo::run(), HcalTriggerPrimitiveAlgo::runFEFormatError(), runFrontEndFormatError_, HcalTriggerPrimitiveAlgo::runZS(), runZS_, theAlgo_, tok_hbhe_, tok_hbhe_up_, tok_hf_, tok_hf_up_, tok_raw_, and upgrade_.

Referenced by ~HcalTrigPrimDigiProducer().

                                                                                         {
 
   // Step A: get the conditions, for the decoding
   edm::ESHandle<HcalTPGCoder> inputCoder;
   eventSetup.get<HcalTPGRecord>().get(inputCoder);
 
   edm::ESHandle<CaloTPGTranscoder> outTranscoder;
   eventSetup.get<CaloTPGRecord>().get(outTranscoder);
 
   edm::ESHandle<HcalLutMetadata> lutMetadata;
   eventSetup.get<HcalLutMetadataRcd>().get(lutMetadata);
   float rctlsb = lutMetadata->getRctLsb();
 
   edm::ESHandle<HcalTrigTowerGeometry> pG;
   eventSetup.get<CaloGeometryRecord>().get(pG);
   
   // 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.get<HcalDbRecord> ().get(pSetup);
 
     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));
 }