#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

	ESProducer (ESProducer &&)=delete

ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const

ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const

bool	hasMayConsumes () const noexcept

size_t	numberOfTokenIndices (unsigned int iIndex) const

ESProducer &	operator= (const ESProducer &)=delete

ESProducer &	operator= (ESProducer &&)=delete

SerialTaskQueueChain &	queue ()

template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final

	~ESProducer () noexcept(false) override

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

	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete

const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete

	~ESProductResolverFactoryProducer () noexcept(false) override

Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)

const ComponentDescription &	description () const

	ESProductResolverProvider ()

	ESProductResolverProvider (const ESProductResolverProvider &)=delete

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

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

bool	isUsingRecord (const EventSetupRecordKey &key) const

KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)

const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete

void	setAppendToDataLabel (const edm::ParameterSet &)

void	setDescription (const ComponentDescription &iDescription)

std::set< EventSetupRecordKey >	usingRecords () const

virtual	~ESProductResolverProvider () 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::ESProductResolverProvider
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 > &, const edm::ESGetToken< ZdcTopology, HcalRecNumberingRecord > &, bool eff)

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

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

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

std::unique_ptr< HcalPFCuts >	producePFCuts (const HcalPFCutsRcd &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
ESConsumesInfo *	consumesInfoPushBackNew ()

unsigned int	consumesInfoSize () const

template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList , const TRecord iRecord, const es::Label &iLabel)

template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null , const TRecord , const es::Label &)

template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})

template<typename T >
auto	setWhatProduced (T iThis, const char iLabel)

template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)

template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const es::Label &iLabel={})

template<typename T , typename TReturn , typename TRecord , typename TDecorator >
auto	setWhatProduced (T iThis, TReturn(T ::iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})

template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})

template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})

void	usesResources (std::vector< std::string > const &)

Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())

virtual void	registerFactoryWithKey (const EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())

KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override

Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &key)

Protected Member Functions inherited from edm::EventSetupRecordIntervalFinder
template<class T >
void	findingRecord ()

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private 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

std::unordered_map< int, edm::ESGetToken< ZdcTopology, HcalRecNumberingRecord > >	zdcTopoTokens_

Additional Inherited Members
Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey

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

Detailed Description

Definition at line 58 of file HcalHardcodeCalibrations.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

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

Definition at line 119 of file HcalHardcodeCalibrations.h.

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

Constructor & Destructor Documentation

◆ HcalHardcodeCalibrations()

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

