#include <HcalHardcodeCalibrations.h>

Inheritance diagram for HcalHardcodeCalibrations:

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

ESProducer const &	operator= (const ESProducer &)=delete

template<typename Record >
void	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final

	~ESProducer () noexcept(false) override

Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()

	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete

const ESProxyFactoryProducer &	operator= (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 ComponentDescription &	description () const

void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const

virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const DataProxyProvider &	operator= (const DataProxyProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~DataProxyProvider () noexcept(false)

Public Member Functions inherited from edm::EventSetupRecordIntervalFinder
bool	concurrentFinder () const

const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

	EventSetupRecordIntervalFinder (const EventSetupRecordIntervalFinder &)=delete

std::set< eventsetup::EventSetupRecordKey >	findingForRecords () const

const ValidityInterval &	findIntervalFor (const eventsetup::EventSetupRecordKey &, const IOVSyncValue &)

bool	nonconcurrentAndIOVNeedsUpdate (const eventsetup::EventSetupRecordKey &key, const IOVSyncValue &syncValue) const

const EventSetupRecordIntervalFinder &	operator= (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< HcalChannelQuality >	produceChannelQuality (const HcalChannelQualityRcd &rcd)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::unique_ptr< HcalZSThresholds >	produceZSThresholds (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 char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &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={})

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 Attributes
HcalDbHardcode	dbHardcode

std::unique_ptr< HBHERecalibration >	hb_recalibration

edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord >	hbDarkeningToken_

std::unique_ptr< HBHERecalibration >	he_recalibration

edm::ESGetToken< HBHEDarkening, HBHEDarkeningRecord >	heDarkeningToken_

std::unique_ptr< HFRecalibration >	hf_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.

        {
     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
   };

Constructor & Destructor Documentation

◆ HcalHardcodeCalibrations()

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

Definition at line 131 of file HcalHardcodeCalibrations.cc.

     : hb_recalibration(nullptr),
       he_recalibration(nullptr),
       hf_recalibration(nullptr),
       setHEdsegm(false),
       setHBdsegm(false) {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
  
   if (iConfig.exists("GainWidthsForTrigPrims"))
     switchGainWidthsForTrigPrims = iConfig.getParameter<bool>("GainWidthsForTrigPrims");
   else
     switchGainWidthsForTrigPrims = false;
  
   //DB helper preparation
   dbHardcode.setHB(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hb")));
   dbHardcode.setHE(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("he")));
   dbHardcode.setHF(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hf")));
   dbHardcode.setHO(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("ho")));
   dbHardcode.setHBUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hbUpgrade")));
   dbHardcode.setHEUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("heUpgrade")));
   dbHardcode.setHFUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hfUpgrade")));
   dbHardcode.useHBUpgrade(iConfig.getParameter<bool>("useHBUpgrade"));
   dbHardcode.useHEUpgrade(iConfig.getParameter<bool>("useHEUpgrade"));
   dbHardcode.useHFUpgrade(iConfig.getParameter<bool>("useHFUpgrade"));
   dbHardcode.useHOUpgrade(iConfig.getParameter<bool>("useHOUpgrade"));
   dbHardcode.testHFQIE10(iConfig.getParameter<bool>("testHFQIE10"));
   dbHardcode.testHEPlan1(iConfig.getParameter<bool>("testHEPlan1"));
   dbHardcode.setKillHE(iConfig.getParameter<bool>("killHE"));
   dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));
  
   useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
   useIeta18depth1 = iConfig.getParameter<bool>("useIeta18depth1");
   testHEPlan1 = iConfig.getParameter<bool>("testHEPlan1");
   // HB, HE, HF recalibration preparation
   iLumi = iConfig.getParameter<double>("iLumi");
  
   if (iLumi > 0.0) {
     bool hb_recalib = iConfig.getParameter<bool>("HBRecalibration");
     bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
     bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
     if (hb_recalib) {
       hb_recalibration.reset(new HBHERecalibration(iLumi,
                                                    iConfig.getParameter<double>("HBreCalibCutoff"),
                                                    iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath()));
     }
     if (he_recalib) {
       he_recalibration.reset(new HBHERecalibration(iLumi,
                                                    iConfig.getParameter<double>("HEreCalibCutoff"),
                                                    iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath()));
     }
     if (hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())
       hf_recalibration.reset(new HFRecalibration(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock")));
  
 #ifdef DebugLog
     std::cout << " HcalHardcodeCalibrations:  iLumi = " << iLumi << std::endl;
 #endif
   }
  
   std::vector<std::string> toGet = iConfig.getUntrackedParameter<std::vector<std::string>>("toGet");
   for (auto& objectName : toGet) {
     bool all = objectName == "all";
 #ifdef DebugLog
     std::cout << "Load parameters for " << objectName << std::endl;
 #endif
     if ((objectName == "Pedestals") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::producePedestals).setConsumes(topoTokens_[kPedestals]);
       findingRecord<HcalPedestalsRcd>();
     }
     if ((objectName == "PedestalWidths") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::producePedestalWidths).setConsumes(topoTokens_[kPedestalWidths]);
       findingRecord<HcalPedestalWidthsRcd>();
     }
     if ((objectName == "EffectivePedestals") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceEffectivePedestals, edm::es::Label("effective"))
           .setConsumes(topoTokens_[kEffectivePedestals]);
       findingRecord<HcalPedestalsRcd>();
     }
     if ((objectName == "EffectivePedestalWidths") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceEffectivePedestalWidths, edm::es::Label("effective"))
           .setConsumes(topoTokens_[kEffectivePedestalWidths]);
       findingRecord<HcalPedestalWidthsRcd>();
     }
     if ((objectName == "Gains") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceGains).setConsumes(topoTokens_[kGains]);
       findingRecord<HcalGainsRcd>();
     }
     if ((objectName == "GainWidths") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceGainWidths).setConsumes(topoTokens_[kGainWidths]);
       findingRecord<HcalGainWidthsRcd>();
     }
     if ((objectName == "QIEData") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceQIEData).setConsumes(topoTokens_[kQIEData]);
       findingRecord<HcalQIEDataRcd>();
     }
     if ((objectName == "QIETypes") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceQIETypes).setConsumes(topoTokens_[kQIETypes]);
       findingRecord<HcalQIETypesRcd>();
     }
     if ((objectName == "ChannelQuality") || (objectName == "channelQuality") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceChannelQuality).setConsumes(topoTokens_[kChannelQuality]);
       findingRecord<HcalChannelQualityRcd>();
     }
     if ((objectName == "ElectronicsMap") || (objectName == "electronicsMap") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceElectronicsMap).setConsumes(topoTokens_[kElectronicsMap]);
       findingRecord<HcalElectronicsMapRcd>();
     }
     if ((objectName == "ZSThresholds") || (objectName == "zsThresholds") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceZSThresholds).setConsumes(topoTokens_[kZSThresholds]);
       findingRecord<HcalZSThresholdsRcd>();
     }
     if ((objectName == "RespCorrs") || (objectName == "ResponseCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceRespCorrs);
       c.setConsumes(topoTokens_[kRespCorrs]);
       if (he_recalibration) {
         c.setConsumes(heDarkeningToken_, edm::ESInputTag("", "HE"));
       }
       if (hb_recalibration) {
         c.setConsumes(hbDarkeningToken_, edm::ESInputTag("", "HB"));
       }
       findingRecord<HcalRespCorrsRcd>();
     }
     if ((objectName == "LUTCorrs") || (objectName == "LUTCorrection") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceLUTCorrs).setConsumes(topoTokens_[kLUTCorrs]);
       findingRecord<HcalLUTCorrsRcd>();
     }
     if ((objectName == "PFCorrs") || (objectName == "PFCorrection") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::producePFCorrs).setConsumes(topoTokens_[kPFCorrs]);
       findingRecord<HcalPFCorrsRcd>();
     }
     if ((objectName == "TimeCorrs") || (objectName == "TimeCorrection") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceTimeCorrs).setConsumes(topoTokens_[kTimeCorrs]);
       findingRecord<HcalTimeCorrsRcd>();
     }
     if ((objectName == "L1TriggerObjects") || (objectName == "L1Trigger") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceL1TriggerObjects)
           .setConsumes(topoTokens_[kL1TriggerObjects]);
       findingRecord<HcalL1TriggerObjectsRcd>();
     }
     if ((objectName == "ValidationCorrs") || (objectName == "ValidationCorrection") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceValidationCorrs)
           .setConsumes(topoTokens_[kValidationCorrs]);
       findingRecord<HcalValidationCorrsRcd>();
     }
     if ((objectName == "LutMetadata") || (objectName == "lutMetadata") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceLutMetadata).setConsumes(topoTokens_[kLutMetadata]);
       findingRecord<HcalLutMetadataRcd>();
     }
     if ((objectName == "DcsValues") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceDcsValues);
       findingRecord<HcalDcsRcd>();
     }
     if ((objectName == "DcsMap") || (objectName == "dcsMap") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceDcsMap);
       findingRecord<HcalDcsMapRcd>();
     }
     if ((objectName == "RecoParams") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceRecoParams).setConsumes(topoTokens_[kRecoParams]);
       findingRecord<HcalRecoParamsRcd>();
     }
     if ((objectName == "LongRecoParams") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceLongRecoParams).setConsumes(topoTokens_[kLongRecoParams]);
       findingRecord<HcalLongRecoParamsRcd>();
     }
     if ((objectName == "ZDCLowGainFractions") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceZDCLowGainFractions)
           .setConsumes(topoTokens_[kZDCLowGainFractions]);
       findingRecord<HcalZDCLowGainFractionsRcd>();
     }
     if ((objectName == "MCParams") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceMCParams).setConsumes(topoTokens_[kMCParams]);
       findingRecord<HcalMCParamsRcd>();
     }
     if ((objectName == "FlagHFDigiTimeParams") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceFlagHFDigiTimeParams)
           .setConsumes(topoTokens_[kFlagHFDigiTimeParams]);
       findingRecord<HcalFlagHFDigiTimeParamsRcd>();
     }
     if ((objectName == "FrontEndMap") || (objectName == "frontEndMap") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceFrontEndMap).setConsumes(topoTokens_[kFrontEndMap]);
       findingRecord<HcalFrontEndMapRcd>();
     }
     if ((objectName == "SiPMParameters") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceSiPMParameters).setConsumes(topoTokens_[kSiPMParameters]);
       findingRecord<HcalSiPMParametersRcd>();
     }
     if ((objectName == "SiPMCharacteristics") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceSiPMCharacteristics);
       findingRecord<HcalSiPMCharacteristicsRcd>();
     }
     if ((objectName == "TPChannelParameters") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceTPChannelParameters)
           .setConsumes(topoTokens_[kTPChannelParameters]);
       findingRecord<HcalTPChannelParametersRcd>();
     }
     if ((objectName == "TPParameters") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceTPParameters);
       findingRecord<HcalTPParametersRcd>();
     }
   }
 }

