#include <HcalHardcodeCalibrations.h>

Inheritance diagram for HcalHardcodeCalibrations:

Public Member Functions
	HcalHardcodeCalibrations (const edm::ParameterSet &)

void	produce ()

	~HcalHardcodeCalibrations ()

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

virtual	~ESProducer ()(false)

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

virtual void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval)
	overrides DataProxyProvider method More...

virtual	~ESProxyFactoryProducer () noexcept(false)

Public Member Functions inherited from edm::eventsetup::DataProxyProvider
	DataProxyProvider ()

const ComponentDescription &	description () const

bool	isUsingRecord (const EventSetupRecordKey &) const

const KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey) const

void	resetProxies (const EventSetupRecordKey &iRecordType)

void	resetProxiesIfTransient (const EventSetupRecordKey &iRecordType)

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
const eventsetup::ComponentDescription &	descriptionForFinder () const

	EventSetupRecordIntervalFinder ()

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

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

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 < 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 < HcalPedestalWidths >	producePedestalWidths (const HcalPedestalWidthsRcd &rcd)

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)

virtual void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &)

Protected Member Functions inherited from edm::ESProducer
template<typename T >
void	setWhatProduced (T *iThis, const es::Label &iLabel=es::Label())

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

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

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

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

template<typename T , typename TReturn , typename TRecord , typename TArg >
void	setWhatProduced (T iThis, TReturn(T::iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel=es::Label())

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 eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())

virtual void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList)
	override DataProxyProvider method More...

Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
void	eraseAll (const EventSetupRecordKey &iRecordKey)
	deletes all the Proxies in aStream More...

void	invalidateProxies (const EventSetupRecordKey &iRecordKey)

template<class T >
void	usingRecord ()

void	usingRecordWithKey (const EventSetupRecordKey &)

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

void	findingRecordWithKey (const eventsetup::EventSetupRecordKey &)

Private Attributes
HcalDbHardcode	dbHardcode

HERecalibration *	he_recalibration

HFRecalibration *	hf_recalibration

double	iLumi

bool	setHBdsegm

bool	setHEdsegm

bool	switchGainWidthsForTrigPrims

bool	useLayer0Weight

Additional Inherited Members
Public Types inherited from edm::eventsetup::DataProxyProvider
typedef std::vector< std::pair < DataKey, edm::propagate_const < std::shared_ptr< DataProxy > > > >	KeyedProxies

typedef std::vector < EventSetupRecordKey >	Keys

typedef std::map < EventSetupRecordKey, KeyedProxies >	RecordProxies

Detailed Description

Definition at line 52 of file HcalHardcodeCalibrations.h.

Constructor & Destructor Documentation

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