Definition at line 163 of file HcalHardcodeCalibrations.cc.

     : hb_recalibration(nullptr),
       he_recalibration(nullptr),
       hf_recalibration(nullptr),
       setHEdsegm(false),
       setHBdsegm(false) {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
 #endif
 
   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 =
           std::make_unique<HBHERecalibration>(iLumi,
                                               iConfig.getParameter<double>("HBreCalibCutoff"),
                                               iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath());
     }
     if (he_recalib) {
       he_recalibration =
           std::make_unique<HBHERecalibration>(iLumi,
                                               iConfig.getParameter<double>("HEreCalibCutoff"),
                                               iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath());
     }
     if (hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())
       hf_recalibration =
           std::make_unique<HFRecalibration>(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock"));
 
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HcalCalib") << " HcalHardcodeCalibrations:  iLumi = " << iLumi;
 #endif
   }
 
   std::vector<std::string> toGet = iConfig.getUntrackedParameter<std::vector<std::string>>("toGet");
   for (auto& objectName : toGet) {
     bool all = objectName == "all";
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HcalCalib") << "Load parameters for " << objectName;
 #endif
     if ((objectName == "Pedestals") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::producePedestals);
       topoTokens_[kPedestals] = c.consumes();
       zdcTopoTokens_[kPedestals] = c.consumes();
       findingRecord<HcalPedestalsRcd>();
     }
     if ((objectName == "PedestalWidths") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::producePedestalWidths);
       topoTokens_[kPedestalWidths] = c.consumes();
       zdcTopoTokens_[kPedestalWidths] = c.consumes();
       findingRecord<HcalPedestalWidthsRcd>();
     }
     if ((objectName == "EffectivePedestals") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceEffectivePedestals, edm::es::Label("effective"));
       topoTokens_[kEffectivePedestals] = c.consumes();
       zdcTopoTokens_[kEffectivePedestals] = c.consumes();
       findingRecord<HcalPedestalsRcd>();
     }
     if ((objectName == "EffectivePedestalWidths") || all) {
       auto c =
           setWhatProduced(this, &HcalHardcodeCalibrations::produceEffectivePedestalWidths, edm::es::Label("effective"));
       topoTokens_[kEffectivePedestalWidths] = c.consumes();
       zdcTopoTokens_[kEffectivePedestalWidths] = c.consumes();
       findingRecord<HcalPedestalWidthsRcd>();
     }
     if ((objectName == "Gains") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceGains);
       topoTokens_[kGains] = c.consumes();
       zdcTopoTokens_[kGains] = c.consumes();
       findingRecord<HcalGainsRcd>();
     }
     if ((objectName == "GainWidths") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceGainWidths);
       topoTokens_[kGainWidths] = c.consumes();
       zdcTopoTokens_[kGainWidths] = c.consumes();
       findingRecord<HcalGainWidthsRcd>();
     }
     if ((objectName == "PFCuts") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::producePFCuts);
       topoTokens_[kPFCuts] = c.consumes();
       zdcTopoTokens_[kPFCuts] = c.consumes();
       findingRecord<HcalPFCutsRcd>();
     }
     if ((objectName == "QIEData") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceQIEData);
       topoTokens_[kQIEData] = c.consumes();
       zdcTopoTokens_[kQIEData] = c.consumes();
       findingRecord<HcalQIEDataRcd>();
     }
     if ((objectName == "QIETypes") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceQIETypes);
       topoTokens_[kQIETypes] = c.consumes();
       zdcTopoTokens_[kQIETypes] = c.consumes();
       findingRecord<HcalQIETypesRcd>();
     }
     if ((objectName == "ChannelQuality") || (objectName == "channelQuality") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceChannelQuality);
       topoTokens_[kChannelQuality] = c.consumes();
       zdcTopoTokens_[kChannelQuality] = c.consumes();
       findingRecord<HcalChannelQualityRcd>();
     }
     if ((objectName == "ElectronicsMap") || (objectName == "electronicsMap") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceElectronicsMap);
       topoTokens_[kElectronicsMap] = c.consumes();
       zdcTopoTokens_[kElectronicsMap] = c.consumes();
       findingRecord<HcalElectronicsMapRcd>();
     }
     if ((objectName == "ZSThresholds") || (objectName == "zsThresholds") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceZSThresholds);
       topoTokens_[kZSThresholds] = c.consumes();
       zdcTopoTokens_[kZSThresholds] = c.consumes();
       findingRecord<HcalZSThresholdsRcd>();
     }
     if ((objectName == "RespCorrs") || (objectName == "ResponseCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceRespCorrs);
       topoTokens_[kRespCorrs] = c.consumes();
       zdcTopoTokens_[kRespCorrs] = c.consumes();
       if (he_recalibration) {
         heDarkeningToken_ = c.consumes(edm::ESInputTag("", "HE"));
       }
       if (hb_recalibration) {
         hbDarkeningToken_ = c.consumes(edm::ESInputTag("", "HB"));
       }
       findingRecord<HcalRespCorrsRcd>();
     }
     if ((objectName == "LUTCorrs") || (objectName == "LUTCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceLUTCorrs);
       topoTokens_[kLUTCorrs] = c.consumes();
       zdcTopoTokens_[kLUTCorrs] = c.consumes();
       findingRecord<HcalLUTCorrsRcd>();
     }
     if ((objectName == "PFCorrs") || (objectName == "PFCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::producePFCorrs);
       topoTokens_[kPFCorrs] = c.consumes();
       zdcTopoTokens_[kPFCorrs] = c.consumes();
       findingRecord<HcalPFCorrsRcd>();
     }
     if ((objectName == "TimeCorrs") || (objectName == "TimeCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceTimeCorrs);
       topoTokens_[kTimeCorrs] = c.consumes();
       zdcTopoTokens_[kTimeCorrs] = c.consumes();
       findingRecord<HcalTimeCorrsRcd>();
     }
     if ((objectName == "L1TriggerObjects") || (objectName == "L1Trigger") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceL1TriggerObjects);
       topoTokens_[kL1TriggerObjects] = c.consumes();
       zdcTopoTokens_[kL1TriggerObjects] = c.consumes();
       findingRecord<HcalL1TriggerObjectsRcd>();
     }
     if ((objectName == "ValidationCorrs") || (objectName == "ValidationCorrection") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceValidationCorrs);
       topoTokens_[kValidationCorrs] = c.consumes();
       zdcTopoTokens_[kValidationCorrs] = c.consumes();
       findingRecord<HcalValidationCorrsRcd>();
     }
     if ((objectName == "LutMetadata") || (objectName == "lutMetadata") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceLutMetadata);
       topoTokens_[kLutMetadata] = c.consumes();
       zdcTopoTokens_[kLutMetadata] = c.consumes();
       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) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceRecoParams);
       topoTokens_[kRecoParams] = c.consumes();
       zdcTopoTokens_[kRecoParams] = c.consumes();
       findingRecord<HcalRecoParamsRcd>();
     }
     if ((objectName == "LongRecoParams") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceLongRecoParams);
       topoTokens_[kLongRecoParams] = c.consumes();
       zdcTopoTokens_[kLongRecoParams] = c.consumes();
       findingRecord<HcalLongRecoParamsRcd>();
     }
     if ((objectName == "ZDCLowGainFractions") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceZDCLowGainFractions);
       topoTokens_[kZDCLowGainFractions] = c.consumes();
       zdcTopoTokens_[kZDCLowGainFractions] = c.consumes();
       findingRecord<HcalZDCLowGainFractionsRcd>();
     }
     if ((objectName == "MCParams") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceMCParams);
       topoTokens_[kMCParams] = c.consumes();
       zdcTopoTokens_[kMCParams] = c.consumes();
       findingRecord<HcalMCParamsRcd>();
     }
     if ((objectName == "FlagHFDigiTimeParams") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceFlagHFDigiTimeParams);
       topoTokens_[kFlagHFDigiTimeParams] = c.consumes();
       zdcTopoTokens_[kFlagHFDigiTimeParams] = c.consumes();
       findingRecord<HcalFlagHFDigiTimeParamsRcd>();
     }
     if ((objectName == "FrontEndMap") || (objectName == "frontEndMap") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceFrontEndMap);
       topoTokens_[kFrontEndMap] = c.consumes();
       zdcTopoTokens_[kFrontEndMap] = c.consumes();
       findingRecord<HcalFrontEndMapRcd>();
     }
     if ((objectName == "SiPMParameters") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceSiPMParameters);
       topoTokens_[kSiPMParameters] = c.consumes();
       zdcTopoTokens_[kSiPMParameters] = c.consumes();
       findingRecord<HcalSiPMParametersRcd>();
     }
     if ((objectName == "SiPMCharacteristics") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceSiPMCharacteristics);
       findingRecord<HcalSiPMCharacteristicsRcd>();
     }
     if ((objectName == "TPChannelParameters") || all) {
       auto c = setWhatProduced(this, &HcalHardcodeCalibrations::produceTPChannelParameters);
       topoTokens_[kTPChannelParameters] = c.consumes();
       zdcTopoTokens_[kTPChannelParameters] = c.consumes();
       findingRecord<HcalTPChannelParametersRcd>();
     }
     if ((objectName == "TPParameters") || all) {
       setWhatProduced(this, &HcalHardcodeCalibrations::produceTPParameters);
       findingRecord<HcalTPParametersRcd>();
     }
   }
 }

