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::ESProxyFactoryProducer edm::eventsetup::DataProxyProvider

Public Member Functions

 HcalHardcodeCalibrations (const edm::ParameterSet &)
 
 ~HcalHardcodeCalibrations () override
 
- Public Member Functions inherited from edm::ESProducer
 ESProducer ()
 
 ESProducer (const ESProducer &)=delete
 
ESProxyIndex const * getTokenIndices (unsigned int iIndex) const
 
ESRecordIndex const * getTokenRecordIndices (unsigned int iIndex) const
 
bool hasMayConsumes () const noexcept
 
size_t numberOfTokenIndices (unsigned int iIndex) const
 
ESProducer const & operator= (const ESProducer &)=delete
 
SerialTaskQueueChainqueue ()
 
template<typename Record >
std::optional< std::vector< ESProxyIndex > > updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &) final
 
 ~ESProducer () noexcept(false) override
 
- Public Member Functions inherited from edm::ESProxyFactoryProducer
 ESProxyFactoryProducer ()
 
 ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete
 
const ESProxyFactoryProduceroperator= (const ESProxyFactoryProducer &)=delete
 
 ~ESProxyFactoryProducer () noexcept(false) override
 
- Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
 
 DataProxyProvider ()
 
 DataProxyProvider (const DataProxyProvider &)=delete
 
const ComponentDescriptiondescription () const
 
void fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
 
virtual void initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
 
bool isUsingRecord (const EventSetupRecordKey &key) const
 
KeyedProxieskeyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
 
const DataProxyProvideroperator= (const DataProxyProvider &)=delete
 
void setAppendToDataLabel (const edm::ParameterSet &)
 
void setDescription (const ComponentDescription &iDescription)
 
std::set< EventSetupRecordKeyusingRecords () const
 
virtual ~DataProxyProvider () 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::DataProxyProvider
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< 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
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 TArg >
ESConsumesCollectorT< TRecord > setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})
 
void usesResources (std::vector< std::string > const &)
 
- Protected Member Functions inherited from edm::ESProxyFactoryProducer
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::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())
 
KeyedProxiesVector registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override
 
- Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
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, 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::ESProxyFactoryProducer
using EventSetupRecordKey = eventsetup::EventSetupRecordKey
 
- Protected Types inherited from edm::eventsetup::DataProxyProvider
using KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>
 

Detailed Description

Definition at line 56 of file HcalHardcodeCalibrations.h.

Member Enumeration Documentation

◆ anonymous enum

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

Definition at line 112 of file HcalHardcodeCalibrations.h.

112  {
113  kPedestals,
117  kGains,
118  kGainWidths,
119  kQIEData,
120  kQIETypes,
122  kRespCorrs,
123  kLUTCorrs,
124  kPFCorrs,
125  kTimeCorrs,
130  kLutMetadata,
131  kRecoParams,
135  kMCParams,
137  kFrontEndMap,
140  };

Constructor & Destructor Documentation

◆ HcalHardcodeCalibrations()

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

Definition at line 130 of file HcalHardcodeCalibrations.cc.

