CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
List of all members | Public Member Functions | Static Public Member Functions | Protected Member Functions | Private Types | Private Attributes
HcalHardcodeCalibrations Class Reference

#include <HcalHardcodeCalibrations.h>

Inheritance diagram for HcalHardcodeCalibrations:
edm::ESProducer edm::EventSetupRecordIntervalFinder edm::ESProductResolverFactoryProducer edm::eventsetup::ESProductResolverProvider

Public Member Functions

 HcalHardcodeCalibrations (const edm::ParameterSet &)
 
 ~HcalHardcodeCalibrations () override
 
- Public Member Functions inherited from edm::ESProducer
 ESProducer ()
 
 ESProducer (const ESProducer &)=delete
 
 ESProducer (ESProducer &&)=delete
 
ESResolverIndex const * getTokenIndices (unsigned int iIndex) const
 
ESRecordIndex const * getTokenRecordIndices (unsigned int iIndex) const
 
bool hasMayConsumes () const noexcept
 
size_t numberOfTokenIndices (unsigned int iIndex) const
 
ESProduceroperator= (const ESProducer &)=delete
 
ESProduceroperator= (ESProducer &&)=delete
 
SerialTaskQueueChainqueue ()
 
template<typename Record >
std::optional< std::vector< ESResolverIndex > > updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
 
void updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final
 
 ~ESProducer () noexcept(false) override
 
- Public Member Functions inherited from edm::ESProductResolverFactoryProducer
 ESProductResolverFactoryProducer ()
 
 ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete
 
const ESProductResolverFactoryProduceroperator= (const ESProductResolverFactoryProducer &)=delete
 
 ~ESProductResolverFactoryProducer () noexcept(false) override
 
- Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
 
const ComponentDescriptiondescription () const
 
 ESProductResolverProvider ()
 
 ESProductResolverProvider (const ESProductResolverProvider &)=delete
 
void fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
 
virtual void initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
 
bool isUsingRecord (const EventSetupRecordKey &key) const
 
KeyedResolverskeyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
 
const ESProductResolverProvideroperator= (const ESProductResolverProvider &)=delete
 
void setAppendToDataLabel (const edm::ParameterSet &)
 
void setDescription (const ComponentDescription &iDescription)
 
std::set< EventSetupRecordKeyusingRecords () const
 
virtual ~ESProductResolverProvider () noexcept(false)
 
- Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool concurrentFinder () const
 
const eventsetup::ComponentDescriptiondescriptionForFinder () const
 
 EventSetupRecordIntervalFinder ()
 
 EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete
 
std::set< eventsetup::EventSetupRecordKeyfindingForRecords () const
 
const ValidityIntervalfindIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)
 
bool nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const
 
const EventSetupRecordIntervalFinderoperator= (const EventSetupRecordIntervalFinder &)=delete
 
void resetInterval (const eventsetup::EventSetupRecordKey &)
 
void setDescriptionForFinder (const eventsetup::ComponentDescription &iDescription)
 
virtual ~EventSetupRecordIntervalFinder () noexcept(false)
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void prevalidate (ConfigurationDescriptions &)
 

Protected Member Functions

std::unique_ptr< HcalChannelQualityproduceChannelQuality (const HcalChannelQualityRcd &rcd)
 
std::unique_ptr< HcalDcsMapproduceDcsMap (const HcalDcsMapRcd &rcd)
 
std::unique_ptr< HcalDcsValuesproduceDcsValues (const HcalDcsRcd &rcd)
 
std::unique_ptr< HcalPedestalsproduceEffectivePedestals (const HcalPedestalsRcd &rcd)
 
std::unique_ptr< HcalPedestalWidthsproduceEffectivePedestalWidths (const HcalPedestalWidthsRcd &rcd)
 
std::unique_ptr< HcalElectronicsMapproduceElectronicsMap (const HcalElectronicsMapRcd &rcd)
 
std::unique_ptr< HcalFlagHFDigiTimeParamsproduceFlagHFDigiTimeParams (const HcalFlagHFDigiTimeParamsRcd &rcd)
 
std::unique_ptr< HcalFrontEndMapproduceFrontEndMap (const HcalFrontEndMapRcd &rcd)
 
std::unique_ptr< HcalGainsproduceGains (const HcalGainsRcd &rcd)
 
std::unique_ptr< HcalGainWidthsproduceGainWidths (const HcalGainWidthsRcd &rcd)
 
std::unique_ptr< HcalL1TriggerObjectsproduceL1TriggerObjects (const HcalL1TriggerObjectsRcd &rcd)
 
std::unique_ptr< HcalLongRecoParamsproduceLongRecoParams (const HcalLongRecoParamsRcd &rcd)
 
std::unique_ptr< HcalLUTCorrsproduceLUTCorrs (const HcalLUTCorrsRcd &rcd)
 
std::unique_ptr< HcalLutMetadataproduceLutMetadata (const HcalLutMetadataRcd &rcd)
 
std::unique_ptr< HcalMCParamsproduceMCParams (const HcalMCParamsRcd &rcd)
 
std::unique_ptr< HcalPedestalsproducePedestals (const HcalPedestalsRcd &rcd)
 
std::unique_ptr< HcalPedestalsproducePedestals_ (const HcalPedestalsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
 
std::unique_ptr< HcalPedestalWidthsproducePedestalWidths (const HcalPedestalWidthsRcd &rcd)
 
std::unique_ptr< HcalPedestalWidthsproducePedestalWidths_ (const HcalPedestalWidthsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
 
std::unique_ptr< HcalPFCorrsproducePFCorrs (const HcalPFCorrsRcd &rcd)
 
std::unique_ptr< HcalPFCutsproducePFCuts (const HcalPFCutsRcd &rcd)
 
std::unique_ptr< HcalQIEDataproduceQIEData (const HcalQIEDataRcd &rcd)
 
std::unique_ptr< HcalQIETypesproduceQIETypes (const HcalQIETypesRcd &rcd)
 
std::unique_ptr< HcalRecoParamsproduceRecoParams (const HcalRecoParamsRcd &rcd)
 
std::unique_ptr< HcalRespCorrsproduceRespCorrs (const HcalRespCorrsRcd &rcd)
 
std::unique_ptr< HcalSiPMCharacteristicsproduceSiPMCharacteristics (const HcalSiPMCharacteristicsRcd &rcd)
 
std::unique_ptr< HcalSiPMParametersproduceSiPMParameters (const HcalSiPMParametersRcd &rcd)
 
std::unique_ptr< HcalTimeCorrsproduceTimeCorrs (const HcalTimeCorrsRcd &rcd)
 
std::unique_ptr< HcalTimingParamsproduceTimingParams (const HcalTimingParamsRcd &rcd)
 
std::unique_ptr< HcalTPChannelParametersproduceTPChannelParameters (const HcalTPChannelParametersRcd &rcd)
 
std::unique_ptr< HcalTPParametersproduceTPParameters (const HcalTPParametersRcd &rcd)
 
std::unique_ptr< HcalValidationCorrsproduceValidationCorrs (const HcalValidationCorrsRcd &rcd)
 
std::unique_ptr< HcalZDCLowGainFractionsproduceZDCLowGainFractions (const HcalZDCLowGainFractionsRcd &rcd)
 
std::unique_ptr< HcalZSThresholdsproduceZSThresholds (const HcalZSThresholdsRcd &rcd)
 
void setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override
 
- Protected Member Functions inherited from edm::ESProducer
ESConsumesInfoconsumesInfoPushBackNew ()
 
unsigned int consumesInfoSize () const
 
template<typename CallbackT , typename TList , typename TRecord >
void registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList *, const TRecord *iRecord, const es::Label &iLabel)
 
template<typename CallbackT , typename TRecord >
void registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null *, const TRecord *, const es::Label &)
 
template<typename T >
auto setWhatProduced (T *iThis, const es::Label &iLabel={})
 
template<typename T >
auto setWhatProduced (T *iThis, const char *iLabel)
 
template<typename T >
auto setWhatProduced (T *iThis, const std::string &iLabel)
 
template<typename T , typename TDecorator >
auto setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
 
template<typename T , typename TReturn , typename TRecord >
auto setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const es::Label &iLabel={})
 
template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})
 
template<typename TFunc >
auto setWhatProduced (TFunc &&func, const es::Label &iLabel={})
 
template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord > setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})
 
void usesResources (std::vector< std::string > const &)
 
- Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())
 
virtual void registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())
 
KeyedResolversVector registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override
 
- Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void usingRecord ()
 
void usingRecordWithKey (const EventSetupRecordKey &key)
 
- Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void findingRecord ()
 
void findingRecordWithKey (const eventsetup::EventSetupRecordKey &)
 

Private Types