◆ ~HcalHardcodeCalibrations()

HcalHardcodeCalibrations::~HcalHardcodeCalibrations ( )

override

Definition at line 420 of file HcalHardcodeCalibrations.cc.

420 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 1044 of file HcalHardcodeCalibrations.cc.

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

                                                                                           {
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
   desc_hb.add<bool>("doRadiationDamage", false);
   desc_hb.add<double>("noiseThreshold", 0.0);
   desc_hb.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
   desc_hbUpgrade.add<bool>("doRadiationDamage", true);
   desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
   desc_hbUpgrade.add<double>("noiseThreshold", 0.0);
   desc_hbUpgrade.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
   desc_he.add<bool>("doRadiationDamage", false);
   desc_he.add<double>("noiseThreshold", 0.0);
   desc_he.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.26}));
   desc_heUpgrade.add<bool>("doRadiationDamage", true);
   desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
   desc_heUpgrade.add<double>("noiseThreshold", 0.0);
   desc_heUpgrade.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
   desc_hf.add<bool>("doRadiationDamage", false);
   desc_hf.add<double>("noiseThreshold", 0.0);
   desc_hf.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
   desc_hfUpgrade.add<bool>("doRadiationDamage", false);
   desc_hfUpgrade.add<double>("noiseThreshold", 0.0);
   desc_hfUpgrade.add<double>("seedThreshold", 0.1);
   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<std::vector<double>>("noiseCorrelation", std::vector<double>({0.0}));
   desc_ho.add<bool>("doRadiationDamage", false);
   desc_ho.add<double>("noiseThreshold", 0.0);
   desc_ho.add<double>("seedThreshold", 0.1);
   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);
 }