References python.cmstools::all(), 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, 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(), 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 == "QIEData") || all) {
227  findingRecord<HcalQIEDataRcd>();
228  }
229  if ((objectName == "QIETypes") || all) {
231  findingRecord<HcalQIETypesRcd>();
232  }
233  if ((objectName == "ChannelQuality") || (objectName == "channelQuality") || all) {
235  findingRecord<HcalChannelQualityRcd>();
236  }
237  if ((objectName == "ElectronicsMap") || (objectName == "electronicsMap") || all) {
239  findingRecord<HcalElectronicsMapRcd>();
240  }
241  if ((objectName == "ZSThresholds") || (objectName == "zsThresholds") || all) {
243  findingRecord<HcalZSThresholdsRcd>();
244  }
245  if ((objectName == "RespCorrs") || (objectName == "ResponseCorrection") || all) {
247  topoTokens_[kRespCorrs] = c.consumes();
248  if (he_recalibration) {
249  heDarkeningToken_ = c.consumes(edm::ESInputTag("", "HE"));
250  }
251  if (hb_recalibration) {
252  hbDarkeningToken_ = c.consumes(edm::ESInputTag("", "HB"));
253  }
254  findingRecord<HcalRespCorrsRcd>();
255  }
256  if ((objectName == "LUTCorrs") || (objectName == "LUTCorrection") || all) {
258  findingRecord<HcalLUTCorrsRcd>();
259  }
260  if ((objectName == "PFCorrs") || (objectName == "PFCorrection") || all) {
262  findingRecord<HcalPFCorrsRcd>();
263  }
264  if ((objectName == "TimeCorrs") || (objectName == "TimeCorrection") || all) {
266  findingRecord<HcalTimeCorrsRcd>();
267  }
268  if ((objectName == "L1TriggerObjects") || (objectName == "L1Trigger") || all) {
271  findingRecord<HcalL1TriggerObjectsRcd>();
272  }
273  if ((objectName == "ValidationCorrs") || (objectName == "ValidationCorrection") || all) {
276  findingRecord<HcalValidationCorrsRcd>();
277  }
278  if ((objectName == "LutMetadata") || (objectName == "lutMetadata") || all) {
280  findingRecord<HcalLutMetadataRcd>();
281  }
282  if ((objectName == "DcsValues") || all) {
284  findingRecord<HcalDcsRcd>();
285  }
286  if ((objectName == "DcsMap") || (objectName == "dcsMap") || all) {
288  findingRecord<HcalDcsMapRcd>();
289  }
290  if ((objectName == "RecoParams") || all) {
292  findingRecord<HcalRecoParamsRcd>();
293  }
294  if ((objectName == "LongRecoParams") || all) {
296  findingRecord<HcalLongRecoParamsRcd>();
297  }
298  if ((objectName == "ZDCLowGainFractions") || all) {
301  findingRecord<HcalZDCLowGainFractionsRcd>();
302  }
303  if ((objectName == "MCParams") || all) {
305  findingRecord<HcalMCParamsRcd>();
306  }
307  if ((objectName == "FlagHFDigiTimeParams") || all) {
310  findingRecord<HcalFlagHFDigiTimeParamsRcd>();
311  }
312  if ((objectName == "FrontEndMap") || (objectName == "frontEndMap") || all) {
314  findingRecord<HcalFrontEndMapRcd>();
315  }
316  if ((objectName == "SiPMParameters") || all) {
318  findingRecord<HcalSiPMParametersRcd>();
319  }
320  if ((objectName == "SiPMCharacteristics") || all) {
322  findingRecord<HcalSiPMCharacteristicsRcd>();
323  }
324  if ((objectName == "TPChannelParameters") || all) {
327  findingRecord<HcalTPChannelParametersRcd>();
328  }
329  if ((objectName == "TPParameters") || all) {
331  findingRecord<HcalTPParametersRcd>();
332  }
333  }
334 }
std::unique_ptr< HcalPedestals > producePedestals(const HcalPedestalsRcd &rcd)
auto setWhatProduced(T *iThis, const es::Label &iLabel={})
Definition: ESProducer.h:163
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 336 of file HcalHardcodeCalibrations.cc.

336 {}

Member Function Documentation

◆ fillDescriptions()

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

Definition at line 855 of file HcalHardcodeCalibrations.cc.

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

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

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

Referenced by HcalHardcodeCalibrations().

459  {
460  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
461  auto const& topo = rcd.get(topoTokens_[kChannelQuality]);
462 
463  auto result = std::make_unique<HcalChannelQuality>(&topo);
464  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
465  for (auto cell : cells) {
466  // Special: removal of (non-instrumented) layer "-1"("nose") = depth 1
467  // from Upgrade HE, either from
468  // (i) HEP17 sector in 2017 or
469  // (ii) the entire HE rin=18 from 2018 through Run 3.
470  // May require a revision by 2021.
471 
472  uint32_t status = 0;
473 
474  if (!(cell.isHcalZDCDetId())) {
475  HcalDetId hid = HcalDetId(cell);
476  int iphi = hid.iphi();
477  int ieta = hid.ieta();
478  int absieta = hid.ietaAbs();
479  int depth = hid.depth();
480 
481  // specific HEP17 sector (2017 only)
482  bool isHEP17 = (iphi >= 63) && (iphi <= 66) && (ieta > 0);
483  // |ieta|=18, depth=1
484  bool is18d1 = (absieta == 18) && (depth == 1);
485 
486  if ((!useIeta18depth1 && is18d1) && ((testHEPlan1 && isHEP17) || (!testHEPlan1))) {
487  status = 0x8002; // dead cell
488  }
489  }
490 
491  HcalChannelStatus item(cell.rawId(), status);
492  result->addValues(item);
493  }
494 
495  return result;
496 }
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
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 691 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeDcsMap().