enum  {
  kPedestals, kPedestalWidths, kEffectivePedestals, kEffectivePedestalWidths,
  kGains, kGainWidths, kPFCuts, kQIEData,
  kQIETypes, kChannelQuality, kRespCorrs, kLUTCorrs,
  kPFCorrs, kTimeCorrs, kZSThresholds, kL1TriggerObjects,
  kElectronicsMap, kValidationCorrs, kLutMetadata, kRecoParams,
  kTimingParams, kLongRecoParams, kZDCLowGainFractions, kMCParams,
  kFlagHFDigiTimeParams, kFrontEndMap, kSiPMParameters, kTPChannelParameters
}
 

Private Attributes

HcalDbHardcode dbHardcode
 
std::unique_ptr< HBHERecalibrationhb_recalibration
 
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecordhbDarkeningToken_
 
std::unique_ptr< HBHERecalibrationhe_recalibration
 
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecordheDarkeningToken_
 
std::unique_ptr< HFRecalibrationhf_recalibration
 
double iLumi
 
bool setHBdsegm
 
bool setHEdsegm
 
bool switchGainWidthsForTrigPrims
 
bool testHEPlan1
 
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_
 
bool useIeta18depth1
 
bool useLayer0Weight
 

Additional Inherited Members

- Protected Types inherited from edm::ESProductResolverFactoryProducer
using EventSetupRecordKey = eventsetup::EventSetupRecordKey
 
- Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>
 

Detailed Description

Definition at line 57 of file HcalHardcodeCalibrations.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
private
Enumerator
kPedestals 
kPedestalWidths 
kEffectivePedestals 
kEffectivePedestalWidths 
kGains 
kGainWidths 
kPFCuts 
kQIEData 
kQIETypes 
kChannelQuality 
kRespCorrs 
kLUTCorrs 
kPFCorrs 
kTimeCorrs 
kZSThresholds 
kL1TriggerObjects 
kElectronicsMap 
kValidationCorrs 
kLutMetadata 
kRecoParams 
kTimingParams 
kLongRecoParams 
kZDCLowGainFractions 
kMCParams 
kFlagHFDigiTimeParams 
kFrontEndMap 
kSiPMParameters 
kTPChannelParameters 

Definition at line 114 of file HcalHardcodeCalibrations.h.

114  {
115  kPedestals,
119  kGains,
120  kGainWidths,
121  kPFCuts,
122  kQIEData,
123  kQIETypes,
125  kRespCorrs,
126  kLUTCorrs,
127  kPFCorrs,
128  kTimeCorrs,
133  kLutMetadata,
134  kRecoParams,
138  kMCParams,
140  kFrontEndMap,
143  };

Constructor & Destructor Documentation

◆ HcalHardcodeCalibrations()

HcalHardcodeCalibrations::HcalHardcodeCalibrations ( const edm::ParameterSet iConfig)

Definition at line 130 of file HcalHardcodeCalibrations.cc.

References python.cmstools::all(), HltBtagPostValidation_cff::c, gather_cfg::cout, dbHardcode, edm::ParameterSet::empty(), edm::ParameterSet::exists(), edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hb_recalibration, hbDarkeningToken_, he_recalibration, heDarkeningToken_, hf_recalibration, iLumi, kChannelQuality, kEffectivePedestals, kEffectivePedestalWidths, kElectronicsMap, kFlagHFDigiTimeParams, kFrontEndMap, kGains, kGainWidths, kL1TriggerObjects, kLongRecoParams, kLUTCorrs, kLutMetadata, kMCParams, kPedestals, kPedestalWidths, kPFCorrs, kPFCuts, kQIEData, kQIETypes, kRecoParams, kRespCorrs, kSiPMParameters, kTimeCorrs, kTPChannelParameters, kValidationCorrs, kZDCLowGainFractions, kZSThresholds, summarizeEdmComparisonLogfiles::objectName, produceChannelQuality(), produceDcsMap(), produceDcsValues(), produceEffectivePedestals(), produceEffectivePedestalWidths(), produceElectronicsMap(), produceFlagHFDigiTimeParams(), produceFrontEndMap(), produceGains(), produceGainWidths(), produceL1TriggerObjects(), produceLongRecoParams(), produceLUTCorrs(), produceLutMetadata(), produceMCParams(), producePedestals(), producePedestalWidths(), producePFCorrs(), producePFCuts(), produceQIEData(), produceQIETypes(), produceRecoParams(), produceRespCorrs(), produceSiPMCharacteristics(), produceSiPMParameters(), produceTimeCorrs(), produceTPChannelParameters(), produceTPParameters(), produceValidationCorrs(), produceZDCLowGainFractions(), produceZSThresholds(), HcalDbHardcode::setHB(), HcalDbHardcode::setHBUpgrade(), HcalDbHardcode::setHE(), HcalDbHardcode::setHEUpgrade(), HcalDbHardcode::setHF(), HcalDbHardcode::setHFUpgrade(), HcalDbHardcode::setHO(), HcalDbHardcode::setKillHE(), HcalDbHardcode::setSiPMCharacteristics(), edm::ESProducer::setWhatProduced(), switchGainWidthsForTrigPrims, HcalDbHardcode::testHEPlan1(), testHEPlan1, HcalDbHardcode::testHFQIE10(), GlobalPosition_Frontier_DevDB_cff::toGet, topoTokens_, HcalDbHardcode::useHBUpgrade(), HcalDbHardcode::useHEUpgrade(), HcalDbHardcode::useHFUpgrade(), HcalDbHardcode::useHOUpgrade(), useIeta18depth1, and useLayer0Weight.