◆ produceChannelQuality()

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

protected

Definition at line 588 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                                   {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
 #endif
   auto const& topo = rcd.get(topoTokens_[kChannelQuality]);
   auto const& zdcTopo = rcd.get(zdcTopoTokens_[kChannelQuality]);
 
   auto result = std::make_unique<HcalChannelQuality>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, 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;
 }

◆ produceDcsMap()

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

protected

Definition at line 852 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeDcsMap().

Referenced by HcalHardcodeCalibrations().

                                                                                           {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
 #endif
   return dbHardcode.makeHardcodeDcsMap();
 }

◆ produceDcsValues()

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

protected

Definition at line 844 of file HcalHardcodeCalibrations.cc.

References mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                              {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceDcsValues-> ...";
 #endif
   auto result = std::make_unique<HcalDcsValues>();
   return result;
 }

◆ produceEffectivePedestals()

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

protected

Definition at line 480 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestals, producePedestals_(), topoTokens_, and zdcTopoTokens_.

Referenced by HcalHardcodeCalibrations().

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

◆ produceEffectivePedestalWidths()

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

protected

Definition at line 488 of file HcalHardcodeCalibrations.cc.

References kEffectivePedestalWidths, producePedestalWidths_(), topoTokens_, and zdcTopoTokens_.

Referenced by HcalHardcodeCalibrations().

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

◆ produceElectronicsMap()

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

protected

Definition at line 787 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceFlagHFDigiTimeParams()

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

protected

Definition at line 949 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                             {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
 #endif
   auto const& topo = rec.get(topoTokens_[kFlagHFDigiTimeParams]);
   auto const& zdcTopo = rec.get(zdcTopoTokens_[kFlagHFDigiTimeParams]);
 
   auto result = std::make_unique<HcalFlagHFDigiTimeParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, 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;
 }

◆ produceFrontEndMap()

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

protected

Definition at line 978 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceGains()

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

protected

Definition at line 494 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceGainWidths()

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

protected

Definition at line 509 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                       {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
 #endif
   auto const& topo = rec.get(topoTokens_[kGainWidths]);
   auto const& zdcTopo = rec.get(zdcTopoTokens_[kGainWidths]);
   auto result = std::make_unique<HcalGainWidths>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, dbHardcode.killHE());
   for (auto cell : cells) {
     // for Upgrade - include TrigPrims, for regular case - only HcalDetId
     if (switchGainWidthsForTrigPrims) {
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HcalCalib") << " HcalGainWidths cell (with TPs) : " << std::hex << cell.rawId() << std::dec
                                     << "  " << cell;
 #endif
       HcalGainWidth item = dbHardcode.makeGainWidth(cell);
       result->addValues(item);
     } else if (!cell.isHcalTrigTowerDetId()) {
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HcalCalib") << " HcalGainWidths cell (without TPs) : " << std::hex << cell.rawId() << std::dec
                                     << "  " << cell;
 #endif
       HcalGainWidth item = dbHardcode.makeGainWidth(cell);
       result->addValues(item);
     }
   }
   return result;
 }