Definition at line 125 of file HcalHardcodeCalibrations.cc.

                                                                                    : 
     he_recalibration(0), hf_recalibration(0), 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.setKillHE(iConfig.getParameter<bool>("killHE"));
   dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));
 
   useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
   // HE and HF recalibration preparation
   iLumi=iConfig.getParameter<double>("iLumi");
 
   if( iLumi > 0.0 ) {
     bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
     bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
     if(he_recalib) {
       double cutoff = iConfig.getParameter<double>("HEreCalibCutoff"); 
       he_recalibration = new HERecalibration(iLumi,cutoff);
     }
     if(hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())  hf_recalibration = 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(std::vector <std::string>::iterator objectName = toGet.begin(); objectName != toGet.end(); ++objectName ) {
     bool all = *objectName == "all";
 #ifdef DebugLog
     std::cout << "Load parameters for " << *objectName << std::endl;
 #endif
     if ((*objectName == "Pedestals") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::producePedestals);
       findingRecord <HcalPedestalsRcd> ();
     }
     if ((*objectName == "PedestalWidths") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::producePedestalWidths);
       findingRecord <HcalPedestalWidthsRcd> ();
     }
     if ((*objectName == "Gains") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceGains);
       findingRecord <HcalGainsRcd> ();
     }
     if ((*objectName == "GainWidths") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceGainWidths);
       findingRecord <HcalGainWidthsRcd> ();
     }
     if ((*objectName == "QIEData") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceQIEData);
       findingRecord <HcalQIEDataRcd> ();
     }
     if ((*objectName == "QIETypes") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceQIETypes);
       findingRecord <HcalQIETypesRcd> ();
     }
     if ((*objectName == "ChannelQuality") || (*objectName == "channelQuality") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceChannelQuality);
       findingRecord <HcalChannelQualityRcd> ();
     }
     if ((*objectName == "ElectronicsMap") || (*objectName == "electronicsMap") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceElectronicsMap);
       findingRecord <HcalElectronicsMapRcd> ();
     }
     if ((*objectName == "ZSThresholds") || (*objectName == "zsThresholds") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceZSThresholds);
       findingRecord <HcalZSThresholdsRcd> ();
     }
     if ((*objectName == "RespCorrs") || (*objectName == "ResponseCorrection") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceRespCorrs);
       findingRecord <HcalRespCorrsRcd> ();
     }
     if ((*objectName == "LUTCorrs") || (*objectName == "LUTCorrection") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceLUTCorrs);
       findingRecord <HcalLUTCorrsRcd> ();
     }
     if ((*objectName == "PFCorrs") || (*objectName == "PFCorrection") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::producePFCorrs);
       findingRecord <HcalPFCorrsRcd> ();
     }
     if ((*objectName == "TimeCorrs") || (*objectName == "TimeCorrection") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceTimeCorrs);
       findingRecord <HcalTimeCorrsRcd> ();
     }
     if ((*objectName == "L1TriggerObjects") || (*objectName == "L1Trigger") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceL1TriggerObjects);
       findingRecord <HcalL1TriggerObjectsRcd> ();
     }
     if ((*objectName == "ValidationCorrs") || (*objectName == "ValidationCorrection") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceValidationCorrs);
       findingRecord <HcalValidationCorrsRcd> ();
     }
     if ((*objectName == "LutMetadata") || (*objectName == "lutMetadata") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceLutMetadata);
       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);
       findingRecord <HcalRecoParamsRcd> ();
     }
     if ((*objectName == "LongRecoParams") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceLongRecoParams);
       findingRecord <HcalLongRecoParamsRcd> ();
     }
     if ((*objectName == "ZDCLowGainFractions") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceZDCLowGainFractions);
       findingRecord <HcalZDCLowGainFractionsRcd> ();
     }
     if ((*objectName == "MCParams") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceMCParams);
       findingRecord <HcalMCParamsRcd> ();
     }
     if ((*objectName == "FlagHFDigiTimeParams") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceFlagHFDigiTimeParams);
       findingRecord <HcalFlagHFDigiTimeParamsRcd> ();
     }
     if ((*objectName == "FrontEndMap") || (*objectName == "frontEndMap") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceFrontEndMap);
       findingRecord <HcalFrontEndMapRcd> ();
     }
     if ((*objectName == "SiPMParameters") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceSiPMParameters);
       findingRecord <HcalSiPMParametersRcd> ();
     }
     if ((*objectName == "SiPMCharacteristics") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceSiPMCharacteristics);
       findingRecord <HcalSiPMCharacteristicsRcd> ();
     }
     if ((*objectName == "TPChannelParameters") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceTPChannelParameters);
       findingRecord <HcalTPChannelParametersRcd> ();
     }
     if ((*objectName == "TPParameters") || all) {
       setWhatProduced (this, &HcalHardcodeCalibrations::produceTPParameters);
       findingRecord <HcalTPParametersRcd> ();
     }
   }
 }

HcalHardcodeCalibrations::~HcalHardcodeCalibrations ( )

Definition at line 290 of file HcalHardcodeCalibrations.cc.

References he_recalibration, and hf_recalibration.

 {
   if (he_recalibration != 0 ) delete he_recalibration;
   if (hf_recalibration != 0 ) delete hf_recalibration;
 }

Member Function Documentation

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

static

Definition at line 848 of file HcalHardcodeCalibrations.cc.

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

                                                                                           {
     edm::ParameterSetDescription desc;
     desc.add<double>("iLumi",-1.);
     desc.add<bool>("HERecalibration",false);
     desc.add<double>("HEreCalibCutoff",20.);
     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>("killHE",false);
     desc.add<bool>("useLayer0Weight",false);
     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<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.add<edm::ParameterSetDescription>("hb", desc_hb);
 
     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<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",203);
     desc_hbUpgrade.add<int>("recoShape",203);
     desc_hbUpgrade.add<double>("photoelectronsToAnalog",57.5);
     desc_hbUpgrade.add<std::vector<double>>("darkCurrent",std::vector<double>(0.055));
     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<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.add<edm::ParameterSetDescription>("he", desc_he);
 
     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<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",203);
     desc_heUpgrade.add<int>("recoShape",203);
     desc_heUpgrade.add<double>("photoelectronsToAnalog",57.5);
     desc_heUpgrade.add<std::vector<double>>("darkCurrent",std::vector<double>(0.055));
     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<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.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<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.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<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.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);
 }

void HcalHardcodeCalibrations::produce ( )

inline

Definition at line 58 of file HcalHardcodeCalibrations.h.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

58 {};

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

protected