131  : hb_recalibration(nullptr),
132  he_recalibration(nullptr),
133  hf_recalibration(nullptr),
134  setHEdsegm(false),
135  setHBdsegm(false) {
136  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
137 
138  if (iConfig.exists("GainWidthsForTrigPrims"))
139  switchGainWidthsForTrigPrims = iConfig.getParameter<bool>("GainWidthsForTrigPrims");
140  else
142 
143  //DB helper preparation
151  dbHardcode.useHBUpgrade(iConfig.getParameter<bool>("useHBUpgrade"));
152  dbHardcode.useHEUpgrade(iConfig.getParameter<bool>("useHEUpgrade"));
153  dbHardcode.useHFUpgrade(iConfig.getParameter<bool>("useHFUpgrade"));
154  dbHardcode.useHOUpgrade(iConfig.getParameter<bool>("useHOUpgrade"));
155  dbHardcode.testHFQIE10(iConfig.getParameter<bool>("testHFQIE10"));
156  dbHardcode.testHEPlan1(iConfig.getParameter<bool>("testHEPlan1"));
157  dbHardcode.setKillHE(iConfig.getParameter<bool>("killHE"));
158  dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));
159 
160  useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
161  useIeta18depth1 = iConfig.getParameter<bool>("useIeta18depth1");
162  testHEPlan1 = iConfig.getParameter<bool>("testHEPlan1");
163  // HB, HE, HF recalibration preparation
164  iLumi = iConfig.getParameter<double>("iLumi");
165 
166  if (iLumi > 0.0) {
167  bool hb_recalib = iConfig.getParameter<bool>("HBRecalibration");
168  bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
169  bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
170  if (hb_recalib) {
172  std::make_unique<HBHERecalibration>(iLumi,
173  iConfig.getParameter<double>("HBreCalibCutoff"),
174  iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath());
175  }
176  if (he_recalib) {
178  std::make_unique<HBHERecalibration>(iLumi,
179  iConfig.getParameter<double>("HEreCalibCutoff"),
180  iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath());
181  }
182  if (hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())
184  std::make_unique<HFRecalibration>(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
185 
186 #ifdef DebugLog
187  std::cout << " HcalHardcodeCalibrations: iLumi = " << iLumi << std::endl;
188 #endif
189  }
190 
191  std::vector<std::string> toGet = iConfig.getUntrackedParameter<std::vector<std::string>>("toGet");
192  for (auto& objectName : toGet) {
193  bool all = objectName == "all";
194 #ifdef DebugLog
195  std::cout << "Load parameters for " << objectName << std::endl;
196 #endif
197  if ((objectName == "Pedestals") || all) {
199  findingRecord<HcalPedestalsRcd>();
200  }
201  if ((objectName == "PedestalWidths") || all) {
203  findingRecord<HcalPedestalWidthsRcd>();
204  }
205  if ((objectName == "EffectivePedestals") || all) {
208  .consumes();
209  findingRecord<HcalPedestalsRcd>();
210  }
211  if ((objectName == "EffectivePedestalWidths") || all) {
214  .consumes();
215  findingRecord<HcalPedestalWidthsRcd>();
216  }
217  if ((objectName == "Gains") || all) {
219  findingRecord<HcalGainsRcd>();
220  }
221  if ((objectName == "GainWidths") || all) {
223  findingRecord<HcalGainWidthsRcd>();
224  }
225  if ((objectName == "PFCuts") || all) {
227  findingRecord<HcalPFCutsRcd>();
228  }
229  if ((objectName == "QIEData") || all) {
231  findingRecord<HcalQIEDataRcd>();
232  }
233  if ((objectName == "QIETypes") || all) {
235  findingRecord<HcalQIETypesRcd>();
236  }
237  if ((objectName == "ChannelQuality") || (objectName == "channelQuality") || all) {
239  findingRecord<HcalChannelQualityRcd>();
240  }
241  if ((objectName == "ElectronicsMap") || (objectName == "electronicsMap") || all) {
243  findingRecord<HcalElectronicsMapRcd>();
244  }
245  if ((objectName == "ZSThresholds") || (objectName == "zsThresholds") || all) {
247  findingRecord<HcalZSThresholdsRcd>();
248  }
249  if ((objectName == "RespCorrs") || (objectName == "ResponseCorrection") || all) {
251  topoTokens_[kRespCorrs] = c.consumes();
252  if (he_recalibration) {
253  heDarkeningToken_ = c.consumes(edm::ESInputTag("", "HE"));
254  }
255  if (hb_recalibration) {
256  hbDarkeningToken_ = c.consumes(edm::ESInputTag("", "HB"));
257  }
258  findingRecord<HcalRespCorrsRcd>();
259  }
260  if ((objectName == "LUTCorrs") || (objectName == "LUTCorrection") || all) {
262  findingRecord<HcalLUTCorrsRcd>();
263  }
264  if ((objectName == "PFCorrs") || (objectName == "PFCorrection") || all) {
266  findingRecord<HcalPFCorrsRcd>();
267  }
268  if ((objectName == "TimeCorrs") || (objectName == "TimeCorrection") || all) {
270  findingRecord<HcalTimeCorrsRcd>();
271  }
272  if ((objectName == "L1TriggerObjects") || (objectName == "L1Trigger") || all) {
275  findingRecord<HcalL1TriggerObjectsRcd>();
276  }
277  if ((objectName == "ValidationCorrs") || (objectName == "ValidationCorrection") || all) {
280  findingRecord<HcalValidationCorrsRcd>();
281  }
282  if ((objectName == "LutMetadata") || (objectName == "lutMetadata") || all) {
284  findingRecord<HcalLutMetadataRcd>();
285  }
286  if ((objectName == "DcsValues") || all) {
288  findingRecord<HcalDcsRcd>();
289  }
290  if ((objectName == "DcsMap") || (objectName == "dcsMap") || all) {
292  findingRecord<HcalDcsMapRcd>();
293  }
294  if ((objectName == "RecoParams") || all) {
296  findingRecord<HcalRecoParamsRcd>();
297  }
298  if ((objectName == "LongRecoParams") || all) {
300  findingRecord<HcalLongRecoParamsRcd>();
301  }
302  if ((objectName == "ZDCLowGainFractions") || all) {
305  findingRecord<HcalZDCLowGainFractionsRcd>();
306  }
307  if ((objectName == "MCParams") || all) {
309  findingRecord<HcalMCParamsRcd>();
310  }
311  if ((objectName == "FlagHFDigiTimeParams") || all) {
314  findingRecord<HcalFlagHFDigiTimeParamsRcd>();
315  }
316  if ((objectName == "FrontEndMap") || (objectName == "frontEndMap") || all) {
318  findingRecord<HcalFrontEndMapRcd>();
319  }
320  if ((objectName == "SiPMParameters") || all) {
322  findingRecord<HcalSiPMParametersRcd>();
323  }
324  if ((objectName == "SiPMCharacteristics") || all) {
326  findingRecord<HcalSiPMCharacteristicsRcd>();
327  }
328  if ((objectName == "TPChannelParameters") || all) {
331  findingRecord<HcalTPChannelParametersRcd>();
332  }
333  if ((objectName == "TPParameters") || all) {
335  findingRecord<HcalTPParametersRcd>();
336  }
337  }
338 }
std::unique_ptr< HcalPedestals > producePedestals(const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalPFCuts > producePFCuts(const HcalPFCutsRcd &rcd)
auto setWhatProduced(T *iThis, const es::Label &iLabel={})
Definition: ESProducer.h:166
std::unique_ptr< HcalGains > produceGains(const HcalGainsRcd &rcd)
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
void useHBUpgrade(bool b)
std::unique_ptr< HcalPedestalWidths > produceEffectivePedestalWidths(const HcalPedestalWidthsRcd &rcd)
std::unique_ptr< HcalPFCorrs > producePFCorrs(const HcalPFCorrsRcd &rcd)
std::unique_ptr< HcalQIEData > produceQIEData(const HcalQIEDataRcd &rcd)
void setHBUpgrade(HcalHardcodeParameters p)
def all(container)
workaround iterator generators for ROOT classes
Definition: cmstools.py:25
std::string fullPath() const
Definition: FileInPath.cc:161
void testHEPlan1(bool b)
std::unique_ptr< HcalTimeCorrs > produceTimeCorrs(const HcalTimeCorrsRcd &rcd)
void useHFUpgrade(bool b)
std::unique_ptr< HcalLongRecoParams > produceLongRecoParams(const HcalLongRecoParamsRcd &rcd)
std::unique_ptr< HcalPedestals > produceEffectivePedestals(const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalSiPMCharacteristics > produceSiPMCharacteristics(const HcalSiPMCharacteristicsRcd &rcd)
bool exists(std::string const &parameterName) const
checks if a parameter exists
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > hbDarkeningToken_
std::unique_ptr< HcalElectronicsMap > produceElectronicsMap(const HcalElectronicsMapRcd &rcd)
void setHF(HcalHardcodeParameters p)
std::unique_ptr< HcalDcsValues > produceDcsValues(const HcalDcsRcd &rcd)
T getUntrackedParameter(std::string const &, T const &) const
std::unique_ptr< HcalPedestalWidths > producePedestalWidths(const HcalPedestalWidthsRcd &rcd)
std::unique_ptr< HFRecalibration > hf_recalibration
std::unique_ptr< HcalRespCorrs > produceRespCorrs(const HcalRespCorrsRcd &rcd)
std::unique_ptr< HcalLutMetadata > produceLutMetadata(const HcalLutMetadataRcd &rcd)
void setHO(HcalHardcodeParameters p)
bool empty() const
Definition: ParameterSet.h:201
void setHFUpgrade(HcalHardcodeParameters p)
void setHE(HcalHardcodeParameters p)
void setKillHE(bool b)
std::unique_ptr< HcalFlagHFDigiTimeParams > produceFlagHFDigiTimeParams(const HcalFlagHFDigiTimeParamsRcd &rcd)
std::unique_ptr< HcalFrontEndMap > produceFrontEndMap(const HcalFrontEndMapRcd &rcd)
std::unique_ptr< HBHERecalibration > hb_recalibration
void useHOUpgrade(bool b)
std::unique_ptr< HcalSiPMParameters > produceSiPMParameters(const HcalSiPMParametersRcd &rcd)
std::unique_ptr< HBHERecalibration > he_recalibration
std::unique_ptr< HcalRecoParams > produceRecoParams(const HcalRecoParamsRcd &rcd)
void setHB(HcalHardcodeParameters p)
Log< level::Info, false > LogInfo
std::unique_ptr< HcalTPParameters > produceTPParameters(const HcalTPParametersRcd &rcd)
std::unique_ptr< HcalGainWidths > produceGainWidths(const HcalGainWidthsRcd &rcd)
std::unique_ptr< HcalTPChannelParameters > produceTPChannelParameters(const HcalTPChannelParametersRcd &rcd)
std::unique_ptr< HcalL1TriggerObjects > produceL1TriggerObjects(const HcalL1TriggerObjectsRcd &rcd)
std::unique_ptr< HcalZSThresholds > produceZSThresholds(const HcalZSThresholdsRcd &rcd)
std::unique_ptr< HcalZDCLowGainFractions > produceZDCLowGainFractions(const HcalZDCLowGainFractionsRcd &rcd)
void setSiPMCharacteristics(std::vector< edm::ParameterSet > vps)
std::unique_ptr< HcalMCParams > produceMCParams(const HcalMCParamsRcd &rcd)
void useHEUpgrade(bool b)
std::unique_ptr< HcalQIETypes > produceQIETypes(const HcalQIETypesRcd &rcd)
std::unique_ptr< HcalChannelQuality > produceChannelQuality(const HcalChannelQualityRcd &rcd)
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > heDarkeningToken_
void setHEUpgrade(HcalHardcodeParameters p)
std::unique_ptr< HcalDcsMap > produceDcsMap(const HcalDcsMapRcd &rcd)
std::unique_ptr< HcalLUTCorrs > produceLUTCorrs(const HcalLUTCorrsRcd &rcd)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_
void testHFQIE10(bool b)
std::unique_ptr< HcalValidationCorrs > produceValidationCorrs(const HcalValidationCorrsRcd &rcd)

◆ ~HcalHardcodeCalibrations()

HcalHardcodeCalibrations::~HcalHardcodeCalibrations ( )
override

Definition at line 340 of file HcalHardcodeCalibrations.cc.

340 {}

Member Function Documentation

◆ fillDescriptions()

void HcalHardcodeCalibrations::fillDescriptions ( edm::ConfigurationDescriptions descriptions)
static

Definition at line 875 of file HcalHardcodeCalibrations.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), and submitPVResolutionJobs::desc.

875  {
877  desc.add<double>("iLumi", -1.);
878  desc.add<bool>("HBRecalibration", false);
879  desc.add<double>("HBreCalibCutoff", 20.);
880  desc.add<edm::FileInPath>("HBmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHB.txt"));
881  desc.add<bool>("HERecalibration", false);
882  desc.add<double>("HEreCalibCutoff", 20.);
883  desc.add<edm::FileInPath>("HEmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHE.txt"));
884  desc.add<bool>("HFRecalibration", false);
885  desc.add<bool>("GainWidthsForTrigPrims", false);
886  desc.add<bool>("useHBUpgrade", false);
887  desc.add<bool>("useHEUpgrade", false);
888  desc.add<bool>("useHFUpgrade", false);
889  desc.add<bool>("useHOUpgrade", true);
890  desc.add<bool>("testHFQIE10", false);
891  desc.add<bool>("testHEPlan1", false);
892  desc.add<bool>("killHE", false);
893  desc.add<bool>("useLayer0Weight", false);
894  desc.add<bool>("useIeta18depth1", true);
895  desc.addUntracked<std::vector<std::string>>("toGet", std::vector<std::string>());
896  desc.addUntracked<bool>("fromDDD", false);
897 
899  desc_hb.add<std::vector<double>>("gain", std::vector<double>({0.19}));
900  desc_hb.add<std::vector<double>>("gainWidth", std::vector<double>({0.0}));
901  desc_hb.add<double>("pedestal", 3.0);
902  desc_hb.add<double>("pedestalWidth", 0.55);
903  desc_hb.add<int>("zsThreshold", 8);
904  desc_hb.add<std::vector<double>>("qieOffset", std::vector<double>({-0.49, 1.8, 7.2, 37.9}));
905  desc_hb.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.917, 0.922, 0.923}));
906  desc_hb.add<int>("qieType", 0);
907  desc_hb.add<int>("mcShape", 125);
908  desc_hb.add<int>("recoShape", 105);
909  desc_hb.add<double>("photoelectronsToAnalog", 0.0);
910  desc_hb.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
911  desc_hb.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
912  desc_hb.add<bool>("doRadiationDamage", false);
913  desc_hb.add<double>("noiseThreshold", 0.0);
914  desc_hb.add<double>("seedThreshold", 0.1);
915  desc.add<edm::ParameterSetDescription>("hb", desc_hb);
916 
917  edm::ParameterSetDescription desc_hbRaddam;
918  desc_hbRaddam.add<double>("temperatureBase", 20.0);
919  desc_hbRaddam.add<double>("temperatureNew", -5.0);
920  desc_hbRaddam.add<double>("intlumiOffset", 150);
921  desc_hbRaddam.add<double>("depVsTemp", 0.0631);
922  desc_hbRaddam.add<double>("intlumiToNeutrons", 3.67e8);
923  desc_hbRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
924 
925  edm::ParameterSetDescription desc_hbUpgrade;
926  desc_hbUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
927  desc_hbUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
928  desc_hbUpgrade.add<double>("pedestal", 18.0);
929  desc_hbUpgrade.add<double>("pedestalWidth", 5.0);
930  desc_hbUpgrade.add<int>("zsThreshold", 3);
931  desc_hbUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
932  desc_hbUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
933  desc_hbUpgrade.add<int>("qieType", 2);
934  desc_hbUpgrade.add<int>("mcShape", 206);
935  desc_hbUpgrade.add<int>("recoShape", 206);
936  desc_hbUpgrade.add<double>("photoelectronsToAnalog", 57.5);
937  desc_hbUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
938  desc_hbUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
939  desc_hbUpgrade.add<bool>("doRadiationDamage", true);
940  desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
941  desc_hbUpgrade.add<double>("noiseThreshold", 0.0);
942  desc_hbUpgrade.add<double>("seedThreshold", 0.1);
943  desc.add<edm::ParameterSetDescription>("hbUpgrade", desc_hbUpgrade);
944 
946  desc_he.add<std::vector<double>>("gain", std::vector<double>({0.23}));
947  desc_he.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
948  desc_he.add<double>("pedestal", 3.0);
949  desc_he.add<double>("pedestalWidth", 0.79);
950  desc_he.add<int>("zsThreshold", 9);
951  desc_he.add<std::vector<double>>("qieOffset", std::vector<double>({-0.38, 2.0, 7.6, 39.6}));
952  desc_he.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.916, 0.92, 0.922}));
953  desc_he.add<int>("qieType", 0);
954  desc_he.add<int>("mcShape", 125);
955  desc_he.add<int>("recoShape", 105);
956  desc_he.add<double>("photoelectronsToAnalog", 0.0);
957  desc_he.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
958  desc_he.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
959  desc_he.add<bool>("doRadiationDamage", false);
960  desc_he.add<double>("noiseThreshold", 0.0);
961  desc_he.add<double>("seedThreshold", 0.1);
962  desc.add<edm::ParameterSetDescription>("he", desc_he);
963 
964  edm::ParameterSetDescription desc_heRaddam;
965  desc_heRaddam.add<double>("temperatureBase", 20.0);
966  desc_heRaddam.add<double>("temperatureNew", 5.0);
967  desc_heRaddam.add<double>("intlumiOffset", 75);
968  desc_heRaddam.add<double>("depVsTemp", 0.0631);
969  desc_heRaddam.add<double>("intlumiToNeutrons", 2.92e8);
970  desc_heRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
971 
972  edm::ParameterSetDescription desc_heUpgrade;
973  desc_heUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
974  desc_heUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
975  desc_heUpgrade.add<double>("pedestal", 18.0);
976  desc_heUpgrade.add<double>("pedestalWidth", 5.0);
977  desc_heUpgrade.add<int>("zsThreshold", 3);
978  desc_heUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
979  desc_heUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
980  desc_heUpgrade.add<int>("qieType", 2);
981  desc_heUpgrade.add<int>("mcShape", 206);
982  desc_heUpgrade.add<int>("recoShape", 206);
983  desc_heUpgrade.add<double>("photoelectronsToAnalog", 57.5);
984  desc_heUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
985  desc_heUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
986  desc_heUpgrade.add<bool>("doRadiationDamage", true);
987  desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
988  desc_heUpgrade.add<double>("noiseThreshold", 0.0);
989  desc_heUpgrade.add<double>("seedThreshold", 0.1);
990  desc.add<edm::ParameterSetDescription>("heUpgrade", desc_heUpgrade);
991 
993  desc_hf.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
994  desc_hf.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
995  desc_hf.add<double>("pedestal", 3.0);
996  desc_hf.add<double>("pedestalWidth", 0.84);
997  desc_hf.add<int>("zsThreshold", -9999);
998  desc_hf.add<std::vector<double>>("qieOffset", std::vector<double>({-0.87, 1.4, 7.8, -29.6}));
999  desc_hf.add<std::vector<double>>("qieSlope", std::vector<double>({0.359, 0.358, 0.36, 0.367}));
1000  desc_hf.add<int>("qieType", 0);
1001  desc_hf.add<int>("mcShape", 301);
1002  desc_hf.add<int>("recoShape", 301);
1003  desc_hf.add<double>("photoelectronsToAnalog", 0.0);
1004  desc_hf.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1005  desc_hf.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1006  desc_hf.add<bool>("doRadiationDamage", false);
1007  desc_hf.add<double>("noiseThreshold", 0.0);
1008  desc_hf.add<double>("seedThreshold", 0.1);
1009  desc.add<edm::ParameterSetDescription>("hf", desc_hf);
1010 
1011  edm::ParameterSetDescription desc_hfUpgrade;
1012  desc_hfUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
1013  desc_hfUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
1014  desc_hfUpgrade.add<double>("pedestal", 13.33);
1015  desc_hfUpgrade.add<double>("pedestalWidth", 3.33);
1016  desc_hfUpgrade.add<int>("zsThreshold", -9999);
1017  desc_hfUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0697, -0.7405, 12.38, -671.9}));
1018  desc_hfUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.297, 0.298, 0.298, 0.313}));
1019  desc_hfUpgrade.add<int>("qieType", 1);
1020  desc_hfUpgrade.add<int>("mcShape", 301);
1021  desc_hfUpgrade.add<int>("recoShape", 301);
1022  desc_hfUpgrade.add<double>("photoelectronsToAnalog", 0.0);
1023  desc_hfUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1024  desc_hfUpgrade.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1025  desc_hfUpgrade.add<bool>("doRadiationDamage", false);
1026  desc_hfUpgrade.add<double>("noiseThreshold", 0.0);
1027  desc_hfUpgrade.add<double>("seedThreshold", 0.1);
1028  desc.add<edm::ParameterSetDescription>("hfUpgrade", desc_hfUpgrade);
1029 
1030  edm::ParameterSetDescription desc_hfrecal;
1031  desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterA", std::vector<double>());
1032  desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterB", std::vector<double>());
1033  desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterA", std::vector<double>());
1034  desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterB", std::vector<double>());
1035  desc.add<edm::ParameterSetDescription>("HFRecalParameterBlock", desc_hfrecal);
1036 
1038  desc_ho.add<std::vector<double>>("gain", std::vector<double>({0.006, 0.0087}));
1039  desc_ho.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
1040  desc_ho.add<double>("pedestal", 11.0);
1041  desc_ho.add<double>("pedestalWidth", 0.57);
1042  desc_ho.add<int>("zsThreshold", 24);
1043  desc_ho.add<std::vector<double>>("qieOffset", std::vector<double>({-0.44, 1.4, 7.1, 38.5}));
1044  desc_ho.add<std::vector<double>>("qieSlope", std::vector<double>({0.907, 0.915, 0.92, 0.921}));
1045  desc_ho.add<int>("qieType", 0);
1046  desc_ho.add<int>("mcShape", 201);
1047  desc_ho.add<int>("recoShape", 201);
1048  desc_ho.add<double>("photoelectronsToAnalog", 4.0);
1049  desc_ho.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
1050  desc_ho.add<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
1051  desc_ho.add<bool>("doRadiationDamage", false);
1052  desc_ho.add<double>("noiseThreshold", 0.0);
1053  desc_ho.add<double>("seedThreshold", 0.1);
1054  desc.add<edm::ParameterSetDescription>("ho", desc_ho);
1055 
1056  edm::ParameterSetDescription validator_sipm;
1057  validator_sipm.add<int>("pixels", 1);
1058  validator_sipm.add<double>("crosstalk", 0);
1059  validator_sipm.add<double>("nonlin1", 1);
1060  validator_sipm.add<double>("nonlin2", 0);
1061  validator_sipm.add<double>("nonlin3", 0);
1062  std::vector<edm::ParameterSet> default_sipm(1);
1063  desc.addVPSet("SiPMCharacteristics", validator_sipm, default_sipm);
1064 
1065  descriptions.addDefault(desc);
1066 }
void addDefault(ParameterSetDescription const &psetDescription)
ParameterDescriptionBase * add(U const &iLabel, T const &value)