◆ produceL1TriggerObjects()

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

protected

Definition at line 767 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                         {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
 #endif
   auto const& topo = rcd.get(topoTokens_[kL1TriggerObjects]);
   auto const& zdcTopo = rcd.get(zdcTopoTokens_[kL1TriggerObjects]);
 
   auto result = std::make_unique<HcalL1TriggerObjects>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, 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;
 }

◆ produceLongRecoParams()

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

protected

Definition at line 891 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                                   {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
 #endif
   auto const& topo = rec.get(topoTokens_[kLongRecoParams]);
   auto const& zdcTopo = rec.get(zdcTopoTokens_[kLongRecoParams]);
 
   auto result = std::make_unique<HcalLongRecoParams>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, 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;
 }

◆ produceLUTCorrs()

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

protected

Definition at line 703 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceLutMetadata()

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

protected

Definition at line 815 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                          {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
 #endif
   auto const& topo = rcd.get(topoTokens_[kLutMetadata]);
   auto const& zdcTopo = rcd.get(zdcTopoTokens_[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, zdcTopo, 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;
 }

◆ produceMCParams()

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

protected

Definition at line 934 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ producePedestals()

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

protected

Definition at line 476 of file HcalHardcodeCalibrations.cc.

References kPedestals, producePedestals_(), topoTokens_, and zdcTopoTokens_.

Referenced by HcalHardcodeCalibrations().

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

◆ producePedestals_()

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

protected

Definition at line 436 of file HcalHardcodeCalibrations.cc.

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

Referenced by produceEffectivePedestals(), and producePedestals().

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

◆ producePedestalWidths()

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

protected

Definition at line 484 of file HcalHardcodeCalibrations.cc.

References kPedestalWidths, producePedestalWidths_(), topoTokens_, and zdcTopoTokens_.

Referenced by HcalHardcodeCalibrations().

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

◆ producePedestalWidths_()

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

protected

Definition at line 456 of file HcalHardcodeCalibrations.cc.

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

Referenced by produceEffectivePedestalWidths(), and producePedestalWidths().

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

◆ producePFCorrs()

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

protected

Definition at line 719 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ producePFCuts()

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

protected

Definition at line 538 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                           {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::producePFCuts-> ...";
 #endif
   auto const& topo = rec.get(topoTokens_[kPFCuts]);
   auto const& zdcTopo = rec.get(zdcTopoTokens_[kPFCuts]);
   auto result = std::make_unique<HcalPFCuts>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, dbHardcode.killHE());
   for (auto cell : cells) {
     // Use only standard Hcal channels for now, no TrigPrims
     if (!cell.isHcalTrigTowerDetId()) {
       HcalPFCut item = dbHardcode.makePFCut(cell, iLumi, dbHardcode.killHE());
       result->addValues(item);
     }
   }
   return result;
 }

◆ produceQIEData()

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

protected

Definition at line 556 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                              {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
 #endif
 
   auto const& topo = rcd.get(topoTokens_[kQIEData]);
   auto const& zdcTopo = rcd.get(zdcTopoTokens_[kQIEData]);
   auto result = std::make_unique<HcalQIEData>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, dbHardcode.killHE());
   for (auto cell : cells) {
     HcalQIECoder coder = dbHardcode.makeQIECoder(cell);
     result->addCoder(coder);
   }
   return result;
 }

◆ produceQIETypes()

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

protected

Definition at line 572 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceRecoParams()

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

protected

Definition at line 859 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceRespCorrs()

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

protected