◆ ~HcalHardcodeCalibrations()

HcalHardcodeCalibrations::~HcalHardcodeCalibrations ( )

override

Definition at line 332 of file HcalHardcodeCalibrations.cc.

332 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 847 of file HcalHardcodeCalibrations.cc.

                                                                                           {
   edm::ParameterSetDescription desc;
   desc.add<double>("iLumi", -1.);
   desc.add<bool>("HBRecalibration", false);
   desc.add<double>("HBreCalibCutoff", 20.);
   desc.add<edm::FileInPath>("HBmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHB.txt"));
   desc.add<bool>("HERecalibration", false);
   desc.add<double>("HEreCalibCutoff", 20.);
   desc.add<edm::FileInPath>("HEmeanenergies", edm::FileInPath("CalibCalorimetry/HcalPlugins/data/meanenergiesHE.txt"));
   desc.add<bool>("HFRecalibration", false);
   desc.add<bool>("GainWidthsForTrigPrims", false);
   desc.add<bool>("useHBUpgrade", false);
   desc.add<bool>("useHEUpgrade", false);
   desc.add<bool>("useHFUpgrade", false);
   desc.add<bool>("useHOUpgrade", true);
   desc.add<bool>("testHFQIE10", false);
   desc.add<bool>("testHEPlan1", false);
   desc.add<bool>("killHE", false);
   desc.add<bool>("useLayer0Weight", false);
   desc.add<bool>("useIeta18depth1", true);
   desc.addUntracked<std::vector<std::string>>("toGet", std::vector<std::string>());
   desc.addUntracked<bool>("fromDDD", false);
  
   edm::ParameterSetDescription desc_hb;
   desc_hb.add<std::vector<double>>("gain", std::vector<double>({0.19}));
   desc_hb.add<std::vector<double>>("gainWidth", std::vector<double>({0.0}));
   desc_hb.add<double>("pedestal", 3.0);
   desc_hb.add<double>("pedestalWidth", 0.55);
   desc_hb.add<int>("zsThreshold", 8);
   desc_hb.add<std::vector<double>>("qieOffset", std::vector<double>({-0.49, 1.8, 7.2, 37.9}));
   desc_hb.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.917, 0.922, 0.923}));
   desc_hb.add<int>("qieType", 0);
   desc_hb.add<int>("mcShape", 125);
   desc_hb.add<int>("recoShape", 105);
   desc_hb.add<double>("photoelectronsToAnalog", 0.0);
   desc_hb.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
   desc_hb.add<bool>("doRadiationDamage", false);
   desc.add<edm::ParameterSetDescription>("hb", desc_hb);
  
   edm::ParameterSetDescription desc_hbRaddam;
   desc_hbRaddam.add<double>("temperatureBase", 20.0);
   desc_hbRaddam.add<double>("temperatureNew", -5.0);
   desc_hbRaddam.add<double>("intlumiOffset", 150);
   desc_hbRaddam.add<double>("depVsTemp", 0.0631);
   desc_hbRaddam.add<double>("intlumiToNeutrons", 3.67e8);
   desc_hbRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
  
   edm::ParameterSetDescription desc_hbUpgrade;
   desc_hbUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
   desc_hbUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
   desc_hbUpgrade.add<double>("pedestal", 18.0);
   desc_hbUpgrade.add<double>("pedestalWidth", 5.0);
   desc_hbUpgrade.add<int>("zsThreshold", 3);
   desc_hbUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
   desc_hbUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
   desc_hbUpgrade.add<int>("qieType", 2);
   desc_hbUpgrade.add<int>("mcShape", 206);
   desc_hbUpgrade.add<int>("recoShape", 206);
   desc_hbUpgrade.add<double>("photoelectronsToAnalog", 57.5);
   desc_hbUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
   desc_hbUpgrade.add<bool>("doRadiationDamage", true);
   desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
   desc.add<edm::ParameterSetDescription>("hbUpgrade", desc_hbUpgrade);
  
   edm::ParameterSetDescription desc_he;
   desc_he.add<std::vector<double>>("gain", std::vector<double>({0.23}));
   desc_he.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
   desc_he.add<double>("pedestal", 3.0);
   desc_he.add<double>("pedestalWidth", 0.79);
   desc_he.add<int>("zsThreshold", 9);
   desc_he.add<std::vector<double>>("qieOffset", std::vector<double>({-0.38, 2.0, 7.6, 39.6}));
   desc_he.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.916, 0.92, 0.922}));
   desc_he.add<int>("qieType", 0);
   desc_he.add<int>("mcShape", 125);
   desc_he.add<int>("recoShape", 105);
   desc_he.add<double>("photoelectronsToAnalog", 0.0);
   desc_he.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
   desc_he.add<bool>("doRadiationDamage", false);
   desc.add<edm::ParameterSetDescription>("he", desc_he);
  
   edm::ParameterSetDescription desc_heRaddam;
   desc_heRaddam.add<double>("temperatureBase", 20.0);
   desc_heRaddam.add<double>("temperatureNew", 5.0);
   desc_heRaddam.add<double>("intlumiOffset", 75);
   desc_heRaddam.add<double>("depVsTemp", 0.0631);
   desc_heRaddam.add<double>("intlumiToNeutrons", 2.92e8);
   desc_heRaddam.add<std::vector<double>>("depVsNeutrons", {5.69e-11, 7.90e-11});
  
   edm::ParameterSetDescription desc_heUpgrade;
   desc_heUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
   desc_heUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
   desc_heUpgrade.add<double>("pedestal", 18.0);
   desc_heUpgrade.add<double>("pedestalWidth", 5.0);
   desc_heUpgrade.add<int>("zsThreshold", 3);
   desc_heUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
   desc_heUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
   desc_heUpgrade.add<int>("qieType", 2);
   desc_heUpgrade.add<int>("mcShape", 206);
   desc_heUpgrade.add<int>("recoShape", 206);
   desc_heUpgrade.add<double>("photoelectronsToAnalog", 57.5);
   desc_heUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
   desc_heUpgrade.add<bool>("doRadiationDamage", true);
   desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
   desc.add<edm::ParameterSetDescription>("heUpgrade", desc_heUpgrade);
  
   edm::ParameterSetDescription desc_hf;
   desc_hf.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
   desc_hf.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
   desc_hf.add<double>("pedestal", 3.0);
   desc_hf.add<double>("pedestalWidth", 0.84);
   desc_hf.add<int>("zsThreshold", -9999);
   desc_hf.add<std::vector<double>>("qieOffset", std::vector<double>({-0.87, 1.4, 7.8, -29.6}));
   desc_hf.add<std::vector<double>>("qieSlope", std::vector<double>({0.359, 0.358, 0.36, 0.367}));
   desc_hf.add<int>("qieType", 0);
   desc_hf.add<int>("mcShape", 301);
   desc_hf.add<int>("recoShape", 301);
   desc_hf.add<double>("photoelectronsToAnalog", 0.0);
   desc_hf.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
   desc_hf.add<bool>("doRadiationDamage", false);
   desc.add<edm::ParameterSetDescription>("hf", desc_hf);
  
   edm::ParameterSetDescription desc_hfUpgrade;
   desc_hfUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
   desc_hfUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
   desc_hfUpgrade.add<double>("pedestal", 13.33);
   desc_hfUpgrade.add<double>("pedestalWidth", 3.33);
   desc_hfUpgrade.add<int>("zsThreshold", -9999);
   desc_hfUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0697, -0.7405, 12.38, -671.9}));
   desc_hfUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.297, 0.298, 0.298, 0.313}));
   desc_hfUpgrade.add<int>("qieType", 1);
   desc_hfUpgrade.add<int>("mcShape", 301);
   desc_hfUpgrade.add<int>("recoShape", 301);
   desc_hfUpgrade.add<double>("photoelectronsToAnalog", 0.0);
   desc_hfUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
   desc_hfUpgrade.add<bool>("doRadiationDamage", false);
   desc.add<edm::ParameterSetDescription>("hfUpgrade", desc_hfUpgrade);
  
   edm::ParameterSetDescription desc_hfrecal;
   desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterA", std::vector<double>());
   desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterB", std::vector<double>());
   desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterA", std::vector<double>());
   desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterB", std::vector<double>());
   desc.add<edm::ParameterSetDescription>("HFRecalParameterBlock", desc_hfrecal);
  
   edm::ParameterSetDescription desc_ho;
   desc_ho.add<std::vector<double>>("gain", std::vector<double>({0.006, 0.0087}));
   desc_ho.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
   desc_ho.add<double>("pedestal", 11.0);
   desc_ho.add<double>("pedestalWidth", 0.57);
   desc_ho.add<int>("zsThreshold", 24);
   desc_ho.add<std::vector<double>>("qieOffset", std::vector<double>({-0.44, 1.4, 7.1, 38.5}));
   desc_ho.add<std::vector<double>>("qieSlope", std::vector<double>({0.907, 0.915, 0.92, 0.921}));
   desc_ho.add<int>("qieType", 0);
   desc_ho.add<int>("mcShape", 201);
   desc_ho.add<int>("recoShape", 201);
   desc_ho.add<double>("photoelectronsToAnalog", 4.0);
   desc_ho.add<std::vector<double>>("darkCurrent", std::vector<double>({0.0}));
   desc_ho.add<bool>("doRadiationDamage", false);
   desc.add<edm::ParameterSetDescription>("ho", desc_ho);
  
   edm::ParameterSetDescription validator_sipm;
   validator_sipm.add<int>("pixels", 1);
   validator_sipm.add<double>("crosstalk", 0);
   validator_sipm.add<double>("nonlin1", 1);
   validator_sipm.add<double>("nonlin2", 0);
   validator_sipm.add<double>("nonlin3", 0);
   std::vector<edm::ParameterSet> default_sipm(1);
   desc.addVPSet("SiPMCharacteristics", validator_sipm, default_sipm);
  
   descriptions.addDefault(desc);
 }

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), edm::ParameterSetDescription::addUntracked(), and edm::ParameterSetDescription::addVPSet().

