#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

std::unique_ptr< HBHERecalibration >	hb_recalibration

std::unique_ptr< HBHERecalibration >	he_recalibration

std::unique_ptr< 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 126 of file HcalHardcodeCalibrations.cc.

                                                                                    : 
     hb_recalibration(nullptr), he_recalibration(nullptr), hf_recalibration(nullptr), setHEdsegm(false), setHBdsegm(false)
 {
   edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";
 
   if ( iConfig.exists("GainWidthsForTrigPrims") ) 
     switchGainWidthsForTrigPrims = iConfig.getParameter<bool>("GainWidthsForTrigPrims");
   else  switchGainWidthsForTrigPrims = false;
   
   //DB helper preparation
   dbHardcode.setHB(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hb")));
   dbHardcode.setHE(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("he")));
   dbHardcode.setHF(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hf")));
   dbHardcode.setHO(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("ho")));
   dbHardcode.setHBUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hbUpgrade")));
   dbHardcode.setHEUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("heUpgrade")));
   dbHardcode.setHFUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hfUpgrade")));
   dbHardcode.useHBUpgrade(iConfig.getParameter<bool>("useHBUpgrade"));
   dbHardcode.useHEUpgrade(iConfig.getParameter<bool>("useHEUpgrade"));
   dbHardcode.useHFUpgrade(iConfig.getParameter<bool>("useHFUpgrade"));
   dbHardcode.useHOUpgrade(iConfig.getParameter<bool>("useHOUpgrade"));
   dbHardcode.testHFQIE10(iConfig.getParameter<bool>("testHFQIE10"));
   dbHardcode.testHEPlan1(iConfig.getParameter<bool>("testHEPlan1"));
   dbHardcode.setKillHE(iConfig.getParameter<bool>("killHE"));
   dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));
 
   useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
   // HB, HE, HF recalibration preparation
   iLumi=iConfig.getParameter<double>("iLumi");
 
   if( iLumi > 0.0 ) {
     bool hb_recalib = iConfig.getParameter<bool>("HBRecalibration");
     bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
     bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
     if(hb_recalib) {
       hb_recalibration.reset(
         new HBHERecalibration(
           iLumi,
           iConfig.getParameter<double>("HBreCalibCutoff"),
           iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath()
         )
       );
     }
     if(he_recalib) {
       he_recalibration.reset(
         new HBHERecalibration(
           iLumi,
           iConfig.getParameter<double>("HEreCalibCutoff"),
           iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath()
         )
       );
     }
     if(hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())  hf_recalibration.reset(new HFRecalibration(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock")));
     
 #ifdef DebugLog
     std::cout << " HcalHardcodeCalibrations:  iLumi = " <<  iLumi << std::endl;
 #endif
   }
 
   std::vector <std::string> toGet = iConfig.getUntrackedParameter <std::vector <std::string> > ("toGet");
   for(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 307 of file HcalHardcodeCalibrations.cc.

308 {

309 }

Member Function Documentation

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

static

Definition at line 884 of file HcalHardcodeCalibrations.cc.

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

Referenced by produce().

                                                                                           {
     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.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_hb.add<bool>("doRadiationDamage", false);
     desc.add<edm::ParameterSetDescription>("hb", desc_hb);
 
     edm::ParameterSetDescription desc_hbRaddam;
     desc_hbRaddam.add<double>("temperatureBase",20.0);
     desc_hbRaddam.add<double>("temperatureNew",-5.0);
     desc_hbRaddam.add<double>("intlumiOffset",150);
     desc_hbRaddam.add<double>("depVsTemp",0.0631);
     desc_hbRaddam.add<double>("intlumiToNeutrons",3.67e8);
     desc_hbRaddam.add<std::vector<double>>("depVsNeutrons",{5.69e-11,7.90e-11});
 
     edm::ParameterSetDescription desc_hbUpgrade;
     desc_hbUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
     desc_hbUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
     desc_hbUpgrade.add<double>("pedestal", 18.0);
     desc_hbUpgrade.add<double>("pedestalWidth", 5.0);
     desc_hbUpgrade.add<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_hbUpgrade.add<bool>("doRadiationDamage", true);
     desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
     desc.add<edm::ParameterSetDescription>("hbUpgrade", desc_hbUpgrade);
 
     edm::ParameterSetDescription desc_he;
     desc_he.add<std::vector<double>>("gain", std::vector<double>({0.23}));
     desc_he.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
     desc_he.add<double>("pedestal", 3.0);
     desc_he.add<double>("pedestalWidth", 0.79);
     desc_he.add<std::vector<double>>("qieOffset", std::vector<double>({-0.38, 2.0, 7.6, 39.6}));
     desc_he.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.916, 0.92, 0.922}));
     desc_he.add<int>("qieType", 0);
     desc_he.add<int>("mcShape",125);
     desc_he.add<int>("recoShape",105);
     desc_he.add<double>("photoelectronsToAnalog",0.0);
     desc_he.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
     desc_he.add<bool>("doRadiationDamage", false);
     desc.add<edm::ParameterSetDescription>("he", desc_he);
 
     edm::ParameterSetDescription desc_heRaddam;
     desc_heRaddam.add<double>("temperatureBase",20.0);
     desc_heRaddam.add<double>("temperatureNew",5.0);
     desc_heRaddam.add<double>("intlumiOffset",75);
     desc_heRaddam.add<double>("depVsTemp",0.0631);
     desc_heRaddam.add<double>("intlumiToNeutrons",2.92e8);
     desc_heRaddam.add<std::vector<double>>("depVsNeutrons",{5.69e-11,7.90e-11});
 
     edm::ParameterSetDescription desc_heUpgrade;
     desc_heUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
     desc_heUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
     desc_heUpgrade.add<double>("pedestal", 18.0);
     desc_heUpgrade.add<double>("pedestalWidth", 5.0);
     desc_heUpgrade.add<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_heUpgrade.add<bool>("doRadiationDamage", true);
     desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
     desc.add<edm::ParameterSetDescription>("heUpgrade", desc_heUpgrade);
 
     edm::ParameterSetDescription desc_hf;
     desc_hf.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
     desc_hf.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
     desc_hf.add<double>("pedestal", 3.0);
     desc_hf.add<double>("pedestalWidth", 0.84);
     desc_hf.add<std::vector<double>>("qieOffset", std::vector<double>({-0.87, 1.4, 7.8, -29.6}));
     desc_hf.add<std::vector<double>>("qieSlope", std::vector<double>({0.359, 0.358, 0.36, 0.367}));
     desc_hf.add<int>("qieType", 0);
     desc_hf.add<int>("mcShape",301);
     desc_hf.add<int>("recoShape",301);
     desc_hf.add<double>("photoelectronsToAnalog",0.0);
     desc_hf.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
     desc_hf.add<bool>("doRadiationDamage", false);
     desc.add<edm::ParameterSetDescription>("hf", desc_hf);
 
     edm::ParameterSetDescription desc_hfUpgrade;
     desc_hfUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
     desc_hfUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
     desc_hfUpgrade.add<double>("pedestal", 13.33);
     desc_hfUpgrade.add<double>("pedestalWidth", 3.33);
     desc_hfUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0697, -0.7405, 12.38, -671.9}));
     desc_hfUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.297, 0.298, 0.298, 0.313}));
     desc_hfUpgrade.add<int>("qieType", 1);
     desc_hfUpgrade.add<int>("mcShape",301);
     desc_hfUpgrade.add<int>("recoShape",301);
     desc_hfUpgrade.add<double>("photoelectronsToAnalog",0.0);
     desc_hfUpgrade.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
     desc_hfUpgrade.add<bool>("doRadiationDamage", false);
     desc.add<edm::ParameterSetDescription>("hfUpgrade", desc_hfUpgrade);
   
     edm::ParameterSetDescription desc_hfrecal;
     desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterA", std::vector<double>());
     desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterB", std::vector<double>());
     desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterA", std::vector<double>());
     desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterB", std::vector<double>());
     desc.add<edm::ParameterSetDescription>("HFRecalParameterBlock", desc_hfrecal);
 
     edm::ParameterSetDescription desc_ho;
     desc_ho.add<std::vector<double>>("gain", std::vector<double>({0.006, 0.0087}));
     desc_ho.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
     desc_ho.add<double>("pedestal", 11.0);
     desc_ho.add<double>("pedestalWidth", 0.57);
     desc_ho.add<std::vector<double>>("qieOffset", std::vector<double>({-0.44, 1.4, 7.1, 38.5}));
     desc_ho.add<std::vector<double>>("qieSlope", std::vector<double>({0.907, 0.915, 0.92, 0.921}));
     desc_ho.add<int>("qieType", 0);
     desc_ho.add<int>("mcShape",201);
     desc_ho.add<int>("recoShape",201);
     desc_ho.add<double>("photoelectronsToAnalog",4.0);
     desc_ho.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
     desc_ho.add<bool>("doRadiationDamage", false);
     desc.add<edm::ParameterSetDescription>("ho", desc_ho);
 
     edm::ParameterSetDescription validator_sipm;
     validator_sipm.add<int>("pixels",1);
     validator_sipm.add<double>("crosstalk",0);
     validator_sipm.add<double>("nonlin1",1);
     validator_sipm.add<double>("nonlin2",0);
     validator_sipm.add<double>("nonlin3",0);
     std::vector<edm::ParameterSet> default_sipm(1);
     desc.addVPSet("SiPMCharacteristics",validator_sipm,default_sipm);
     
     descriptions.addDefault(desc);
 }

