diff --git a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureBit.h b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureBit.h index b26d8dca217b5..0066b27f3cef8 100644 --- a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureBit.h +++ b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureBit.h @@ -2,14 +2,28 @@ #define SimCalorimetry_HcalTPGAlgos_interface_HcalFeatureBit_h_included 1 #include "DataFormats/HcalDetId/interface/HcalDetId.h" +#include "DataFormats/HcalDigi/interface/HFDataFrame.h" +#include "DataFormats/HcalDigi/interface/QIE10DataFrame.h" class HcalFeatureBit { public: HcalFeatureBit(){} virtual ~HcalFeatureBit(){} //the virutal function is responcible for applying a cut based on a linear relationship of the energy //deposited in the short vers long fibers. - virtual bool fineGrainbit(int ADCShort, HcalDetId Sid, int CapIdS, int ADCLong, HcalDetId Lid, int CapIdL) const {return false;} - + virtual bool fineGrainbit( + const QIE10DataFrame& short1, + const QIE10DataFrame& short2, + const QIE10DataFrame& long1, + const QIE10DataFrame& long2, + bool validShort1, + bool validShort2, + bool validLong1, + bool validLong2, + int idx) const = 0; + virtual bool fineGrainbit( + const HFDataFrame& shortDigi, + const HFDataFrame& longDigi, + int idx) const = 0; }; #endif diff --git a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h index 60e0b33ffd0ec..2df3d5db73682 100644 --- a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h +++ b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h @@ -1,18 +1,55 @@ #ifndef SimCalorimetry_HcalTPGAlgos_interface_HcalFeatureHFEMBit_h_included #define SimCalorimetry_HcalTPGAlgos_interface_HcalFeatureHFEMBit_h_included 1 - #include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureBit.h" #include "CalibFormats/HcalObjects/interface/HcalDbService.h" +#include "CalibFormats/HcalObjects/interface/HcalCoderDb.h" class HcalFeatureHFEMBit : public HcalFeatureBit { -public: - HcalFeatureHFEMBit(double ShortMinE, double LongMinE, double ShortLongCutSlope, double ShortLongCutOffset, const HcalDbService& conditions); - ~HcalFeatureHFEMBit(); - virtual bool fineGrainbit(int ADCShort, HcalDetId Sid, int CapIdS, int ADCLong, HcalDetId Lid, int CapIdL) const;//cuts based on energy - //depoisted in the long and short fibers -private: - double ShortMinE_, LongMinE_, ShortLongCutSlope_, ShortLongCutOffset_; - const HcalDbService& conditions_; + public: + HcalFeatureHFEMBit(double ShortMinE, double LongMinE, double ShortLongCutSlope, double ShortLongCutOffset, const HcalDbService& conditions); + ~HcalFeatureHFEMBit(); + + // Provides FG bit based on energy cuts in long & short fibers. + virtual bool fineGrainbit( + const QIE10DataFrame& short1, + const QIE10DataFrame& short2, + const QIE10DataFrame& long1, + const QIE10DataFrame& long2, + bool validShort1, + bool validShort2, + bool validLong1, + bool validLong2, + int idx) const override; + virtual bool fineGrainbit( + const HFDataFrame& shortDigi, + const HFDataFrame& longDigi, + int idx) const override; + private: + template + float getE(const T& f, int idx) const; + + double ShortMinE_, LongMinE_, ShortLongCutSlope_, ShortLongCutOffset_; + const HcalDbService& conditions_; }; + +template +float +HcalFeatureHFEMBit::getE(const T& f, int idx) const +{ + const HcalDetId id(f.id()); + const HcalCalibrations& calibrations = conditions_.getHcalCalibrations(id); + const auto* coder = conditions_.getHcalCoder(id); + const auto* shape = conditions_.getHcalShape(coder); + + HcalCoderDb db(*coder, *shape); + CaloSamples samples; + db.adc2fC(f, samples); + + auto ped = calibrations.pedestal(f[idx].capid()); + auto corr = calibrations.respcorrgain(f[idx].capid()); + + return (samples[idx] - ped) * corr; +} + #endif diff --git a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalTriggerPrimitiveAlgo.h b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalTriggerPrimitiveAlgo.h index 8e313e64f947c..3c83a63db1758 100644 --- a/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalTriggerPrimitiveAlgo.h +++ b/SimCalorimetry/HcalTrigPrimAlgos/interface/HcalTriggerPrimitiveAlgo.h @@ -3,15 +3,17 @@ #include "DataFormats/HcalDetId/interface/HcalTrigTowerDetId.h" #include "DataFormats/HcalDigi/interface/HcalDigiCollections.h" -#include "Geometry/HcalTowerAlgo/interface/HcalTrigTowerGeometry.h" -#include "CalibFormats/CaloObjects/interface/CaloSamples.h" -#include "CalibFormats/CaloObjects/interface/IntegerCaloSamples.h" #include "CalibCalorimetry/HcalTPGAlgos/interface/HcaluLUTTPGCoder.h" #include "CalibFormats/CaloTPG/interface/HcalTPGCompressor.h" +#include "CalibFormats/HcalObjects/interface/HcalDbService.h" #include "CondFormats/HcalObjects/interface/HcalElectronicsMap.h" + #include "DataFormats/FEDRawData/interface/FEDRawDataCollection.h" -#include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h"//cuts based on short and long energy deposited. + +#include "Geometry/HcalTowerAlgo/interface/HcalTrigTowerGeometry.h" + +#include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h" #include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFinegrainBit.h" #include @@ -22,12 +24,6 @@ class IntegerCaloSamples; class HcalTriggerPrimitiveAlgo { public: - struct TPParameters { - uint64_t hf_tdc_mask; - uint32_t hf_adc_threshold; - uint32_t hf_fg_threshold; - }; - HcalTriggerPrimitiveAlgo(bool pf, const std::vector& w, int latency, uint32_t FG_threshold, uint32_t FG_HF_threshold, uint32_t ZS_threshold, int numberOfSamples, int numberOfPresamples, @@ -38,6 +34,7 @@ class HcalTriggerPrimitiveAlgo { template void run(const HcalTPGCoder* incoder, const HcalTPGCompressor* outcoder, + const HcalDbService* conditions, HcalTrigPrimDigiCollection& result, const HcalTrigTowerGeometry* trigTowerGeometry, float rctlsb, const HcalFeatureBit* LongvrsShortCut, @@ -73,9 +70,7 @@ class HcalTriggerPrimitiveAlgo { void setRCTScaleShift(int); void setUpgradeFlags(bool hb, bool he, bool hf); - void overrideParameters(unsigned int hf_tdc_mask, - unsigned int hf_adc_threshold, - unsigned int hf_fg_threshold); + void overrideParameters(const edm::ParameterSet& ps); private: @@ -89,6 +84,7 @@ class HcalTriggerPrimitiveAlgo { void addUpgradeFG(const HcalTrigTowerDetId& id, int depth, const std::vector>& bits); bool validUpgradeFG(const HcalTrigTowerDetId& id, int depth) const; + bool validChannel(const QIE10DataFrame& digi, int ts) const; /// adds the actual RecHits void analyze(IntegerCaloSamples & samples, HcalTriggerPrimitiveDigi & result); @@ -114,6 +110,7 @@ class HcalTriggerPrimitiveAlgo { // Member initialized by constructor const HcaluLUTTPGCoder* incoder_; const HcalTPGCompressor* outcoder_; + const HcalDbService* conditions_; double theThreshold; bool peakfind_; std::vector weights_; @@ -157,6 +154,7 @@ class HcalTriggerPrimitiveAlgo { struct HFUpgradeDetails { IntegerCaloSamples samples; QIE10DataFrame digi; + std::vector validity; }; typedef std::map>> HFUpgradeDetailMap; HFUpgradeDetailMap theHFUpgradeDetailMap; @@ -189,12 +187,21 @@ class HcalTriggerPrimitiveAlgo { bool upgrade_he_ = false; bool upgrade_hf_ = false; - std::unique_ptr override_parameters_; + edm::ParameterSet override_parameters_; + + bool override_adc_hf_ = false; + uint32_t override_adc_hf_value_; + bool override_tdc_hf_ = false; + unsigned long long override_tdc_hf_value_; + // HE constants static const int HBHE_OVERLAP_TOWER = 16; static const int LAST_FINEGRAIN_DEPTH = 6; static const int LAST_FINEGRAIN_TOWER = 28; + // Fine-grain in HF ignores tower 29, and starts with 30 + static const int FIRST_FINEGRAIN_TOWER = 30; + static const int QIE8_LINEARIZATION_ET = HcaluLUTTPGCoder::QIE8_LUT_BITMASK; static const int QIE10_LINEARIZATION_ET = HcaluLUTTPGCoder::QIE10_LUT_BITMASK; static const int QIE11_LINEARIZATION_ET = HcaluLUTTPGCoder::QIE11_LUT_BITMASK; @@ -206,14 +213,16 @@ class HcalTriggerPrimitiveAlgo { template void HcalTriggerPrimitiveAlgo::run(const HcalTPGCoder* incoder, const HcalTPGCompressor* outcoder, + const HcalDbService* conditions, HcalTrigPrimDigiCollection& result, const HcalTrigTowerGeometry* trigTowerGeometry, float rctlsb, const HcalFeatureBit* LongvrsShortCut, const Digis&... digis) { theTrigTowerGeometry = trigTowerGeometry; - - incoder_=dynamic_cast(incoder); - outcoder_=outcoder; + + incoder_ = dynamic_cast(incoder); + outcoder_ = outcoder; + conditions_ = conditions; theSumMap.clear(); theTowerMapFGSum.clear(); @@ -228,6 +237,10 @@ void HcalTriggerPrimitiveAlgo::run(const HcalTPGCoder* incoder, // Prepare the fine-grain calculation algorithm for HB/HE int version = 0; + if (upgrade_he_ or upgrade_hb_) + version = conditions_->getHcalTPParameters()->getFGVersionHBHE(); + if (override_parameters_.exists("FGVersionHBHE")) + version = override_parameters_.getParameter("FGVersionHBHE"); HcalFinegrainBit fg_algo(version); // VME produces additional bits on the front used by lumi but not the diff --git a/SimCalorimetry/HcalTrigPrimAlgos/src/HcalFeatureHFEMBit.cc b/SimCalorimetry/HcalTrigPrimAlgos/src/HcalFeatureHFEMBit.cc index 5418c1b83a036..4e8e9c0ac495b 100644 --- a/SimCalorimetry/HcalTrigPrimAlgos/src/HcalFeatureHFEMBit.cc +++ b/SimCalorimetry/HcalTrigPrimAlgos/src/HcalFeatureHFEMBit.cc @@ -4,7 +4,6 @@ #include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h" #include "CondFormats/HcalObjects/interface/HcalQIECoder.h" -#include "CalibFormats/HcalObjects/interface/HcalCoderDb.h" HcalFeatureHFEMBit::HcalFeatureHFEMBit(double ShortMinE, double LongMinE, @@ -21,48 +20,54 @@ HcalFeatureHFEMBit::HcalFeatureHFEMBit(double ShortMinE, double LongMinE, HcalFeatureHFEMBit::~HcalFeatureHFEMBit() { } -bool HcalFeatureHFEMBit::fineGrainbit(int ADCShort, HcalDetId Sid, int CapIdS, int ADCLong, HcalDetId Lid, int CapIdL) const//pass det id +bool +HcalFeatureHFEMBit::fineGrainbit( + const HFDataFrame& shortDigi, + const HFDataFrame& longDigi, + int idx) const { + float shortE = getE(shortDigi, idx); + float longE = getE(longDigi, idx); - float ShortE = 0; //holds deposited energy - float LongE = 0; + if (shortE < ShortMinE_) + return false; + if (longE < LongMinE_) + return false; - - HcalQIESample sQIESample(ADCShort, CapIdS, 1, 1); - //makes a QIE sample for the short fiber. - HFDataFrame shortf(Sid); - shortf.setSize(1); //not planning on there being anything else here at this point in time so setting the size to 1 shouldn't matter - shortf.setSample(0, sQIESample); //inputs data into digi. - const HcalCalibrations& calibrations = conditions_.getHcalCalibrations(Sid); - const HcalQIECoder* channelCoderS = conditions_.getHcalCoder(Sid); - const HcalQIEShape* shapeS = conditions_.getHcalShape(channelCoderS); - - HcalCoderDb coders(*channelCoderS, *shapeS); - - CaloSamples tools; - coders.adc2fC(shortf, tools); - ShortE = (tools[0] - calibrations.pedestal(CapIdS)) * calibrations.respcorrgain(CapIdS); - - HcalQIESample lQIESample(ADCLong, CapIdL, 1, 1); - HFDataFrame longf(Lid); - longf.setSize(1); - longf.setSample(0, lQIESample); - const HcalCalibrations& calibrationL = conditions_.getHcalCalibrations(Lid); - - CaloSamples tool_l; - - const HcalQIECoder* channelCoderL = conditions_.getHcalCoder(Lid); - const HcalQIEShape* shapeL = conditions_.getHcalShape(channelCoderL); - - HcalCoderDb coderL(*channelCoderL, *shapeL); - - coderL.adc2fC(longf, tool_l); // this fills tool_l[0] with linearized adc - LongE = (tool_l[0] - calibrationL.pedestal(CapIdL)) * calibrationL.respcorrgain(CapIdL); - - - // this actually does the cut - if((ShortE < ((LongE)-(ShortLongCutOffset_)) * ShortLongCutSlope_) && LongE > LongMinE_ && ShortE > ShortMinE_) return true; - else return false; + return (shortE < (longE - ShortLongCutOffset_) * ShortLongCutSlope_); } - +bool HcalFeatureHFEMBit::fineGrainbit( + const QIE10DataFrame& short1, + const QIE10DataFrame& short2, + const QIE10DataFrame& long1, + const QIE10DataFrame& long2, + bool validShort1, + bool validShort2, + bool validLong1, + bool validLong2, + int idx) const +{ + float shortE = 0; + if (validShort1) + shortE += getE(short1, idx); + if (validShort2) + shortE += getE(short2, idx); + if (validShort1 and validShort2) + shortE *= .5; + + float longE = 0; + if (validLong1) + longE += getE(long1, idx); + if (validLong2) + longE += getE(long2, idx); + if (validLong1 and validLong2) + longE *= .5; + + if (shortE < ShortMinE_) + return false; + if (longE < LongMinE_) + return false; + + return (shortE < (longE - ShortLongCutOffset_) * ShortLongCutSlope_); +} diff --git a/SimCalorimetry/HcalTrigPrimAlgos/src/HcalTriggerPrimitiveAlgo.cc b/SimCalorimetry/HcalTrigPrimAlgos/src/HcalTriggerPrimitiveAlgo.cc index 2d9f22ec30363..f1a04c71031b3 100644 --- a/SimCalorimetry/HcalTrigPrimAlgos/src/HcalTriggerPrimitiveAlgo.cc +++ b/SimCalorimetry/HcalTrigPrimAlgos/src/HcalTriggerPrimitiveAlgo.cc @@ -1,16 +1,23 @@ #include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalTriggerPrimitiveAlgo.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "CalibFormats/CaloObjects/interface/IntegerCaloSamples.h" +#include "CondFormats/HcalObjects/interface/HcalTPParameters.h" +#include "CondFormats/HcalObjects/interface/HcalTPChannelParameters.h" #include "DataFormats/HcalDetId/interface/HcalDetId.h" -#include "Geometry/HcalTowerAlgo/interface/HcalTrigTowerGeometry.h" -#include "DataFormats/HcalDetId/interface/HcalTrigTowerDetId.h" #include "DataFormats/FEDRawData/interface/FEDNumbering.h" #include "DataFormats/HcalDetId/interface/HcalElectronicsId.h" + #include "EventFilter/HcalRawToDigi/interface/HcalDCCHeader.h" #include "EventFilter/HcalRawToDigi/interface/HcalHTRData.h" -#include "SimCalorimetry/HcalTrigPrimAlgos/interface/HcalFeatureHFEMBit.h"//cuts based on short and long energy deposited. + +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "Geometry/HcalTowerAlgo/interface/HcalTrigTowerGeometry.h" + #include + using namespace std; HcalTriggerPrimitiveAlgo::HcalTriggerPrimitiveAlgo( bool pf, const std::vector& w, int latency, @@ -29,7 +36,8 @@ HcalTriggerPrimitiveAlgo::HcalTriggerPrimitiveAlgo( bool pf, const std::vectorhf_tdc_mask = hf_tdc_mask; - parameters->hf_adc_threshold = hf_adc_threshold; - parameters->hf_fg_threshold = hf_fg_threshold; + override_parameters_ = ps; - override_parameters_ = std::unique_ptr(parameters); + if (override_parameters_.exists("ADCThresholdHF")) { + override_adc_hf_ = true; + override_adc_hf_value_ = override_parameters_.getParameter("ADCThresholdHF"); + } + if (override_parameters_.exists("TDCMaskHF")) { + override_tdc_hf_ = true; + override_tdc_hf_value_ = override_parameters_.getParameter("TDCMaskHF"); + } } @@ -208,6 +218,9 @@ HcalTriggerPrimitiveAlgo::addSignal(const QIE10DataFrame& frame) auto& details = theHFUpgradeDetailMap[id][fid.maskDepth()]; details[fid.depth() - 1].samples = samples; details[fid.depth() - 1].digi = frame; + details[fid.depth() - 1].validity.resize(frame.samples()); + for (int idx = 0; idx < frame.samples(); ++idx) + details[fid.depth() - 1].validity[idx] = validChannel(frame, idx); } } @@ -486,17 +499,11 @@ void HcalTriggerPrimitiveAlgo::analyzeHF2016( uint32_t ADCLong = details.LongDigi[ibin].adc(); uint32_t ADCShort = details.ShortDigi[ibin].adc(); - if (details.LongDigi.id().ietaAbs() != 29) { + if (details.LongDigi.id().ietaAbs() >= FIRST_FINEGRAIN_TOWER) { finegrain[ibin][1] = (ADCLong > FG_HF_threshold_ || ADCShort > FG_HF_threshold_); - if (HCALFEM != 0) { - finegrain[ibin][0] = HCALFEM->fineGrainbit( - ADCShort, details.ShortDigi.id(), - details.ShortDigi[ibin].capid(), - ADCLong, details.LongDigi.id(), - details.LongDigi[ibin].capid() - ); - } + if (HCALFEM != 0) + finegrain[ibin][0] = HCALFEM->fineGrainbit(details.ShortDigi, details.LongDigi, ibin); } } } @@ -513,9 +520,31 @@ void HcalTriggerPrimitiveAlgo::analyzeHF2016( } +bool +HcalTriggerPrimitiveAlgo::validChannel(const QIE10DataFrame& digi, int ts) const +{ + auto mask = conditions_->getHcalTPChannelParameter(HcalDetId(digi.id()))->getMask(); + if (mask) + return false; + + auto parameters = conditions_->getHcalTPParameters(); + auto adc_threshold = parameters->getADCThresholdHF(); + auto tdc_mask = parameters->getTDCMaskHF(); + + if (override_adc_hf_) + adc_threshold = override_adc_hf_value_; + if (override_tdc_hf_) + tdc_mask = override_tdc_hf_value_; + + if (digi[ts].adc() < adc_threshold) + return true; + + return (1ul << digi[ts].le_tdc()) & tdc_mask; +} + void HcalTriggerPrimitiveAlgo::analyzeHF2017( const IntegerCaloSamples& samples, HcalTriggerPrimitiveDigi& result, - const int hf_lumi_shift, const HcalFeatureBit* hcalfem) + const int hf_lumi_shift, const HcalFeatureBit* embit) { // Align digis and TP const int shift = samples.presamples() - numberOfPresamples_; @@ -530,7 +559,7 @@ void HcalTriggerPrimitiveAlgo::analyzeHF2017( return; } - std::vector finegrain(numberOfSamples_, false); + std::vector> finegrain(numberOfSamples_, false); // Set up out output of IntergerCaloSamples IntegerCaloSamples output(samples.id(), numberOfSamples_); @@ -549,23 +578,17 @@ void HcalTriggerPrimitiveAlgo::analyzeHF2017( bool saturated = false; for (auto i: {0, 2}) { - if (idx < details[i].samples.size()) { - if ((unsigned int) details[i].digi[idx].adc() < override_parameters_->hf_adc_threshold - or (1ul << (details[i].digi[idx].le_tdc() - 1)) & override_parameters_->hf_tdc_mask) { - long_fiber_val += details[i].samples[idx]; - saturated = saturated || (details[i].samples[idx] == QIE10_LINEARIZATION_ET); - ++long_fiber_count; - } + if (idx < details[i].samples.size() and details[i].validity[idx]) { + long_fiber_val += details[i].samples[idx]; + saturated = saturated || (details[i].samples[idx] == QIE10_LINEARIZATION_ET); + ++long_fiber_count; } } for (auto i: {1, 3}) { - if (idx < details[i].samples.size()) { - if ((unsigned int) details[i].digi[idx].adc() < override_parameters_->hf_adc_threshold - or (1ul << (details[i].digi[idx].le_tdc() - 1)) & override_parameters_->hf_tdc_mask) { - short_fiber_val += details[i].samples[idx]; - saturated = saturated || (details[i].samples[idx] == QIE10_LINEARIZATION_ET); - ++short_fiber_count; - } + if (idx < details[i].samples.size() and details[i].validity[idx]) { + short_fiber_val += details[i].samples[idx]; + saturated = saturated || (details[i].samples[idx] == QIE10_LINEARIZATION_ET); + ++short_fiber_count; } } @@ -586,19 +609,31 @@ void HcalTriggerPrimitiveAlgo::analyzeHF2017( output[ibin] += sum; } - // int ADCLong = details.LongDigi[ibin].adc(); - // int ADCShort = details.ShortDigi[ibin].adc(); - // if(hcalfem != 0) - // { - // finegrain[ibin] = (finegrain[ibin] || hcalfem->fineGrainbit(ADCShort, details.ShortDigi.id(), details.ShortDigi[ibin].capid(), ADCLong, details.LongDigi.id(), details.LongDigi[ibin].capid())); - // } + for (const auto& detail: details) { + if (detail.validity[idx] and HcalDetId(detail.digi.id()).ietaAbs() >= FIRST_FINEGRAIN_TOWER) { + finegrain[ibin][1] = finegrain[ibin][1] or (detail.digi[idx].adc() > (int) FG_HF_threshold_); + } + } + + if (embit != 0) { + finegrain[ibin][0] = embit->fineGrainbit( + details[1].digi, details[3].digi, + details[0].digi, details[2].digi, + details[1].validity[idx], details[3].validity[idx], + details[0].validity[idx], details[2].validity[idx], + idx + ); + } } } for (int bin = 0; bin < numberOfSamples_; ++bin) { output[bin] = min({(unsigned int) QIE10_MAX_LINEARIZATION_ET, output[bin]}); } - outcoder_->compress(output, finegrain, result); + std::vector finegrain_converted; + for (const auto& fg: finegrain) + finegrain_converted.push_back(fg.to_ulong()); + outcoder_->compress(output, finegrain_converted, result); } void HcalTriggerPrimitiveAlgo::runZS(HcalTrigPrimDigiCollection & result){ diff --git a/SimCalorimetry/HcalTrigPrimProducers/python/hcaltpdigi_cfi.py b/SimCalorimetry/HcalTrigPrimProducers/python/hcaltpdigi_cfi.py index 3e8f700942fb8..80f5d6c1edeb4 100644 --- a/SimCalorimetry/HcalTrigPrimProducers/python/hcaltpdigi_cfi.py +++ b/SimCalorimetry/HcalTrigPrimProducers/python/hcaltpdigi_cfi.py @@ -29,14 +29,13 @@ upgradeHB = cms.bool(False), upgradeHE = cms.bool(False), - parameters = cms.untracked.PSet( - TDCMask=cms.uint64(0xFFFFFFFFFFFFFFFF), - ADCThreshold=cms.uint32(0), - FGThreshold=cms.uint32(12) - ), - - -# + # parameters = cms.untracked.PSet( + # FGVersionHBHE=cms.uint32(0), + # TDCMask=cms.uint64(0xFFFFFFFFFFFFFFFF), + # ADCThreshold=cms.uint32(0), + # FGThreshold=cms.uint32(12) + # ), + #vdouble weights = { -1, -1, 1, 1} //low lumi algo # Input digi label (_must_ be without zero-suppression!) inputLabel = cms.VInputTag(cms.InputTag('simHcalUnsuppressedDigis'), diff --git a/SimCalorimetry/HcalTrigPrimProducers/src/HcalTrigPrimDigiProducer.cc b/SimCalorimetry/HcalTrigPrimProducers/src/HcalTrigPrimDigiProducer.cc index 3be317a2b535f..807d73b86cf9b 100644 --- a/SimCalorimetry/HcalTrigPrimProducers/src/HcalTrigPrimDigiProducer.cc +++ b/SimCalorimetry/HcalTrigPrimProducers/src/HcalTrigPrimDigiProducer.cc @@ -52,9 +52,7 @@ HcalTrigPrimDigiProducer::HcalTrigPrimDigiProducer(const edm::ParameterSet& ps) if (ps.exists("parameters")) { auto pset = ps.getUntrackedParameter("parameters"); - theAlgo_.overrideParameters(pset.getParameter("TDCMask"), - pset.getParameter("ADCThreshold"), - pset.getParameter("FGThreshold")); + theAlgo_.overrideParameters(ps); } theAlgo_.setUpgradeFlags(upgrades[0], upgrades[1], upgrades[2]); @@ -196,13 +194,13 @@ void HcalTrigPrimDigiProducer::produce(edm::Event& iEvent, const edm::EventSetup // Step C: Invoke the algorithm, passing in inputs and getting back outputs. if (legacy_ and not upgrade_) { - theAlgo_.run(inputCoder.product(), outTranscoder->getHcalCompressor().get(), + 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(), + 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(), + theAlgo_.run(inputCoder.product(), outTranscoder->getHcalCompressor().get(), pSetup.product(), *result, &(*pG), rctlsb, hfembit, *hbheUpDigis, *hfUpDigis); }