Referenced by HcalHardcodeCalibrations().

691  {
692  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
693 
695 }
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 685 of file HcalHardcodeCalibrations.cc.

References mps_fire::result.

Referenced by HcalHardcodeCalibrations().

685  {
686  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsValues-> ...";
687  auto result = std::make_unique<HcalDcsValues>();
688  return result;
689 }
Log< level::Info, false > LogInfo

◆ produceEffectivePedestals()

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

Definition at line 383 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

383  {
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_

◆ produceEffectivePedestalWidths()

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

Definition at line 391 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

392  {
394 }
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 637 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

637  {
638  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceElectronicsMap-> ...";
639  auto const& topo = rcd.get(topoTokens_[kElectronicsMap]);
640 
641  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
643 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 774 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

775  {
776  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
777  auto const& topo = rec.get(topoTokens_[kFlagHFDigiTimeParams]);
778 
779  auto result = std::make_unique<HcalFlagHFDigiTimeParams>(&topo);
780  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
781 
782  std::vector<double> coef;
783  coef.push_back(0.93);
784  coef.push_back(-0.38275);
785  coef.push_back(-0.012667);
786 
787  for (auto cell : cells) {
788  HcalFlagHFDigiTimeParam item(cell.rawId(),
789  1, //firstsample
790  3, // samplestoadd
791  2, //expectedpeak
792  40., // min energy threshold
793  coef // coefficients
794  );
795  result->addValues(item);
796  }
797  return result;
798 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceFrontEndMap()

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

Definition at line 800 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

800  {
801  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFrontEndMap-> ...";
802  auto const& topo = rec.get(topoTokens_[kFrontEndMap]);
803 
804  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
805 
807 }
void makeHardcodeFrontEndMap(HcalFrontEndMap &emap, const std::vector< HcalGenericDetId > &cells) const
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceGains()

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

Definition at line 396 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

396  {
397  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGains-> ...";
398 
399  auto const& topo = rec.get(topoTokens_[kGains]);
400  auto result = std::make_unique<HcalGains>(&topo);
401  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
402  for (auto cell : cells) {
404  result->addValues(item);
405  }
406  return result;
407 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 409 of file HcalHardcodeCalibrations.cc.

References 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().

409  {
410  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
411 
412  auto const& topo = rec.get(topoTokens_[kGainWidths]);
413  auto result = std::make_unique<HcalGainWidths>(&topo);
414  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
415  for (auto cell : cells) {
416  // for Upgrade - include TrigPrims, for regular case - only HcalDetId
419  result->addValues(item);
420  } else if (!cell.isHcalTrigTowerDetId()) {
422  result->addValues(item);
423  }
424  }
425  return result;
426 }
const bool killHE() const
HcalGainWidth makeGainWidth(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceL1TriggerObjects()

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

Definition at line 620 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

621  {
622  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
623  auto const& topo = rcd.get(topoTokens_[kL1TriggerObjects]);
624 
625  auto result = std::make_unique<HcalL1TriggerObjects>(&topo);
626  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
627  for (auto cell : cells) {
628  HcalL1TriggerObject item(cell.rawId(), 0., 1., 0);
629  result->addValues(item);
630  }
631  // add tag and algo values
632  result->setTagString("hardcoded");
633  result->setAlgoString("hardcoded");
634  return result;
635 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 723 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

723  {
724  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
725  auto const& topo = rec.get(topoTokens_[kLongRecoParams]);
726 
727  auto result = std::make_unique<HcalLongRecoParams>(&topo);
728  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
729  std::vector<unsigned int> mSignal;
730  mSignal.push_back(4);
731  mSignal.push_back(5);
732  mSignal.push_back(6);
733  std::vector<unsigned int> mNoise;
734  mNoise.push_back(1);
735  mNoise.push_back(2);
736  mNoise.push_back(3);
737  for (auto cell : cells) {
738  if (cell.isHcalZDCDetId()) {
739  HcalLongRecoParam item(cell.rawId(), mSignal, mNoise);
740  result->addValues(item);
741  }
742  }
743  return result;
744 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceLUTCorrs()

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

Definition at line 568 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

568  {
569  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLUTCorrs-> ...";
570  auto const& topo = rcd.get(topoTokens_[kLUTCorrs]);
571 
572  auto result = std::make_unique<HcalLUTCorrs>(&topo);
573  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
574  for (auto cell : cells) {
575  HcalLUTCorr item(cell.rawId(), 1.0);
576  result->addValues(item);
577  }
578  return result;
579 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 659 of file HcalHardcodeCalibrations.cc.

References 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().

659  {
660  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
661  auto const& topo = rcd.get(topoTokens_[kLutMetadata]);
662 
663  auto result = std::make_unique<HcalLutMetadata>(&topo);
664 
665  result->setRctLsb(0.5);
666  result->setNominalGain(0.177); // for HBHE SiPMs
667 
668  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
669  for (const auto& cell : cells) {
670  float rcalib = 1.;
671  int granularity = 1;
672  int threshold = 0;
673 
674  if (cell.isHcalTrigTowerDetId()) {
675  rcalib = 0.;
676  }
677 
678  HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
679  result->addValues(item);
680  }
681 
682  return result;
683 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 760 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

760  {
761  // std::cout << std::endl << " .... HcalHardcodeCalibrations::produceMCParams ->"<< std::endl;
762 
763  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceMCParams-> ...";
764  auto const& topo = rec.get(topoTokens_[kMCParams]);
765  auto result = std::make_unique<HcalMCParams>(&topo);
766  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
767  for (auto cell : cells) {
769  result->addValues(item);
770  }
771  return result;
772 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 379 of file HcalHardcodeCalibrations.cc.

References kPedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

379  {
380  return producePedestals_(rec, topoTokens_[kPedestals], false);
381 }
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 350 of file HcalHardcodeCalibrations.cc.

References 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().

351  {
352  std::string seff = eff ? "Effective" : "";
353  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "Pedestals-> ...";
354 
355  auto const& topo = rec.get(token);
356  auto result = std::make_unique<HcalPedestals>(&topo, false);
357  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
358  for (auto cell : cells) {
359  HcalPedestal item = dbHardcode.makePedestal(cell, false, eff, &topo, iLumi);
360  result->addValues(item);
361  }
362  return result;
363 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 387 of file HcalHardcodeCalibrations.cc.

References kPedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

387  {
389 }
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 365 of file HcalHardcodeCalibrations.cc.

References 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().

366  {
367  std::string seff = eff ? "Effective" : "";
368  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "PedestalWidths-> ...";
369  auto const& topo = rec.get(token);
370  auto result = std::make_unique<HcalPedestalWidths>(&topo, false);
371  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
372  for (auto cell : cells) {
374  result->addValues(item);
375  }
376  return result;
377 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 581 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

581  {
582  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCorrs-> ...";
583  auto const& topo = rcd.get(topoTokens_[kPFCorrs]);
584 
585  auto result = std::make_unique<HcalPFCorrs>(&topo);
586  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
587  for (auto cell : cells) {
588  HcalPFCorr item(cell.rawId(), 1.0);
589  result->addValues(item);
590  }
591  return result;
592 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
ProductT const & get(ESGetToken< ProductT, DepRecordT > const &iToken) const
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceQIEData()

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

Definition at line 428 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

428  {
429  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
430 
431  /*
432  std::cout << std::endl << ">>> HcalHardcodeCalibrations::produceQIEData"
433  << std::endl;
434  */
435 
436  auto const& topo = rcd.get(topoTokens_[kQIEData]);
437  auto result = std::make_unique<HcalQIEData>(&topo);
438  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
439  for (auto cell : cells) {
440  HcalQIECoder coder = dbHardcode.makeQIECoder(cell);
441  result->addCoder(coder);
442  }
443  return result;
444 }
const bool killHE() const
HcalQIECoder makeQIECoder(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 446 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

446  {
447  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIETypes-> ...";
448  auto const& topo = rcd.get(topoTokens_[kQIETypes]);
449 
450  auto result = std::make_unique<HcalQIETypes>(&topo);
451  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
452  for (auto cell : cells) {
454  result->addValues(item);
455  }
456  return result;
457 }
const bool killHE() const
HcalQIEType makeQIEType(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 697 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

697  {
698  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRecoParams-> ...";
699  auto const& topo = rec.get(topoTokens_[kRecoParams]);
700 
701  auto result = std::make_unique<HcalRecoParams>(&topo);
702  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
703  for (auto cell : cells) {
705  result->addValues(item);
706  }
707  return result;
708 }
HcalRecoParam makeRecoParam(HcalGenericDetId fId) const
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceRespCorrs()

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

Definition at line 498 of file HcalHardcodeCalibrations.cc.

References cells, alignCSCRings::corr, gather_cfg::cout, dbHardcode, LEDCalibrationChannels::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, maxEta, mps_fire::result, setHBdsegm, setHEdsegm, topoTokens_, and useLayer0Weight.

Referenced by HcalHardcodeCalibrations().

498  {
499  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
500  auto const& topo = rcd.get(topoTokens_[kRespCorrs]);
501 
502  //set depth segmentation for HB/HE recalib - only happens once
504  std::vector<std::vector<int>> m_segmentation;
505  int maxEta = topo.lastHBHERing();
506  m_segmentation.resize(maxEta);
507  for (int i = 0; i < maxEta; i++) {
508  topo.getDepthSegmentation(i + 1, m_segmentation[i]);
509  }
510  if (he_recalibration && !setHEdsegm) {
511  he_recalibration->setup(m_segmentation, &rcd.get(heDarkeningToken_));
512  setHEdsegm = true;
513  }
514  if (hb_recalibration && !setHBdsegm) {
515  hb_recalibration->setup(m_segmentation, &rcd.get(hbDarkeningToken_));
516  setHBdsegm = true;
517  }
518  }
519 
520  auto result = std::make_unique<HcalRespCorrs>(&topo);
521  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
522  for (const auto& cell : cells) {
523  double corr = 1.0;
524 
525  //check for layer 0 reweighting: when depth 1 has only one layer, it is layer 0
526  if (useLayer0Weight &&
527  ((cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap) ||
528  (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) &&
529  (HcalDetId(cell).depth() == 1 &&
530  dbHardcode.getLayersInDepth(HcalDetId(cell).ietaAbs(), HcalDetId(cell).depth(), &topo) == 1)) {
531  //layer 0 is thicker than other layers (9mm vs 3.7mm) and brighter (Bicron vs SCSN81)
532  //in Run1/Run2 (pre-2017 for HE), ODU for layer 0 had neutral density filter attached
533  //NDF was simulated as weight of 0.5 applied to Geant energy deposits
534  //for Phase1, NDF is removed - simulated as weight of 1.2 applied to Geant energy deposits
535  //to maintain RECO calibrations, move the layer 0 energy scale back to its previous state using respcorrs
536  corr = 0.5 / 1.2;
537  }
538 
539  if ((hb_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
540  int depth_ = HcalDetId(cell).depth();
541  int ieta_ = HcalDetId(cell).ieta();
542  corr *= hb_recalibration->getCorr(ieta_, depth_);
543 #ifdef DebugLog
544  std::cout << "HB ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
545 #endif
546  } else if ((he_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
547  int depth_ = HcalDetId(cell).depth();
548  int ieta_ = HcalDetId(cell).ieta();
549  corr *= he_recalibration->getCorr(ieta_, depth_);
550 #ifdef DebugLog
551  std::cout << "HE ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
552 #endif
553  } else if ((hf_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenForward)) {
554  int depth_ = HcalDetId(cell).depth();
555  int ieta_ = HcalDetId(cell).ieta();
556  corr = hf_recalibration->getCorr(ieta_, depth_, iLumi);
557 #ifdef DebugLog
558  std::cout << "HF ieta, depth = " << ieta_ << ", " << depth_ << " corr = " << corr << std::endl;
559 #endif
560  }
561 
562  HcalRespCorr item(cell.rawId(), corr);
563  result->addValues(item);
564  }
565  return result;
566 }
edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord > hbDarkeningToken_
double maxEta
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
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 822 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeSiPMCharacteristics().

Referenced by HcalHardcodeCalibrations().

823  {
824  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
825 
827 }
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 809 of file HcalHardcodeCalibrations.cc.

References 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().

809  {
810  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMParameters-> ...";
811  auto const& topo = rec.get(topoTokens_[kSiPMParameters]);
812 
813  auto result = std::make_unique<HcalSiPMParameters>(&topo);
814  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
815  for (auto cell : cells) {
817  result->addValues(item);
818  }
819  return result;
820 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 594 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

594  {
595  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimeCorrs-> ...";
596  auto const& topo = rcd.get(topoTokens_[kTimeCorrs]);
597 
598  auto result = std::make_unique<HcalTimeCorrs>(&topo);
599  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
600  for (auto cell : cells) {
601  HcalTimeCorr item(cell.rawId(), 0.0);
602  result->addValues(item);
603  }
604  return result;
605 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 710 of file HcalHardcodeCalibrations.cc.

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

710  {
711  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimingParams-> ...";
712  auto const& topo = rec.get(topoTokens_[kTimingParams]);
713 
714  auto result = std::make_unique<HcalTimingParams>(&topo);
715  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
716  for (auto cell : cells) {
718  result->addValues(item);
719  }
720  return result;
721 }
const bool killHE() const
HcalTimingParam makeTimingParam(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTPChannelParameters()

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

Definition at line 829 of file HcalHardcodeCalibrations.cc.

References 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().

830  {
831  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
832  auto const& topo = rec.get(topoTokens_[kTPChannelParameters]);
833 
834  auto result = std::make_unique<HcalTPChannelParameters>(&topo);
835  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
836  for (auto cell : cells) {
837  // Thinking about Phase2 and the new FIR filter,
838  // for now, don't put TT in TPChannelParams
839  if (cell.subdetId() == HcalTriggerTower)
840  continue;
842  result->addValues(item);
843  }
844  return result;
845 }
const bool killHE() const
HcalTPChannelParameter makeHardcodeTPChannelParameter(HcalGenericDetId fId) const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceTPParameters()

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

Definition at line 847 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

847  {
848  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPParameters-> ...";
849 
850  auto result = std::make_unique<HcalTPParameters>();
852  return result;
853 }
Log< level::Info, false > LogInfo
void makeHardcodeTPParameters(HcalTPParameters &tppar) const

◆ produceValidationCorrs()

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

Definition at line 645 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

646  {
647  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceValidationCorrs-> ...";
648  auto const& topo = rcd.get(topoTokens_[kValidationCorrs]);
649 
650  auto result = std::make_unique<HcalValidationCorrs>(&topo);
651  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
652  for (auto cell : cells) {
653  HcalValidationCorr item(cell.rawId(), 1.0);
654  result->addValues(item);
655  }
656  return result;
657 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 746 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

747  {
748  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZDCLowGainFractions-> ...";
749  auto const& topo = rec.get(topoTokens_[kZDCLowGainFractions]);
750 
751  auto result = std::make_unique<HcalZDCLowGainFractions>(&topo);
752  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
753  for (auto cell : cells) {
754  HcalZDCLowGainFraction item(cell.rawId(), 0.0);
755  result->addValues(item);
756  }
757  return result;
758 }
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
std::unordered_map< int, edm::ESGetToken< HcalTopology, HcalRecNumberingRecord > > topoTokens_

◆ produceZSThresholds()

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

Definition at line 607 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

607  {
608  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZSThresholds-> ...";
609  auto const& topo = rcd.get(topoTokens_[kZSThresholds]);
610 
611  auto result = std::make_unique<HcalZSThresholds>(&topo);
612  const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
613  for (auto cell : cells) {
615  result->addValues(item);
616  }
617  return result;
618 }
HcalZSThreshold makeZSThreshold(HcalGenericDetId fId) const
const bool killHE() const
Log< level::Info, false > LogInfo
caConstants::TupleMultiplicity const CAHitNtupletGeneratorKernelsGPU::HitToTuple const cms::cuda::AtomicPairCounter GPUCACell const *__restrict__ cells
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 341 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().

343  {
344  std::string record = iKey.name();
345  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::setIntervalFor-> key: " << record << " time: " << iTime.eventID()
346  << '/' << iTime.time().value();
348 }
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:45
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 143 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hbDarkeningToken_

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

Definition at line 148 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ he_recalibration

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

Definition at line 144 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ heDarkeningToken_

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

Definition at line 147 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hf_recalibration

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

Definition at line 145 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ iLumi

double HcalHardcodeCalibrations::iLumi
private

◆ setHBdsegm

bool HcalHardcodeCalibrations::setHBdsegm
private

Definition at line 151 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ setHEdsegm

bool HcalHardcodeCalibrations::setHEdsegm
private

Definition at line 150 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ switchGainWidthsForTrigPrims

bool HcalHardcodeCalibrations::switchGainWidthsForTrigPrims
private

Definition at line 149 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceGainWidths().

◆ testHEPlan1

bool HcalHardcodeCalibrations::testHEPlan1
private

Definition at line 154 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 153 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

◆ useLayer0Weight

bool HcalHardcodeCalibrations::useLayer0Weight
private

Definition at line 152 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().