Definition at line 630 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                    {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
 #endif
   auto const& topo = rcd.get(topoTokens_[kRespCorrs]);
   auto const& zdcTopo = rcd.get(zdcTopoTokens_[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, zdcTopo, 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 EDM_ML_DEBUG
       edm::LogVerbatim("HcalCalib") << "HB ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr;
 #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 EDM_ML_DEBUG
       edm::LogVerbatim("HcalCalib") << "HE ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr;
 #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 EDM_ML_DEBUG
       edm::LogVerbatim("HcalCalib") << "HF ieta, depth = " << ieta_ << ",  " << depth_ << "   corr = " << corr;
 #endif
     }
 
     HcalRespCorr item(cell.rawId(), corr);
     result->addValues(item);
   }
   return result;
 }

◆ produceSiPMCharacteristics()

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

protected

Definition at line 1006 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeSiPMCharacteristics().

Referenced by HcalHardcodeCalibrations().

                                            {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
 #endif
   return dbHardcode.makeHardcodeSiPMCharacteristics();
 }

◆ produceSiPMParameters()

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

protected

Definition at line 990 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceTimeCorrs()

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

protected

Definition at line 735 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceTimingParams()

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

protected

Definition at line 875 of file HcalHardcodeCalibrations.cc.

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

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

◆ produceTPChannelParameters()

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

protected

Definition at line 1014 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                            {
 #ifdef EDM_ML_DEBUG
   edm::LogVerbatim("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
 #endif
   auto const& topo = rec.get(topoTokens_[kTPChannelParameters]);
   auto const& zdcTopo = rec.get(zdcTopoTokens_[kTPChannelParameters]);
 
   auto result = std::make_unique<HcalTPChannelParameters>(&topo);
   const std::vector<HcalGenericDetId>& cells = allCells(topo, zdcTopo, dbHardcode.killHE());
   for (auto cell : cells) {
     // Thinking about Phase2 and the new FIR filter,
     // for now, don't put TT in TPChannelParams
     if (cell.subdetId() == HcalTriggerTower)
       continue;
     HcalTPChannelParameter item = dbHardcode.makeHardcodeTPChannelParameter(cell);
     result->addValues(item);
   }
   return result;
 }

◆ produceTPParameters()

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

protected

Definition at line 1035 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceValidationCorrs()

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

protected

Definition at line 798 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceZDCLowGainFractions()

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

protected

Definition at line 917 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ produceZSThresholds()

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

protected

Definition at line 751 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

◆ setIntervalFor()

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 425 of file HcalHardcodeCalibrations.cc.

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

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

Member Data Documentation

◆ dbHardcode

HcalDbHardcode HcalHardcodeCalibrations::dbHardcode

private

◆ hb_recalibration

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::hb_recalibration

private

Definition at line 151 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hbDarkeningToken_

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

private

Definition at line 157 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ he_recalibration

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::he_recalibration

private

Definition at line 152 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ heDarkeningToken_

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

private

Definition at line 156 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ hf_recalibration

std::unique_ptr<HFRecalibration> HcalHardcodeCalibrations::hf_recalibration

private

Definition at line 153 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ iLumi

double HcalHardcodeCalibrations::iLumi

private

Definition at line 150 of file HcalHardcodeCalibrations.h.

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

◆ setHBdsegm

bool HcalHardcodeCalibrations::setHBdsegm

private

Definition at line 160 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ setHEdsegm

bool HcalHardcodeCalibrations::setHEdsegm

private

Definition at line 159 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

◆ switchGainWidthsForTrigPrims

bool HcalHardcodeCalibrations::switchGainWidthsForTrigPrims

private

Definition at line 158 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceGainWidths().

◆ testHEPlan1

bool HcalHardcodeCalibrations::testHEPlan1

private

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

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

◆ useLayer0Weight

bool HcalHardcodeCalibrations::useLayer0Weight

private

Definition at line 161 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

◆ zdcTopoTokens_

std::unordered_map<int, edm::ESGetToken<ZdcTopology, HcalRecNumberingRecord> > HcalHardcodeCalibrations::zdcTopoTokens_

private

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

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

◆ producePFCuts()

◆ 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

◆ zdcTopoTokens_