◆ produceChannelQuality()

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

protected

Definition at line 455 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
   auto const& topo = rcd.get(topoTokens_[kChannelQuality]);
  
   auto result = std::make_unique<HcalChannelQuality>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     // Special: removal of (non-instrumented) layer "-1"("nose") = depth 1
     // from Upgrade HE, either from
     // (i)  HEP17 sector in 2017 or
     // (ii) the entire HE rin=18 from 2018 through Run 3.
     // May require a revision  by 2021.
  
     uint32_t status = 0;
  
     if (!(cell.isHcalZDCDetId())) {
       HcalDetId hid = HcalDetId(cell);
       int iphi = hid.iphi();
       int ieta = hid.ieta();
       int absieta = hid.ietaAbs();
       int depth = hid.depth();
  
       // specific HEP17 sector (2017 only)
       bool isHEP17 = (iphi >= 63) && (iphi <= 66) && (ieta > 0);
       // |ieta|=18, depth=1
       bool is18d1 = (absieta == 18) && (depth == 1);
  
       if ((!useIeta18depth1 && is18d1) && ((testHEPlan1 && isHEP17) || (!testHEPlan1))) {
         status = 0x8002;  // dead cell
       }
     }
  
     HcalChannelStatus item(cell.rawId(), status);
     result->addValues(item);
   }
  
   return result;
 }