Definition at line 409 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceChannelQuality-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalChannelQuality>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalChannelStatus item(cell->rawId(),0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 660 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                            {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceDcsMap-> ...";
 
   auto result = std::make_unique<HcalDcsMap>();
   dbHardcode.makeHardcodeDcsMap(*result);
   return result;
 }

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

protected

Definition at line 654 of file HcalHardcodeCalibrations.cc.

References mps_fire::result.

Referenced by HcalHardcodeCalibrations().

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

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

protected

Definition at line 574 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeMap(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceElectronicsMap-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   auto result = std::make_unique<HcalElectronicsMap>();
   dbHardcode.makeHardcodeMap(*result,cells);
   return result;
 }

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

protected

Definition at line 760 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                                      {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFlagHFDigiTimeParams-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalFlagHFDigiTimeParams>(topo);
   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 (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalFlagHFDigiTimeParam item(cell->rawId(),
                  1, //firstsample
                  3, // samplestoadd
                  2, //expectedpeak
                  40., // min energy threshold
                  coef // coefficients
                  );
     result->addValues(item);
   }
   return result;
 } 

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

protected

Definition at line 788 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeFrontEndMap(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                           {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceFrontEndMap-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
 
   auto result = std::make_unique<HcalFrontEndMap>();
   dbHardcode.makeHardcodeFrontEndMap(*result, cells);
   return result;
 }

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

protected

Definition at line 336 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeGain(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                         {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGains-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalGains>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalGain item = dbHardcode.makeGain (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 351 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeGainWidth(), mps_fire::result, and switchGainWidthsForTrigPrims.

Referenced by HcalHardcodeCalibrations().

                                                                                                        {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceGainWidths-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalGainWidths>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
 
     // 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;
 }

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

protected

Definition at line 555 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                          {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceL1TriggerObjects-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalL1TriggerObjects>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalL1TriggerObject item(cell->rawId(),0., 1., 0);
     result->addValues(item);
   }
   // add tag and algo values
   result->setTagString("hardcoded");
   result->setAlgoString("hardcoded");
   return result;
 }

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

protected

Definition at line 698 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLongRecoParams-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalLongRecoParams>(topo);
   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 (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     if (cell->isHcalZDCDetId())
       {
     HcalLongRecoParam item(cell->rawId(),mSignal,mNoise);
     result->addValues(item);
       }
   }
   return result;
 }

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

protected

Definition at line 494 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                  {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLUTCorrs-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalLUTCorrs>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalLUTCorr item(cell->rawId(),1.0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 601 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalGenericDetId::HcalGenBarrel, HcalGenericDetId::HcalGenEndcap, HcalGenericDetId::HcalGenForward, HcalDbHardcode::killHE(), or, mps_fire::result, dtDQMClient_cfg::threshold, HcalDbHardcode::useHEUpgrade(), and HcalDbHardcode::useHFUpgrade().

Referenced by HcalHardcodeCalibrations().

                                                                                                           {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceLutMetadata-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalLutMetadata>(topo);
 
   result->setRctLsb( 0.5 );
   result->setNominalGain(0.177);  // for HBHE SiPMs
 
   std::vector <HcalGenericDetId> cells = allCells(*topo,dbHardcode.killHE());
   for (const auto& cell: cells) {
     float rcalib = 1.;
     int granularity = 1;
     int threshold = 1;
 
     if (dbHardcode.useHEUpgrade() or dbHardcode.useHFUpgrade()) {
        // Use values from 2016 as starting conditions for 2017+.  These are
        // averaged over the subdetectors, with the last two HE towers split
        // off due to diverging correction values.
        switch (cell.genericSubdet()) {
           case HcalGenericDetId::HcalGenBarrel:
              rcalib = 1.128;
              break;
          case HcalGenericDetId::HcalGenEndcap:
              {
                 HcalDetId id(cell);
                 if (id.ietaAbs() >= 28)
                    rcalib = 1.188;
                 else
                    rcalib = 1.117;
              }
              break;
          case HcalGenericDetId::HcalGenForward:
              rcalib = 1.02;
              break;
          default:
              break;
        }
 
        if (cell.isHcalTrigTowerDetId()) {
           rcalib = 0.;
        }
     }
 
     HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
     result->addValues(item);
   }
   
   return result;
 }

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

protected

Definition at line 739 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeMCParam(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                  {
 
 
   //  std::cout << std::endl << " .... HcalHardcodeCalibrations::produceMCParams ->"<< std::endl;
 
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceMCParams-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
   auto result = std::make_unique<HcalMCParams>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
 
     //    HcalMCParam item(cell->rawId(),0);
     HcalMCParam item = dbHardcode.makeMCParam (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 306 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makePedestal(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                     {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePedestals-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalPedestals>(topo,false);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalPedestal item = dbHardcode.makePedestal (*cell, false);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 321 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makePedestalWidth(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePedestalWidths-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalPedestalWidths>(topo,false);
   std::vector <HcalGenericDetId> cells = allCells(*htopo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalPedestalWidth item = dbHardcode.makePedestalWidth (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 509 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                               {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::producePFCorrs-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalPFCorrs>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalPFCorr item(cell->rawId(),1.0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 373 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                               {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIEData-> ...";
 
   /*
   std::cout << std::endl << ">>>  HcalHardcodeCalibrations::produceQIEData"
         << std::endl;  
   */
 
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalQIEData>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalQIECoder coder = dbHardcode.makeQIECoder (*cell);
     result->addCoder (coder);
   }
   return result;
 }

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

protected

Definition at line 394 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeQIEType(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                  {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceQIETypes-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
     auto result = std::make_unique<HcalQIETypes>(topo);
     std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalQIEType item = dbHardcode.makeQIEType(*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 668 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeRecoParam(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                        {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRecoParams-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalRecoParams>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalRecoParam item = dbHardcode.makeRecoParam (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 425 of file HcalHardcodeCalibrations.cc.

References corr, gather_cfg::cout, dbHardcode, HcalDetId::depth(), HLT_25ns10e33_v2_cff::depth, HERecalibration::getCorr(), HFRecalibration::getCorr(), HcalTopology::getDepthSegmentation(), HcalDbHardcode::getLayersInDepth(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalGenericDetId::HcalGenBarrel, HcalGenericDetId::HcalGenEndcap, HcalGenericDetId::HcalGenForward, he_recalibration, hf_recalibration, i, HcalDetId::ieta(), iLumi, HcalDbHardcode::killHE(), HcalTopology::lastHERing(), maxEta, mps_fire::result, HERecalibration::setDsegm(), setHEdsegm, and useLayer0Weight.

Referenced by HcalHardcodeCalibrations().

                                                                                                     {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceRespCorrs-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
  
   //set depth segmentation for HB/HE recalib - only happens once
 //  if((he_recalibration && !setHEdsegm) || (hb_recalibration && !setHBdsegm)){
   if((he_recalibration && !setHEdsegm)) {
     std::vector<std::vector<int>> m_segmentation;
     int maxEta = topo->lastHERing();
     m_segmentation.resize(maxEta);
     for (int i = 0; i < maxEta; i++) {
       topo->getDepthSegmentation(i+1,m_segmentation[i]);
     }
     if(he_recalibration && !setHEdsegm){
       he_recalibration->setDsegm(m_segmentation);
       setHEdsegm = true;
     }
     /*
     if(hb_recalibration && !setHBdsegm){
       hb_recalibration->setDsegm(m_segmentation);
       setHBdsegm = true;
     }
     */
   }
  
   auto result = std::make_unique<HcalRespCorrs>(topo);
   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 ((he_recalibration != 0 ) && (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 != 0 ) && (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;
 }

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

protected

Definition at line 816 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

                                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMCharacteristics-> ...";
 
   auto result = std::make_unique<HcalSiPMCharacteristics>();
   dbHardcode.makeHardcodeSiPMCharacteristics(*result);
   return result;
 }

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

protected

Definition at line 801 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeSiPMParameter(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                    {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceSiPMParameters-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalSiPMParameters>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*htopo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalSiPMParameter item = dbHardcode.makeHardcodeSiPMParameter (*cell,topo);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 524 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                     {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimeCorrs-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalTimeCorrs>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalTimeCorr item(cell->rawId(),0.0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 683 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeTimingParam(), and mps_fire::result.

                                                                                                              {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTimingParams-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalTimingParams>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalTimingParam item = dbHardcode.makeTimingParam (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 825 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeHardcodeTPChannelParameter(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceTPChannelParameters-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalTPChannelParameters>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*htopo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalTPChannelParameter item = dbHardcode.makeHardcodeTPChannelParameter (*cell);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 840 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations().

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

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

protected

Definition at line 586 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                       {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceValidationCorrs-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalValidationCorrs>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalValidationCorr item(cell->rawId(),1.0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 724 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                                                   {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZDCLowGainFractions-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rec.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalZDCLowGainFractions>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalZDCLowGainFraction item(cell->rawId(),0.0);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 539 of file HcalHardcodeCalibrations.cc.

References dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), and mps_fire::result.

Referenced by HcalHardcodeCalibrations().

                                                                                                              {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produceZSThresholds-> ...";
   edm::ESHandle<HcalTopology> htopo;
   rcd.getRecord<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* topo=&(*htopo);
 
   auto result = std::make_unique<HcalZSThresholds>(topo);
   std::vector <HcalGenericDetId> cells = allCells(*topo, dbHardcode.killHE());
   for (std::vector <HcalGenericDetId>::const_iterator cell = cells.begin (); cell != cells.end (); ++cell) {
     HcalZSThreshold item(cell->rawId(),0);
     result->addValues(item);
   }
   return result;
 }

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

protectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 300 of file HcalHardcodeCalibrations.cc.

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

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