void HcalHardcodeCalibrations::produce ( )

inline

Definition at line 58 of file HcalHardcodeCalibrations.h.

References fillDescriptions(), produceChannelQuality(), produceDcsMap(), produceDcsValues(), produceElectronicsMap(), produceFlagHFDigiTimeParams(), produceFrontEndMap(), produceGains(), produceGainWidths(), produceL1TriggerObjects(), produceLongRecoParams(), produceLUTCorrs(), produceLutMetadata(), produceMCParams(), producePedestals(), producePedestalWidths(), producePFCorrs(), produceQIEData(), produceQIETypes(), produceRecoParams(), produceRespCorrs(), produceSiPMCharacteristics(), produceSiPMParameters(), produceTimeCorrs(), produceTimingParams(), produceTPChannelParameters(), produceTPParameters(), produceValidationCorrs(), produceZDCLowGainFractions(), produceZSThresholds(), and setIntervalFor().

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 424 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                    {
   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 702 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeDcsMap().

Referenced by HcalHardcodeCalibrations(), and produce().

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

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

protected

Definition at line 696 of file HcalHardcodeCalibrations.cc.

References mps_fire::result.

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                               {
   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 598 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                    {
   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());
   return dbHardcode.makeHardcodeMap(cells);
 }

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

protected

Definition at line 800 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                                      {
   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 828 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                           {
   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());
 
   return dbHardcode.makeHardcodeFrontEndMap(cells);
 }

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

protected

Definition at line 351 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                         {
   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 366 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                        {
   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 579 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                          {
   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 738 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                    {
   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 518 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                  {
   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 623 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                           {
   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;
         // granularity is equal to 1 only for |ieta| == 17
         if(id.ietaAbs() >= 18 && id.ietaAbs() <= 26) granularity = 2;
         else if(id.ietaAbs() >=27 && id.ietaAbs() <= 29) granularity = 5;
          }
              break;
         case HcalGenericDetId::HcalGenForward:
              rcalib = 1.02;
              break;
          default:
              break;
        }
 
        if (cell.isHcalTrigTowerDetId()) {
       rcalib = 0.;
       HcalTrigTowerDetId id(cell);
       if(id.ietaAbs() <= 17) {
         granularity = 1;
         threshold = 4;
       }
       else if(id.ietaAbs() >= 18 && id.ietaAbs() <= 26) {
         granularity = 2;
         threshold = 2;
       }
       else if(id.ietaAbs() >= 27 && id.ietaAbs() <= 28) {
         granularity = 5;
         threshold = 1;
       }
       else {
         granularity = 0;
         threshold = 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 779 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                  {
 
 
   //  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 321 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                     {
   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 336 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                    {
   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 533 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                               {
   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 388 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                               {
   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 409 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                  {
   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 708 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                        {
   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 440 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                     {
   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)){
     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){
       edm::ESHandle<HBHEDarkening> hdark;
       rcd.getRecord<HBHEDarkeningRecord>().get("HE",hdark);
       he_recalibration->setup(m_segmentation,&*hdark);
       setHEdsegm = true;
     }
     if(hb_recalibration && !setHBdsegm){
       edm::ESHandle<HBHEDarkening> hdark;
       rcd.getRecord<HBHEDarkeningRecord>().get("HB",hdark);
       hb_recalibration->setup(m_segmentation,&*hdark);
       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 ((hb_recalibration != 0 ) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
       int depth_ = HcalDetId(cell).depth();
       int ieta_  = HcalDetId(cell).ieta();
       corr *= hb_recalibration->getCorr(ieta_, depth_); 
 #ifdef DebugLog      
       std::cout << "HB ieta, depth = " << ieta_  << ",  " << depth_ << "   corr = "  << corr << std::endl;
 #endif
     }
     else if ((he_recalibration != 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 854 of file HcalHardcodeCalibrations.cc.

References dbHardcode, and HcalDbHardcode::makeHardcodeSiPMCharacteristics().

Referenced by HcalHardcodeCalibrations(), and produce().

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

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

protected

Definition at line 839 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                    {
   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,iLumi);
     result->addValues(item);
   }
   return result;
 }

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

protected

Definition at line 548 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                     {
   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 723 of file HcalHardcodeCalibrations.cc.

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

Referenced by produce().

                                                                                                              {
   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 861 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                                   {
   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 876 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                              {
   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 608 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                       {
   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 764 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                                   {
   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 563 of file HcalHardcodeCalibrations.cc.

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

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                              {
   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 315 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().

Referenced by produce().

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