References postprocess-scan-build::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().

◆ produceDcsMap()

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

protected

Definition at line 687 of file HcalHardcodeCalibrations.cc.

                                                                                           {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
  
   return dbHardcode.makeHardcodeDcsMap();
 }

References dbHardcode, and HcalDbHardcode::makeHardcodeDcsMap().

Referenced by HcalHardcodeCalibrations().

◆ produceDcsValues()

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

protected

Definition at line 681 of file HcalHardcodeCalibrations.cc.

                                                                                              {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsValues-> ...";
   auto result = std::make_unique<HcalDcsValues>();
   return result;
 }

References mps_fire::result.

Referenced by HcalHardcodeCalibrations().

◆ produceEffectivePedestals()

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

protected

Definition at line 379 of file HcalHardcodeCalibrations.cc.

                                                                                                             {
   return producePedestals_(rec, topoTokens_[kEffectivePedestals], true);
 }

References kEffectivePedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ produceEffectivePedestalWidths()

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

protected

Definition at line 387 of file HcalHardcodeCalibrations.cc.

                                       {
   return producePedestalWidths_(rec, topoTokens_[kEffectivePedestalWidths], true);
 }

References kEffectivePedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ produceElectronicsMap()

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

protected

Definition at line 633 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceElectronicsMap-> ...";
   auto const& topo = rcd.get(topoTokens_[kElectronicsMap]);
  
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   return dbHardcode.makeHardcodeMap(cells);
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceFlagHFDigiTimeParams()

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