◆ produceChannelQuality()

std::unique_ptr< HcalChannelQuality > HcalHardcodeCalibrations::produceChannelQuality ( const HcalChannelQualityRcd rcd)
protected

Definition at line 479 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, hcalRecHitTable_cff::depth, HcalDetId::depth(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), hcalRecHitTable_cff::ieta, HcalDetId::ieta(), HcalDetId::ietaAbs(), hcalRecHitTable_cff::iphi, HcalDetId::iphi(), B2GTnPMonitor_cfi::item, kChannelQuality, HcalDbHardcode::killHE(), mps_fire::result, mps_update::status, testHEPlan1, topoTokens_, and useIeta18depth1.

Referenced by HcalHardcodeCalibrations().

479  {
480  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
481  auto const& topo = rcd.get(topoTokens_[kChannelQuality]);
482 
483  auto result = std::make_unique<HcalChannelQuality>(&topo);
484  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
485  for (auto cell : cells) {
486  // Special: removal of (non-instrumented) layer "-1"("nose") = depth 1
487  // from Upgrade HE, either from
488  // (i) HEP17 sector in 2017 or
489  // (ii) the entire HE rin=18 from 2018 through Run 3.
490  // May require a revision by 2021.
491 
492  uint32_t status = 0;
493 
494  if (!(cell.isHcalZDCDetId())) {
495  HcalDetId hid = HcalDetId(cell);
496  int iphi = hid.iphi();
497  int ieta = hid.ieta();
498  int absieta = hid.ietaAbs();
499  int depth = hid.depth();
500 
501  // specific HEP17 sector (2017 only)
502  bool isHEP17 = (iphi >= 63) && (iphi <= 66) && (ieta > 0);
503  // |ieta|=18, depth=1
504  bool is18d1 = (absieta == 18) && (depth == 1);
505 
506  if ((!useIeta18depth1 && is18d1) && ((testHEPlan1 && isHEP17) || (!testHEPlan1))) {
507  status = 0x8002; // dead cell
508  }
509  }
510 
511  HcalChannelStatus item(cell.rawId(), status);
512  result->addValues(item);
513  }
514 
515  return result;
516 }
constexpr int ietaAbs() const
get the absolute value of the cell ieta
Definition: HcalDetId.h:148
const bool killHE() const
constexpr int ieta() const
get the cell ieta
Definition: HcalDetId.h:155
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
constexpr int iphi() const
get the cell iphi
Definition: HcalDetId.h:157
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_
constexpr int depth() const
get the tower depth
Definition: HcalDetId.h:164