protected

Definition at line 770 of file HcalHardcodeCalibrations.cc.

                                             {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
   auto const& topo = rec.get(topoTokens_[kFlagHFDigiTimeParams]);
  
   auto result = std::make_unique<HcalFlagHFDigiTimeParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
  
   std::vector<double> coef;
   coef.push_back(0.93);
   coef.push_back(-0.38275);
   coef.push_back(-0.012667);
  
   for (auto cell : cells) {
     HcalFlagHFDigiTimeParam item(cell.rawId(),
                                  1,    //firstsample
                                  3,    // samplestoadd
                                  2,    //expectedpeak
                                  40.,  // min energy threshold
                                  coef  // coefficients
     );
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceFrontEndMap()

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

protected

Definition at line 796 of file HcalHardcodeCalibrations.cc.

                                                                                                          {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFrontEndMap-> ...";
   auto const& topo = rec.get(topoTokens_[kFrontEndMap]);
  
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
  
   return dbHardcode.makeHardcodeFrontEndMap(cells);
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceGains()

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

protected

Definition at line 392 of file HcalHardcodeCalibrations.cc.

                                                                                        {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGains-> ...";
  
   auto const& topo = rec.get(topoTokens_[kGains]);
   auto result = std::make_unique<HcalGains>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalGain item = dbHardcode.makeGain(cell);
     result->addValues(item);
   }
   return result;
 }

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, kGains, HcalDbHardcode::killHE(), HcalDbHardcode::makeGain(), mps_fire::result, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ produceGainWidths()

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

protected

Definition at line 405 of file HcalHardcodeCalibrations.cc.

                                                                                                       {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
  
   auto const& topo = rec.get(topoTokens_[kGainWidths]);
   auto result = std::make_unique<HcalGainWidths>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     // for Upgrade - include TrigPrims, for regular case - only HcalDetId
     if (switchGainWidthsForTrigPrims) {
       HcalGainWidth item = dbHardcode.makeGainWidth(cell);
       result->addValues(item);
     } else if (!cell.isHcalTrigTowerDetId()) {
       HcalGainWidth item = dbHardcode.makeGainWidth(cell);
       result->addValues(item);
     }
   }
   return result;
 }

References postprocess-scan-build::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().

◆ produceL1TriggerObjects()

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

protected

Definition at line 616 of file HcalHardcodeCalibrations.cc.

                                         {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
   auto const& topo = rcd.get(topoTokens_[kL1TriggerObjects]);
  
   auto result = std::make_unique<HcalL1TriggerObjects>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalL1TriggerObject item(cell.rawId(), 0., 1., 0);
     result->addValues(item);
   }
   // add tag and algo values
   result->setTagString("hardcoded");
   result->setAlgoString("hardcoded");
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceLongRecoParams()

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

protected

Definition at line 719 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
   auto const& topo = rec.get(topoTokens_[kLongRecoParams]);
  
   auto result = std::make_unique<HcalLongRecoParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   std::vector<unsigned int> mSignal;
   mSignal.push_back(4);
   mSignal.push_back(5);
   mSignal.push_back(6);
   std::vector<unsigned int> mNoise;
   mNoise.push_back(1);
   mNoise.push_back(2);
   mNoise.push_back(3);
   for (auto cell : cells) {
     if (cell.isHcalZDCDetId()) {
       HcalLongRecoParam item(cell.rawId(), mSignal, mNoise);
       result->addValues(item);
     }
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceLUTCorrs()

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

protected

Definition at line 564 of file HcalHardcodeCalibrations.cc.

                                                                                                 {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLUTCorrs-> ...";
   auto const& topo = rcd.get(topoTokens_[kLUTCorrs]);
  
   auto result = std::make_unique<HcalLUTCorrs>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalLUTCorr item(cell.rawId(), 1.0);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceLutMetadata()

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

protected

Definition at line 655 of file HcalHardcodeCalibrations.cc.

                                                                                                          {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
   auto const& topo = rcd.get(topoTokens_[kLutMetadata]);
  
   auto result = std::make_unique<HcalLutMetadata>(&topo);
  
   result->setRctLsb(0.5);
   result->setNominalGain(0.177);  // for HBHE SiPMs
  
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (const auto& cell : cells) {
     float rcalib = 1.;
     int granularity = 1;
     int threshold = 0;
  
     if (cell.isHcalTrigTowerDetId()) {
       rcalib = 0.;
     }
  
     HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
     result->addValues(item);
   }
  
   return result;
 }

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), B2GTnPMonitor_cfi::item, HcalDbHardcode::killHE(), kLutMetadata, mps_fire::result, remoteMonitoring_LED_IterMethod_cfg::threshold, and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ produceMCParams()

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

protected

Definition at line 756 of file HcalHardcodeCalibrations.cc.

                                                                                                 {
   //  std::cout << std::endl << " .... HcalHardcodeCalibrations::produceMCParams ->"<< std::endl;
  
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceMCParams-> ...";
   auto const& topo = rec.get(topoTokens_[kMCParams]);
   auto result = std::make_unique<HcalMCParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalMCParam item = dbHardcode.makeMCParam(cell);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ producePedestals()

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

protected

Definition at line 375 of file HcalHardcodeCalibrations.cc.

                                                                                                    {
   return producePedestals_(rec, topoTokens_[kPedestals], false);
 }

References kPedestals, producePedestals_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ producePedestals_()

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

protected

Definition at line 346 of file HcalHardcodeCalibrations.cc.

                                                                                                              {
   std::string seff = eff ? "Effective" : "";
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "Pedestals-> ...";
  
   auto const& topo = rec.get(token);
   auto result = std::make_unique<HcalPedestals>(&topo, false);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalPedestal item = dbHardcode.makePedestal(cell, false, eff, &topo, iLumi);
     result->addValues(item);
   }
   return result;
 }

References postprocess-scan-build::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().

◆ producePedestalWidths()

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

protected

Definition at line 383 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   return producePedestalWidths_(rec, topoTokens_[kPedestalWidths], false);
 }

References kPedestalWidths, producePedestalWidths_(), and topoTokens_.

Referenced by HcalHardcodeCalibrations().

◆ producePedestalWidths_()

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

protected

Definition at line 361 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   std::string seff = eff ? "Effective" : "";
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "PedestalWidths-> ...";
   auto const& topo = rec.get(token);
   auto result = std::make_unique<HcalPedestalWidths>(&topo, false);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalPedestalWidth item = dbHardcode.makePedestalWidth(cell, eff, &topo, iLumi);
     result->addValues(item);
   }
   return result;
 }

References postprocess-scan-build::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().

◆ producePFCorrs()

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

protected

Definition at line 577 of file HcalHardcodeCalibrations.cc.

                                                                                              {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCorrs-> ...";
   auto const& topo = rcd.get(topoTokens_[kPFCorrs]);
  
   auto result = std::make_unique<HcalPFCorrs>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalPFCorr item(cell.rawId(), 1.0);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceQIEData()

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

protected

Definition at line 424 of file HcalHardcodeCalibrations.cc.

                                                                                              {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
  
   /*
   std::cout << std::endl << ">>>  HcalHardcodeCalibrations::produceQIEData"
         << std::endl;  
   */
  
   auto const& topo = rcd.get(topoTokens_[kQIEData]);
   auto result = std::make_unique<HcalQIEData>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalQIECoder coder = dbHardcode.makeQIECoder(cell);
     result->addCoder(coder);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceQIETypes()

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

protected

Definition at line 442 of file HcalHardcodeCalibrations.cc.

                                                                                                 {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIETypes-> ...";
   auto const& topo = rcd.get(topoTokens_[kQIETypes]);
  
   auto result = std::make_unique<HcalQIETypes>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalQIEType item = dbHardcode.makeQIEType(cell);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceRecoParams()

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

protected

Definition at line 693 of file HcalHardcodeCalibrations.cc.

                                                                                                       {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRecoParams-> ...";
   auto const& topo = rec.get(topoTokens_[kRecoParams]);
  
   auto result = std::make_unique<HcalRecoParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalRecoParam item = dbHardcode.makeRecoParam(cell);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceRespCorrs()

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

protected

Definition at line 494 of file HcalHardcodeCalibrations.cc.

                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
   auto const& topo = rcd.get(topoTokens_[kRespCorrs]);
  
   //set depth segmentation for HB/HE recalib - only happens once
   if ((he_recalibration && !setHEdsegm) || (hb_recalibration && !setHBdsegm)) {
     std::vector<std::vector<int>> m_segmentation;
     int maxEta = topo.lastHBHERing();
     m_segmentation.resize(maxEta);
     for (int i = 0; i < maxEta; i++) {
       topo.getDepthSegmentation(i + 1, m_segmentation[i]);
     }
     if (he_recalibration && !setHEdsegm) {
       he_recalibration->setup(m_segmentation, &rcd.get(heDarkeningToken_));
       setHEdsegm = true;
     }
     if (hb_recalibration && !setHBdsegm) {
       hb_recalibration->setup(m_segmentation, &rcd.get(hbDarkeningToken_));
       setHBdsegm = true;
     }
   }
  
   auto result = std::make_unique<HcalRespCorrs>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (const auto& cell : cells) {
     double corr = 1.0;
  
     //check for layer 0 reweighting: when depth 1 has only one layer, it is layer 0
     if (useLayer0Weight &&
         ((cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap) ||
          (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) &&
         (HcalDetId(cell).depth() == 1 &&
          dbHardcode.getLayersInDepth(HcalDetId(cell).ietaAbs(), HcalDetId(cell).depth(), &topo) == 1)) {
       //layer 0 is thicker than other layers (9mm vs 3.7mm) and brighter (Bicron vs SCSN81)
       //in Run1/Run2 (pre-2017 for HE), ODU for layer 0 had neutral density filter attached
       //NDF was simulated as weight of 0.5 applied to Geant energy deposits
       //for Phase1, NDF is removed - simulated as weight of 1.2 applied to Geant energy deposits
       //to maintain RECO calibrations, move the layer 0 energy scale back to its previous state using respcorrs
       corr = 0.5 / 1.2;
     }
  
     if ((hb_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
       int depth_ = HcalDetId(cell).depth();
       int ieta_ = HcalDetId(cell).ieta();
       corr *= hb_recalibration->getCorr(ieta_, depth_);
 #ifdef DebugLog
       std::cout << "HB ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr << std::endl;
 #endif
     } else if ((he_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
       int depth_ = HcalDetId(cell).depth();
       int ieta_ = HcalDetId(cell).ieta();
       corr *= he_recalibration->getCorr(ieta_, depth_);
 #ifdef DebugLog
       std::cout << "HE ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr << std::endl;
 #endif
     } else if ((hf_recalibration != nullptr) && (cell.genericSubdet() == HcalGenericDetId::HcalGenForward)) {
       int depth_ = HcalDetId(cell).depth();
       int ieta_ = HcalDetId(cell).ieta();
       corr = hf_recalibration->getCorr(ieta_, depth_, iLumi);
 #ifdef DebugLog
       std::cout << "HF ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr << std::endl;
 #endif
     }
  
     HcalRespCorr item(cell.rawId(), corr);
     result->addValues(item);
   }
   return result;
 }

References postprocess-scan-build::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().

◆ produceSiPMCharacteristics()

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

protected

Definition at line 818 of file HcalHardcodeCalibrations.cc.

                                            {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
  
   return dbHardcode.makeHardcodeSiPMCharacteristics();
 }

References dbHardcode, and HcalDbHardcode::makeHardcodeSiPMCharacteristics().

Referenced by HcalHardcodeCalibrations().

◆ produceSiPMParameters()

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

protected

Definition at line 805 of file HcalHardcodeCalibrations.cc.

                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMParameters-> ...";
   auto const& topo = rec.get(topoTokens_[kSiPMParameters]);
  
   auto result = std::make_unique<HcalSiPMParameters>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalSiPMParameter item = dbHardcode.makeHardcodeSiPMParameter(cell, &topo, iLumi);
     result->addValues(item);
   }
   return result;
 }

References postprocess-scan-build::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().

◆ produceTimeCorrs()

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

protected

Definition at line 590 of file HcalHardcodeCalibrations.cc.

                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimeCorrs-> ...";
   auto const& topo = rcd.get(topoTokens_[kTimeCorrs]);
  
   auto result = std::make_unique<HcalTimeCorrs>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalTimeCorr item(cell.rawId(), 0.0);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceTimingParams()

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

protected

Definition at line 706 of file HcalHardcodeCalibrations.cc.

                                                                                                             {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimingParams-> ...";
   auto const& topo = rec.get(topoTokens_[kTimingParams]);
  
   auto result = std::make_unique<HcalTimingParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalTimingParam item = dbHardcode.makeTimingParam(cell);
     result->addValues(item);
   }
   return result;
 }

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

◆ produceTPChannelParameters()

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

protected

Definition at line 825 of file HcalHardcodeCalibrations.cc.

                                            {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
   auto const& topo = rec.get(topoTokens_[kTPChannelParameters]);
  
   auto result = std::make_unique<HcalTPChannelParameters>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalTPChannelParameter item = dbHardcode.makeHardcodeTPChannelParameter(cell);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceTPParameters()

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

protected

Definition at line 839 of file HcalHardcodeCalibrations.cc.

                                                                                                             {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPParameters-> ...";
  
   auto result = std::make_unique<HcalTPParameters>();
   dbHardcode.makeHardcodeTPParameters(*result);
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceValidationCorrs()

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

protected

Definition at line 641 of file HcalHardcodeCalibrations.cc.

                                        {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceValidationCorrs-> ...";
   auto const& topo = rcd.get(topoTokens_[kValidationCorrs]);
  
   auto result = std::make_unique<HcalValidationCorrs>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalValidationCorr item(cell.rawId(), 1.0);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceZDCLowGainFractions()

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

protected

Definition at line 742 of file HcalHardcodeCalibrations.cc.

                                            {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZDCLowGainFractions-> ...";
   auto const& topo = rec.get(topoTokens_[kZDCLowGainFractions]);
  
   auto result = std::make_unique<HcalZDCLowGainFractions>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalZDCLowGainFraction item(cell.rawId(), 0.0);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ produceZSThresholds()

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

protected

Definition at line 603 of file HcalHardcodeCalibrations.cc.

                                                                                                             {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZSThresholds-> ...";
   auto const& topo = rcd.get(topoTokens_[kZSThresholds]);
  
   auto result = std::make_unique<HcalZSThresholds>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalZSThreshold item = dbHardcode.makeZSThreshold(cell);
     result->addValues(item);
   }
   return result;
 }

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

Referenced by HcalHardcodeCalibrations().

◆ setIntervalFor()

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 337 of file HcalHardcodeCalibrations.cc.

                                                                               {
   std::string record = iKey.name();
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::setIntervalFor-> key: " << record << " time: " << iTime.eventID()
                        << '/' << iTime.time().value();
   oInterval = edm::ValidityInterval(edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime());  //infinite
 }

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

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

Definition at line 142 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), producePedestals_(), producePedestalWidths_(), produceRespCorrs(), and produceSiPMParameters().

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

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 }

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Types

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ HcalHardcodeCalibrations()

◆ ~HcalHardcodeCalibrations()

Member Function Documentation

◆ fillDescriptions()

◆ produceChannelQuality()

◆ produceDcsMap()

◆ produceDcsValues()

◆ produceEffectivePedestals()

◆ produceEffectivePedestalWidths()

◆ produceElectronicsMap()

◆ produceFlagHFDigiTimeParams()

◆ produceFrontEndMap()

◆ produceGains()

◆ produceGainWidths()

◆ produceL1TriggerObjects()

◆ produceLongRecoParams()

◆ produceLUTCorrs()

◆ produceLutMetadata()

◆ produceMCParams()

◆ producePedestals()

◆ producePedestals_()

◆ producePedestalWidths()

◆ producePedestalWidths_()

◆ producePFCorrs()

◆ produceQIEData()

◆ produceQIETypes()

◆ produceRecoParams()

◆ produceRespCorrs()

◆ produceSiPMCharacteristics()

◆ produceSiPMParameters()

◆ produceTimeCorrs()

◆ produceTimingParams()

◆ produceTPChannelParameters()

◆ produceTPParameters()

◆ produceValidationCorrs()

◆ produceZDCLowGainFractions()

◆ produceZSThresholds()

◆ setIntervalFor()

Member Data Documentation

◆ dbHardcode

◆ hb_recalibration

◆ hbDarkeningToken_

◆ he_recalibration

◆ heDarkeningToken_

◆ hf_recalibration

◆ iLumi

◆ setHBdsegm

◆ setHEdsegm

◆ switchGainWidthsForTrigPrims

◆ testHEPlan1

◆ topoTokens_

◆ useIeta18depth1

◆ useLayer0Weight