◆ produceDcsMap()

std::unique_ptr< HcalDcsMap > HcalHardcodeCalibrations::produceDcsMap ( const HcalDcsMapRcd rcd)
protected

Definition at line 711 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeDcsMap().

Referenced by HcalHardcodeCalibrations().

711  {
712  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
713 
715 }
std::unique_ptr< HcalDcsMap > makeHardcodeDcsMap() const
Log< level::Info, false > LogInfo

◆ produceDcsValues()

std::unique_ptr< HcalDcsValues > HcalHardcodeCalibrations::produceDcsValues ( const HcalDcsRcd rcd)
protected

Definition at line 705 of file HcalHardcodeCalibrations.cc.

References mps_fire::result.

Referenced by HcalHardcodeCalibrations().

705  {
706  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsValues-> ...";
707  auto result = std::make_unique<HcalDcsValues>();
708  return result;
709 }
Log< level::Info, false > LogInfo

◆ produceEffectivePedestals()

std::unique_ptr< HcalPedestals > HcalHardcodeCalibrations::produceEffectivePedestals ( const HcalPedestalsRcd rcd)
protected

Definition at line 387 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

387  {
389 }
std::unique_ptr< HcalPedestals > producePedestals_(const HcalPedestalsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceEffectivePedestalWidths()

std::unique_ptr< HcalPedestalWidths > HcalHardcodeCalibrations::produceEffectivePedestalWidths ( const HcalPedestalWidthsRcd rcd)
protected

Definition at line 395 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

396  {
398 }
std::unique_ptr< HcalPedestalWidths > producePedestalWidths_(const HcalPedestalWidthsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceElectronicsMap()

std::unique_ptr< HcalElectronicsMap > HcalHardcodeCalibrations::produceElectronicsMap ( const HcalElectronicsMapRcd rcd)
protected

Definition at line 657 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), kElectronicsMap, HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeMap(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

657  {
658  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceElectronicsMap-> ...";
659  auto const& topo = rcd.get(topoTokens_[kElectronicsMap]);
660 
661  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
663 }
const bool killHE() const
Log< level::Info, false > LogInfo
std::unique_ptr< HcalElectronicsMap > makeHardcodeMap(const std::vector< HcalGenericDetId > &cells) const
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceFlagHFDigiTimeParams()

std::unique_ptr< HcalFlagHFDigiTimeParams > HcalHardcodeCalibrations::produceFlagHFDigiTimeParams ( const HcalFlagHFDigiTimeParamsRcd rcd)
protected

Definition at line 794 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, kFlagHFDigiTimeParams, HcalDbHardcode::killHE(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

795  {
796  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
797  auto const& topo = rec.get(topoTokens_[kFlagHFDigiTimeParams]);
798 
799  auto result = std::make_unique<HcalFlagHFDigiTimeParams>(&topo);
800  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
801 
802  std::vector<double> coef;
803  coef.push_back(0.93);
804  coef.push_back(-0.38275);
805  coef.push_back(-0.012667);
806 
807  for (auto cell : cells) {
808  HcalFlagHFDigiTimeParam item(cell.rawId(),
809  1, //firstsample
810  3, // samplestoadd
811  2, //expectedpeak
812  40., // min energy threshold
813  coef // coefficients
814  );
815  result->addValues(item);
816  }
817  return result;
818 }
const bool killHE() const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceFrontEndMap()

std::unique_ptr< HcalFrontEndMap > HcalHardcodeCalibrations::produceFrontEndMap ( const HcalFrontEndMapRcd rcd)
protected

Definition at line 820 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), kFrontEndMap, HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeFrontEndMap(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

820  {
821  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFrontEndMap-> ...";
822  auto const& topo = rec.get(topoTokens_[kFrontEndMap]);
823 
824  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
825 
827 }
void makeHardcodeFrontEndMap(HcalFrontEndMap &emap, const std::vector< HcalGenericDetId > &cells) const
const bool killHE() const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceGains()

std::unique_ptr< HcalGains > HcalHardcodeCalibrations::produceGains ( const HcalGainsRcd rcd)
protected

Definition at line 400 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, B2GTnPMonitor_cfi::item, kGains, HcalDbHardcode::killHE(), HcalDbHardcode::makeGain(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

400  {
401  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGains-> ...";
402 
403  auto const& topo = rec.get(topoTokens_[kGains]);
404  auto result = std::make_unique<HcalGains>(&topo);
405  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
406  for (auto cell : cells) {
408  result->addValues(item);
409  }
410  return result;
411 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalGain makeGain(HcalGenericDetId fId, bool fSmear=false) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceGainWidths()

std::unique_ptr< HcalGainWidths > HcalHardcodeCalibrations::produceGainWidths ( const HcalGainWidthsRcd rcd)
protected

Definition at line 413 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, kGainWidths, HcalDbHardcode::killHE(), HcalDbHardcode::makeGainWidth(), mps_fire::result, switchGainWidthsForTrigPrims, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

413  {
414  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
415 
416  auto const& topo = rec.get(topoTokens_[kGainWidths]);
417  auto result = std::make_unique<HcalGainWidths>(&topo);
418  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
419  for (auto cell : cells) {
420  // for Upgrade - include TrigPrims, for regular case - only HcalDetId
423  result->addValues(item);
424  } else if (!cell.isHcalTrigTowerDetId()) {
426  result->addValues(item);
427  }
428  }
429  return result;
430 }
const bool killHE() const
HcalGainWidth makeGainWidth(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceL1TriggerObjects()

std::unique_ptr< HcalL1TriggerObjects > HcalHardcodeCalibrations::produceL1TriggerObjects ( const HcalL1TriggerObjectsRcd rcd)
protected

Definition at line 640 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kL1TriggerObjects, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

641  {
642  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
643  auto const& topo = rcd.get(topoTokens_[kL1TriggerObjects]);
644 
645  auto result = std::make_unique<HcalL1TriggerObjects>(&topo);
646  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
647  for (auto cell : cells) {
648  HcalL1TriggerObject item(cell.rawId(), 0., 1., 0);
649  result->addValues(item);
650  }
651  // add tag and algo values
652  result->setTagString("hardcoded");
653  result->setAlgoString("hardcoded");
654  return result;
655 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceLongRecoParams()

std::unique_ptr< HcalLongRecoParams > HcalHardcodeCalibrations::produceLongRecoParams ( const HcalLongRecoParamsRcd rcd)
protected

Definition at line 743 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kLongRecoParams, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

743  {
744  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
745  auto const& topo = rec.get(topoTokens_[kLongRecoParams]);
746 
747  auto result = std::make_unique<HcalLongRecoParams>(&topo);
748  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
749  std::vector<unsigned int> mSignal;
750  mSignal.push_back(4);
751  mSignal.push_back(5);
752  mSignal.push_back(6);
753  std::vector<unsigned int> mNoise;
754  mNoise.push_back(1);
755  mNoise.push_back(2);
756  mNoise.push_back(3);
757  for (auto cell : cells) {
758  if (cell.isHcalZDCDetId()) {
759  HcalLongRecoParam item(cell.rawId(), mSignal, mNoise);
760  result->addValues(item);
761  }
762  }
763  return result;
764 }
const bool killHE() const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceLUTCorrs()

std::unique_ptr< HcalLUTCorrs > HcalHardcodeCalibrations::produceLUTCorrs ( const HcalLUTCorrsRcd rcd)
protected

Definition at line 588 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kLUTCorrs, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

588  {
589  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLUTCorrs-> ...";
590  auto const& topo = rcd.get(topoTokens_[kLUTCorrs]);
591 
592  auto result = std::make_unique<HcalLUTCorrs>(&topo);
593  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
594  for (auto cell : cells) {
595  HcalLUTCorr item(cell.rawId(), 1.0);
596  result->addValues(item);
597  }
598  return result;
599 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceLutMetadata()

std::unique_ptr< HcalLutMetadata > HcalHardcodeCalibrations::produceLutMetadata ( const HcalLutMetadataRcd rcd)
protected

Definition at line 679 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kLutMetadata, mps_fire::result, remoteMonitoring_LASER_era2018_cfg::threshold, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

679  {
680  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
681  auto const& topo = rcd.get(topoTokens_[kLutMetadata]);
682 
683  auto result = std::make_unique<HcalLutMetadata>(&topo);
684 
685  result->setRctLsb(0.5);
686  result->setNominalGain(0.177); // for HBHE SiPMs
687 
688  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
689  for (const auto& cell : cells) {
690  float rcalib = 1.;
691  int granularity = 1;
692  int threshold = 0;
693 
694  if (cell.isHcalTrigTowerDetId()) {
695  rcalib = 0.;
696  }
697 
698  HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
699  result->addValues(item);
700  }
701 
702  return result;
703 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceMCParams()

std::unique_ptr< HcalMCParams > HcalHardcodeCalibrations::produceMCParams ( const HcalMCParamsRcd rcd)
protected

Definition at line 780 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kMCParams, HcalDbHardcode::makeMCParam(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

780  {
781  // std::cout << std::endl << " .... HcalHardcodeCalibrations::produceMCParams ->"<< std::endl;
782 
783  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceMCParams-> ...";
784  auto const& topo = rec.get(topoTokens_[kMCParams]);
785  auto result = std::make_unique<HcalMCParams>(&topo);
786  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
787  for (auto cell : cells) {
789  result->addValues(item);
790  }
791  return result;
792 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalMCParam makeMCParam(HcalGenericDetId fId) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ producePedestals()

std::unique_ptr< HcalPedestals > HcalHardcodeCalibrations::producePedestals ( const HcalPedestalsRcd rcd)
protected

Definition at line 383 of file HcalHardcodeCalibrations.cc.

References kPedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

383  {
384  return producePedestals_(rec, topoTokens_[kPedestals], false);
385 }
std::unique_ptr< HcalPedestals > producePedestals_(const HcalPedestalsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ producePedestals_()

std::unique_ptr< HcalPedestals > HcalHardcodeCalibrations::producePedestals_ ( const HcalPedestalsRcd rcd,
const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &  token,
bool  eff 
)
protected

Definition at line 354 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), iLumi, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), HcalDbHardcode::makePedestal(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and unpackBuffers-CaloStage2::token.

Referenced by produceEffectivePedestals(), and producePedestals().

355  {
356  std::string seff = eff ? "Effective" : "";
357  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "Pedestals-> ...";
358 
359  auto const& topo = rec.get(token);
360  auto result = std::make_unique<HcalPedestals>(&topo, false);
361  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
362  for (auto cell : cells) {
363  HcalPedestal item = dbHardcode.makePedestal(cell, false, eff, &topo, iLumi);
364  result->addValues(item);
365  }
366  return result;
367 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalPedestal makePedestal(HcalGenericDetId fId, bool fSmear, bool eff, const HcalTopology *topo, double intlumi)

◆ producePedestalWidths()

std::unique_ptr< HcalPedestalWidths > HcalHardcodeCalibrations::producePedestalWidths ( const HcalPedestalWidthsRcd rcd)
protected

Definition at line 391 of file HcalHardcodeCalibrations.cc.

References kPedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

391  {
393 }
std::unique_ptr< HcalPedestalWidths > producePedestalWidths_(const HcalPedestalWidthsRcd &rcd, const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &, bool eff)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ producePedestalWidths_()

std::unique_ptr< HcalPedestalWidths > HcalHardcodeCalibrations::producePedestalWidths_ ( const HcalPedestalWidthsRcd rcd,
const edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > &  token,
bool  eff 
)
protected

Definition at line 369 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), iLumi, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), HcalDbHardcode::makePedestalWidth(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and unpackBuffers-CaloStage2::token.

Referenced by produceEffectivePedestalWidths(), and producePedestalWidths().

370  {
371  std::string seff = eff ? "Effective" : "";
372  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "PedestalWidths-> ...";
373  auto const& topo = rec.get(token);
374  auto result = std::make_unique<HcalPedestalWidths>(&topo, false);
375  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
376  for (auto cell : cells) {
378  result->addValues(item);
379  }
380  return result;
381 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalPedestalWidth makePedestalWidth(HcalGenericDetId fId, bool eff, const HcalTopology *topo, double intlumi)

◆ producePFCorrs()

std::unique_ptr< HcalPFCorrs > HcalHardcodeCalibrations::producePFCorrs ( const HcalPFCorrsRcd rcd)
protected

Definition at line 601 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kPFCorrs, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

601  {
602  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCorrs-> ...";
603  auto const& topo = rcd.get(topoTokens_[kPFCorrs]);
604 
605  auto result = std::make_unique<HcalPFCorrs>(&topo);
606  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
607  for (auto cell : cells) {
608  HcalPFCorr item(cell.rawId(), 1.0);
609  result->addValues(item);
610  }
611  return result;
612 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ producePFCuts()

std::unique_ptr< HcalPFCuts > HcalHardcodeCalibrations::producePFCuts ( const HcalPFCutsRcd rcd)
protected

Definition at line 432 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kPFCuts, HcalDbHardcode::makePFCut(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

432  {
433  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCuts-> ...";
434 
435  auto const& topo = rec.get(topoTokens_[kPFCuts]);
436  auto result = std::make_unique<HcalPFCuts>(&topo);
437  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
438  for (auto cell : cells) {
439  // Use only standard Hcal channels for now, no TrigPrims
440  if (!cell.isHcalTrigTowerDetId()) {
442  result->addValues(item);
443  }
444  }
445  return result;
446 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalPFCut makePFCut(HcalGenericDetId fId) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceQIEData()

std::unique_ptr< HcalQIEData > HcalHardcodeCalibrations::produceQIEData ( const HcalQIEDataRcd rcd)
protected

Definition at line 448 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), HcalDbHardcode::killHE(), kQIEData, HcalDbHardcode::makeQIECoder(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

448  {
449  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
450 
451  /*
452  std::cout << std::endl << ">>> HcalHardcodeCalibrations::produceQIEData"
453  << std::endl;
454  */
455 
456  auto const& topo = rcd.get(topoTokens_[kQIEData]);
457  auto result = std::make_unique<HcalQIEData>(&topo);
458  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
459  for (auto cell : cells) {
460  HcalQIECoder coder = dbHardcode.makeQIECoder(cell);
461  result->addCoder(coder);
462  }
463  return result;
464 }
const bool killHE() const
HcalQIECoder makeQIECoder(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceQIETypes()

std::unique_ptr< HcalQIETypes > HcalHardcodeCalibrations::produceQIETypes ( const HcalQIETypesRcd rcd)
protected

Definition at line 466 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kQIETypes, HcalDbHardcode::makeQIEType(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

466  {
467  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIETypes-> ...";
468  auto const& topo = rcd.get(topoTokens_[kQIETypes]);
469 
470  auto result = std::make_unique<HcalQIETypes>(&topo);
471  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
472  for (auto cell : cells) {
474  result->addValues(item);
475  }
476  return result;
477 }
const bool killHE() const
HcalQIEType makeQIEType(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceRecoParams()

std::unique_ptr< HcalRecoParams > HcalHardcodeCalibrations::produceRecoParams ( const HcalRecoParamsRcd rcd)
protected

Definition at line 717 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kRecoParams, HcalDbHardcode::makeRecoParam(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

717  {
718  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRecoParams-> ...";
719  auto const& topo = rec.get(topoTokens_[kRecoParams]);
720 
721  auto result = std::make_unique<HcalRecoParams>(&topo);
722  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
723  for (auto cell : cells) {
725  result->addValues(item);
726  }
727  return result;
728 }
HcalRecoParam makeRecoParam(HcalGenericDetId fId) const
const bool killHE() const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceRespCorrs()

std::unique_ptr< HcalRespCorrs > HcalHardcodeCalibrations::produceRespCorrs ( const HcalRespCorrsRcd rcd)
protected

Definition at line 518 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, alignCSCRings::corr, gather_cfg::cout, dbHardcode, hcalRecHitTable_cff::depth, HcalDetId::depth(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), HcalDbHardcode::getLayersInDepth(), hb_recalibration, hbDarkeningToken_, HcalGenericDetId::HcalGenBarrel, HcalGenericDetId::HcalGenEndcap, HcalGenericDetId::HcalGenForward, he_recalibration, heDarkeningToken_, hf_recalibration, mps_fire::i, HcalDetId::ieta(), iLumi, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kRespCorrs, razorScouting_cff::maxEta, mps_fire::result, setHBdsegm, setHEdsegm, topoTokens_, and useLayer0Weight.

Referenced by HcalHardcodeCalibrations().

518  {
519  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
520  auto const& topo = rcd.get(topoTokens_[kRespCorrs]);
521 
522  //set depth segmentation for HB/HE recalib - only happens once
524  std::vector<std::vector<int>> m_segmentation;
525  int maxEta = topo.lastHBHERing();
526  m_segmentation.resize(maxEta);
527  for (int i = 0; i < maxEta; i++) {
528  topo.getDepthSegmentation(i + 1, m_segmentation[i]);
529  }
530  if (he_recalibration && !setHEdsegm) {
531  he_recalibration->setup(m_segmentation, &rcd.get(heDarkeningToken_));
532  setHEdsegm = true;
533  }
534  if (hb_recalibration && !setHBdsegm) {
535  hb_recalibration->setup(m_segmentation, &rcd.get(hbDarkeningToken_));
536  setHBdsegm = true;
537  }
538  }
539 
540  auto result = std::make_unique<HcalRespCorrs>(&topo);
541  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
542  for (const auto& cell : cells) {
543  double corr = 1.0;
544 
545  //check for layer 0 reweighting: when depth 1 has only one layer, it is layer 0
546  if (useLayer0Weight &&
547  ((cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap) ||
548  (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) &&
549  (HcalDetId(cell).depth() == 1 &&
550  dbHardcode.getLayersInDepth(HcalDetId(cell).ietaAbs(), HcalDetId(cell).depth(), &topo) == 1)) {
551  //layer 0 is thicker than other layers (9mm vs 3.7mm) and brighter (Bicron vs SCSN81)
552  //in Run1/Run2 (pre-2017 for HE), ODU for layer 0 had neutral density filter attached
553  //NDF was simulated as weight of 0.5 applied to Geant energy deposits
554  //for Phase1, NDF is removed - simulated as weight of 1.2 applied to Geant energy deposits
555  //to maintain RECO calibrations, move the layer 0 energy scale back to its previous state using respcorrs
556  corr = 0.5 / 1.2;
557  }
558 
559  if ((hb_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
560  int depth_ = HcalDetId(cell).depth();
561  int ieta_ = HcalDetId(cell).ieta();
562  corr *= hb_recalibration->getCorr(ieta_, depth_);
563 #ifdef DebugLog
564  std::cout << "HB ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
565 #endif
566  } else if ((he_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
567  int depth_ = HcalDetId(cell).depth();
568  int ieta_ = HcalDetId(cell).ieta();
569  corr *= he_recalibration->getCorr(ieta_, depth_);
570 #ifdef DebugLog
571  std::cout << "HE ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
572 #endif
573  } else if ((hf_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenForward)) {
574  int depth_ = HcalDetId(cell).depth();
575  int ieta_ = HcalDetId(cell).ieta();
576  corr = hf_recalibration->getCorr(ieta_, depth_, iLumi);
577 #ifdef DebugLog
578  std::cout << "HF ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
579 #endif
580  }
581 
582  HcalRespCorr item(cell.rawId(), corr);
583  result->addValues(item);
584  }
585  return result;
586 }
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > hbDarkeningToken_
const bool killHE() const
std::unique_ptr< HFRecalibration > hf_recalibration
dictionary corr
constexpr int ieta() const
get the cell ieta
Definition: HcalDetId.h:155
std::unique_ptr< HBHERecalibration > hb_recalibration
std::unique_ptr< HBHERecalibration > he_recalibration
Log< level::Info, false > LogInfo
int getLayersInDepth(int ieta, int depth, const HcalTopology *topo)
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > heDarkeningToken_
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_
constexpr int depth() const
get the tower depth
Definition: HcalDetId.h:164

◆ produceSiPMCharacteristics()

std::unique_ptr< HcalSiPMCharacteristics > HcalHardcodeCalibrations::produceSiPMCharacteristics ( const HcalSiPMCharacteristicsRcd rcd)
protected

Definition at line 842 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeSiPMCharacteristics().

Referenced by HcalHardcodeCalibrations().

843  {
844  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
845 
847 }
std::unique_ptr< HcalSiPMCharacteristics > makeHardcodeSiPMCharacteristics() const
Log< level::Info, false > LogInfo

◆ produceSiPMParameters()

std::unique_ptr< HcalSiPMParameters > HcalHardcodeCalibrations::produceSiPMParameters ( const HcalSiPMParametersRcd rcd)
protected

Definition at line 829 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), iLumi, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kSiPMParameters, HcalDbHardcode::makeHardcodeSiPMParameter(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

829  {
830  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMParameters-> ...";
831  auto const& topo = rec.get(topoTokens_[kSiPMParameters]);
832 
833  auto result = std::make_unique<HcalSiPMParameters>(&topo);
834  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
835  for (auto cell : cells) {
837  result->addValues(item);
838  }
839  return result;
840 }
const bool killHE() const
Log< level::Info, false > LogInfo
HcalSiPMParameter makeHardcodeSiPMParameter(HcalGenericDetId fId, const HcalTopology *topo, double intlumi)
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTimeCorrs()

std::unique_ptr< HcalTimeCorrs > HcalHardcodeCalibrations::produceTimeCorrs ( const HcalTimeCorrsRcd rcd)
protected

Definition at line 614 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kTimeCorrs, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

614  {
615  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimeCorrs-> ...";
616  auto const& topo = rcd.get(topoTokens_[kTimeCorrs]);
617 
618  auto result = std::make_unique<HcalTimeCorrs>(&topo);
619  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
620  for (auto cell : cells) {
621  HcalTimeCorr item(cell.rawId(), 0.0);
622  result->addValues(item);
623  }
624  return result;
625 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTimingParams()

std::unique_ptr< HcalTimingParams > HcalHardcodeCalibrations::produceTimingParams ( const HcalTimingParamsRcd rcd)
protected

Definition at line 730 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kTimingParams, HcalDbHardcode::makeTimingParam(), mps_fire::result, and topoTokens_.

730  {
731  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimingParams-> ...";
732  auto const& topo = rec.get(topoTokens_[kTimingParams]);
733 
734  auto result = std::make_unique<HcalTimingParams>(&topo);
735  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
736  for (auto cell : cells) {
738  result->addValues(item);
739  }
740  return result;
741 }
const bool killHE() const
HcalTimingParam makeTimingParam(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTPChannelParameters()

std::unique_ptr< HcalTPChannelParameters > HcalHardcodeCalibrations::produceTPChannelParameters ( const HcalTPChannelParametersRcd rcd)
protected

Definition at line 849 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), HcalTriggerTower, B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kTPChannelParameters, HcalDbHardcode::makeHardcodeTPChannelParameter(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

850  {
851  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
852  auto const& topo = rec.get(topoTokens_[kTPChannelParameters]);
853 
854  auto result = std::make_unique<HcalTPChannelParameters>(&topo);
855  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
856  for (auto cell : cells) {
857  // Thinking about Phase2 and the new FIR filter,
858  // for now, don't put TT in TPChannelParams
859  if (cell.subdetId() == HcalTriggerTower)
860  continue;
862  result->addValues(item);
863  }
864  return result;
865 }
const bool killHE() const
HcalTPChannelParameter makeHardcodeTPChannelParameter(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTPParameters()

std::unique_ptr< HcalTPParameters > HcalHardcodeCalibrations::produceTPParameters ( const HcalTPParametersRcd rcd)
protected

Definition at line 867 of file HcalHardcodeCalibrations.cc.

References dbHardcode, HcalDbHardcode::makeHardcodeTPParameters(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

867  {
868  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPParameters-> ...";
869 
870  auto result = std::make_unique<HcalTPParameters>();
872  return result;
873 }
Log< level::Info, false > LogInfo
void makeHardcodeTPParameters(HcalTPParameters &tppar) const

◆ produceValidationCorrs()

std::unique_ptr< HcalValidationCorrs > HcalHardcodeCalibrations::produceValidationCorrs ( const HcalValidationCorrsRcd rcd)
protected

Definition at line 665 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kValidationCorrs, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

666  {
667  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceValidationCorrs-> ...";
668  auto const& topo = rcd.get(topoTokens_[kValidationCorrs]);
669 
670  auto result = std::make_unique<HcalValidationCorrs>(&topo);
671  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
672  for (auto cell : cells) {
673  HcalValidationCorr item(cell.rawId(), 1.0);
674  result->addValues(item);
675  }
676  return result;
677 }
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceZDCLowGainFractions()

std::unique_ptr< HcalZDCLowGainFractions > HcalHardcodeCalibrations::produceZDCLowGainFractions ( const HcalZDCLowGainFractionsRcd rcd)
protected

Definition at line 766 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kZDCLowGainFractions, mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

767  {
768  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZDCLowGainFractions-> ...";
769  auto const& topo = rec.get(topoTokens_[kZDCLowGainFractions]);
770 
771  auto result = std::make_unique<HcalZDCLowGainFractions>(&topo);
772  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
773  for (auto cell : cells) {
774  HcalZDCLowGainFraction item(cell.rawId(), 0.0);
775  result->addValues(item);
776  }
777  return result;
778 }
const bool killHE() const
Log< level::Info, false > LogInfo
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceZSThresholds()

std::unique_ptr< HcalZSThresholds > HcalHardcodeCalibrations::produceZSThresholds ( const HcalZSThresholdsRcd rcd)
protected

Definition at line 627 of file HcalHardcodeCalibrations.cc.

References hgcalTBTopologyTester_cfi::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kZSThresholds, HcalDbHardcode::makeZSThreshold(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

627  {
628  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZSThresholds-> ...";
629  auto const& topo = rcd.get(topoTokens_[kZSThresholds]);
630 
631  auto result = std::make_unique<HcalZSThresholds>(&topo);
632  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
633  for (auto cell : cells) {
635  result->addValues(item);
636  }
637  return result;
638 }
HcalZSThreshold makeZSThreshold(HcalGenericDetId fId) const
const bool killHE() const
Log< level::Info, false > LogInfo
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ setIntervalFor()

void HcalHardcodeCalibrations::setIntervalFor ( const edm::eventsetup::EventSetupRecordKey iKey,
const edm::IOVSyncValue iTime,
edm::ValidityInterval oInterval 
)
overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 345 of file HcalHardcodeCalibrations.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), edm::IOVSyncValue::eventID(), edm::eventsetup::EventSetupRecordKey::name(), AlCaHarvesting_cff::record, AlCaHLTBitMon_QueryRunRegistry::string, edm::IOVSyncValue::time(), and edm::Timestamp::value().

347  {
348  std::string record = iKey.name();
349  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::setIntervalFor-> key: " << record << " time: " << iTime.eventID()
350  << '/' << iTime.time().value();
352 }
static const IOVSyncValue & endOfTime()
Definition: IOVSyncValue.cc:82
std::pair< Time_t, Time_t > ValidityInterval
Definition: Time.h:17
static const IOVSyncValue & beginOfTime()
Definition: IOVSyncValue.cc:88
Log< level::Info, false > LogInfo
TimeValue_t value() const
Definition: Timestamp.h:38
const EventID & eventID() const
Definition: IOVSyncValue.h:40
const Timestamp & time() const
Definition: IOVSyncValue.h:42

Member Data Documentation

◆ dbHardcode

HcalDbHardcode HcalHardcodeCalibrations::dbHardcode
private

◆ hb_recalibration

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::hb_recalibration
private

Definition at line 146 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hbDarkeningToken_

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalHardcodeCalibrations::hbDarkeningToken_
private

Definition at line 151 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ he_recalibration

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::he_recalibration
private

Definition at line 147 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ heDarkeningToken_

edm::ESGetToken<HBHEDarkening, HBHEDarkeningRecord> HcalHardcodeCalibrations::heDarkeningToken_
private

Definition at line 150 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hf_recalibration

std::unique_ptr<HFRecalibration> HcalHardcodeCalibrations::hf_recalibration
private

Definition at line 148 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ iLumi

double HcalHardcodeCalibrations::iLumi
private

◆ setHBdsegm

bool HcalHardcodeCalibrations::setHBdsegm
private

Definition at line 154 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ setHEdsegm

bool HcalHardcodeCalibrations::setHEdsegm
private

Definition at line 153 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ switchGainWidthsForTrigPrims

bool HcalHardcodeCalibrations::switchGainWidthsForTrigPrims
private

Definition at line 152 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceGainWidths().

◆ testHEPlan1

bool HcalHardcodeCalibrations::testHEPlan1
private

Definition at line 157 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

◆ topoTokens_

std::unordered_map<int, edm::ESGetToken<HcalTopology, HcalRecNumberingRecord> > HcalHardcodeCalibrations::topoTokens_
private

◆ useIeta18depth1

bool HcalHardcodeCalibrations::useIeta18depth1
private

Definition at line 156 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

◆ useLayer0Weight

bool HcalHardcodeCalibrations::useLayer0Weight
private

Definition at line 155 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().