HcalHardcodeCalibrations Class Reference

#include <HcalHardcodeCalibrations.h>

Inheritance diagram for HcalHardcodeCalibrations:

Public Member Functions
	HcalHardcodeCalibrations (const edm::ParameterSet &)
void	produce ()
	~HcalHardcodeCalibrations () override
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	~ESProducer ()(false) override
Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()
void	newInterval (const eventsetup::EventSetupRecordKey &iRecordType, const ValidityInterval &iInterval) override
	overrides DataProxyProvider method More...
	~ESProxyFactoryProducer () noexcept(false) override
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< HcalPedestals >	produceEffectivePedestals (const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalPedestalWidths >	produceEffectivePedestalWidths (const HcalPedestalWidthsRcd &rcd)
std::unique_ptr< HcalElectronicsMap >	produceElectronicsMap (const HcalElectronicsMapRcd &rcd)
std::unique_ptr< HcalFlagHFDigiTimeParams >	produceFlagHFDigiTimeParams (const HcalFlagHFDigiTimeParamsRcd &rcd)
std::unique_ptr< HcalFrontEndMap >	produceFrontEndMap (const HcalFrontEndMapRcd &rcd)
std::unique_ptr< HcalGains >	produceGains (const HcalGainsRcd &rcd)
std::unique_ptr< HcalGainWidths >	produceGainWidths (const HcalGainWidthsRcd &rcd)
std::unique_ptr< HcalL1TriggerObjects >	produceL1TriggerObjects (const HcalL1TriggerObjectsRcd &rcd)
std::unique_ptr< HcalLongRecoParams >	produceLongRecoParams (const HcalLongRecoParamsRcd &rcd)
std::unique_ptr< HcalLUTCorrs >	produceLUTCorrs (const HcalLUTCorrsRcd &rcd)
std::unique_ptr< HcalLutMetadata >	produceLutMetadata (const HcalLutMetadataRcd &rcd)
std::unique_ptr< HcalMCParams >	produceMCParams (const HcalMCParamsRcd &rcd)
std::unique_ptr< HcalPedestals >	producePedestals (const HcalPedestalsRcd &rcd)
std::unique_ptr< HcalPedestals >	producePedestals_ (const HcalPedestalsRcd &rcd, bool eff)
std::unique_ptr< HcalPedestalWidths >	producePedestalWidths (const HcalPedestalWidthsRcd &rcd)
std::unique_ptr< HcalPedestalWidths >	producePedestalWidths_ (const HcalPedestalWidthsRcd &rcd, bool eff)
std::unique_ptr< HcalPFCorrs >	producePFCorrs (const HcalPFCorrsRcd &rcd)
std::unique_ptr< HcalQIEData >	produceQIEData (const HcalQIEDataRcd &rcd)
std::unique_ptr< HcalQIETypes >	produceQIETypes (const HcalQIETypesRcd &rcd)
std::unique_ptr< HcalRecoParams >	produceRecoParams (const HcalRecoParamsRcd &rcd)
std::unique_ptr< HcalRespCorrs >	produceRespCorrs (const HcalRespCorrsRcd &rcd)
std::unique_ptr< HcalSiPMCharacteristics >	produceSiPMCharacteristics (const HcalSiPMCharacteristicsRcd &rcd)
std::unique_ptr< HcalSiPMParameters >	produceSiPMParameters (const HcalSiPMParametersRcd &rcd)
std::unique_ptr< HcalTimeCorrs >	produceTimeCorrs (const HcalTimeCorrsRcd &rcd)
std::unique_ptr< HcalTimingParams >	produceTimingParams (const HcalTimingParamsRcd &rcd)
std::unique_ptr< HcalTPChannelParameters >	produceTPChannelParameters (const HcalTPChannelParametersRcd &rcd)
std::unique_ptr< HcalTPParameters >	produceTPParameters (const HcalTPParametersRcd &rcd)
std::unique_ptr< HcalValidationCorrs >	produceValidationCorrs (const HcalValidationCorrsRcd &rcd)
std::unique_ptr< HcalZDCLowGainFractions >	produceZDCLowGainFractions (const HcalZDCLowGainFractionsRcd &rcd)
std::unique_ptr< HcalZSThresholds >	produceZSThresholds (const HcalZSThresholdsRcd &rcd)
void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &) override
Protected Member Functions inherited from edm::ESProducer
	ESProducer (const ESProducer &)=delete
ESProducer const &	operator= (const ESProducer &)=delete
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &iLabel={})
template<typename T >
auto	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatProduced (T *iThis, const std::string &iLabel)
template<typename T , typename TDecorator >
auto	setWhatProduced (T *iThis, const TDecorator &iDec, const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord >
auto	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const es::Label &iLabel={})
template<typename T , typename TReturn , typename TRecord , typename TArg >
ESConsumesCollector	setWhatProduced (T *iThis, TReturn(T::*iMethod)(const TRecord &), const TArg &iDec, const es::Label &iLabel={})
Protected Member Functions inherited from edm::ESProxyFactoryProducer
template<class TFactory >
void	registerFactory (std::unique_ptr< TFactory > iFactory, const std::string &iLabel=std::string())
virtual void	registerFactoryWithKey (const eventsetup::EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())
void	registerProxies (const eventsetup::EventSetupRecordKey &iRecord, KeyedProxies &aProxyList) override
	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	testHEPlan1
bool	useIeta18depth1
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 53 of file HcalHardcodeCalibrations.h.

Constructor & Destructor Documentation

HcalHardcodeCalibrations::HcalHardcodeCalibrations

(

const edm::ParameterSet &

iConfig

)

Definition at line 128 of file HcalHardcodeCalibrations.cc.

References Vispa.Plugins.EdmBrowser.EdmDataAccessor::all(), gather_cfg::cout, dbHardcode, edm::ParameterSet::empty(), edm::ParameterSet::exists(), edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hb_recalibration, he_recalibration, hf_recalibration, iLumi, summarizeEdmComparisonLogfiles::objectName, produceChannelQuality(), produceDcsMap(), produceDcsValues(), produceEffectivePedestals(), produceEffectivePedestalWidths(), produceElectronicsMap(), produceFlagHFDigiTimeParams(), produceFrontEndMap(), produceGains(), produceGainWidths(), produceL1TriggerObjects(), produceLongRecoParams(), produceLUTCorrs(), produceLutMetadata(), produceMCParams(), producePedestals(), producePedestalWidths(), producePFCorrs(), produceQIEData(), produceQIETypes(), produceRecoParams(), produceRespCorrs(), produceSiPMCharacteristics(), produceSiPMParameters(), produceTimeCorrs(), produceTPChannelParameters(), produceTPParameters(), produceValidationCorrs(), produceZDCLowGainFractions(), produceZSThresholds(), HcalDbHardcode::setHB(), HcalDbHardcode::setHBUpgrade(), HcalDbHardcode::setHE(), HcalDbHardcode::setHEUpgrade(), HcalDbHardcode::setHF(), HcalDbHardcode::setHFUpgrade(), HcalDbHardcode::setHO(), HcalDbHardcode::setKillHE(), HcalDbHardcode::setSiPMCharacteristics(), edm::ESProducer::setWhatProduced(), switchGainWidthsForTrigPrims, HcalDbHardcode::testHEPlan1(), testHEPlan1, HcalDbHardcode::testHFQIE10(), DBConfiguration_cff::toGet, HcalDbHardcode::useHBUpgrade(), HcalDbHardcode::useHEUpgrade(), HcalDbHardcode::useHFUpgrade(), HcalDbHardcode::useHOUpgrade(), useIeta18depth1, and useLayer0Weight.

                                                                                   : 
    hb_recalibration(nullptr), he_recalibration(nullptr), hf_recalibration(nullptr), setHEdsegm(false), setHBdsegm(false)
{
  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::HcalHardcodeCalibrations->...";

  if ( iConfig.exists("GainWidthsForTrigPrims") ) 
    switchGainWidthsForTrigPrims = iConfig.getParameter<bool>("GainWidthsForTrigPrims");
  else  switchGainWidthsForTrigPrims = false;
  
  //DB helper preparation
  dbHardcode.setHB(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hb")));
  dbHardcode.setHE(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("he")));
  dbHardcode.setHF(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hf")));
  dbHardcode.setHO(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("ho")));
  dbHardcode.setHBUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hbUpgrade")));
  dbHardcode.setHEUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("heUpgrade")));
  dbHardcode.setHFUpgrade(HcalHardcodeParameters(iConfig.getParameter<edm::ParameterSet>("hfUpgrade")));
  dbHardcode.useHBUpgrade(iConfig.getParameter<bool>("useHBUpgrade"));
  dbHardcode.useHEUpgrade(iConfig.getParameter<bool>("useHEUpgrade"));
  dbHardcode.useHFUpgrade(iConfig.getParameter<bool>("useHFUpgrade"));
  dbHardcode.useHOUpgrade(iConfig.getParameter<bool>("useHOUpgrade"));
  dbHardcode.testHFQIE10(iConfig.getParameter<bool>("testHFQIE10"));
  dbHardcode.testHEPlan1(iConfig.getParameter<bool>("testHEPlan1"));
  dbHardcode.setKillHE(iConfig.getParameter<bool>("killHE"));
  dbHardcode.setSiPMCharacteristics(iConfig.getParameter<std::vector<edm::ParameterSet>>("SiPMCharacteristics"));

  useLayer0Weight = iConfig.getParameter<bool>("useLayer0Weight");
  useIeta18depth1 = iConfig.getParameter<bool>("useIeta18depth1");
  testHEPlan1     = iConfig.getParameter<bool>("testHEPlan1");
  // HB, HE, HF recalibration preparation
  iLumi=iConfig.getParameter<double>("iLumi");

  if( iLumi > 0.0 ) {
    bool hb_recalib = iConfig.getParameter<bool>("HBRecalibration");
    bool he_recalib = iConfig.getParameter<bool>("HERecalibration");
    bool hf_recalib = iConfig.getParameter<bool>("HFRecalibration");
    if(hb_recalib) {
      hb_recalibration.reset(
        new HBHERecalibration(
          iLumi,
          iConfig.getParameter<double>("HBreCalibCutoff"),
          iConfig.getParameter<edm::FileInPath>("HBmeanenergies").fullPath()
        )
      );
    }
    if(he_recalib) {
      he_recalibration.reset(
        new HBHERecalibration(
          iLumi,
          iConfig.getParameter<double>("HEreCalibCutoff"),
          iConfig.getParameter<edm::FileInPath>("HEmeanenergies").fullPath()
        )
      );
    }
    if(hf_recalib && !iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock").empty())  hf_recalibration.reset(new HFRecalibration(iConfig.getParameter<edm::ParameterSet>("HFRecalParameterBlock")));
    
#ifdef DebugLog
    std::cout << " HcalHardcodeCalibrations:  iLumi = " <<  iLumi << std::endl;
#endif
  }

  std::vector <std::string> toGet = iConfig.getUntrackedParameter <std::vector <std::string> > ("toGet");
  for(auto& objectName : toGet){
    bool all = objectName == "all";
#ifdef DebugLog
    std::cout << "Load parameters for " << objectName << std::endl;
#endif
    if ((objectName == "Pedestals") || all) {
      setWhatProduced (this, &HcalHardcodeCalibrations::producePedestals);
      findingRecord <HcalPedestalsRcd> ();
    }
    if ((objectName == "PedestalWidths") || all) {
      setWhatProduced (this, &HcalHardcodeCalibrations::producePedestalWidths);
      findingRecord <HcalPedestalWidthsRcd> ();
    }
    if ((objectName == "EffectivePedestals") || all) {
      setWhatProduced (this, &HcalHardcodeCalibrations::produceEffectivePedestals, edm::es::Label("effective"));
      findingRecord <HcalPedestalsRcd> ();
    }
    if ((objectName == "EffectivePedestalWidths") || all) {
      setWhatProduced (this, &HcalHardcodeCalibrations::produceEffectivePedestalWidths, edm::es::Label("effective"));
      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 ( )

override

Definition at line 319 of file HcalHardcodeCalibrations.cc.

{
}

Member Function Documentation

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

static

Definition at line 897 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.add<bool>("useIeta18depth1",true);
    desc.addUntracked<std::vector<std::string> >("toGet",std::vector<std::string>());
    desc.addUntracked<bool>("fromDDD",false);

    edm::ParameterSetDescription desc_hb;
    desc_hb.add<std::vector<double>>("gain", std::vector<double>({0.19}));
    desc_hb.add<std::vector<double>>("gainWidth", std::vector<double>({0.0}));
    desc_hb.add<double>("pedestal", 3.0);
    desc_hb.add<double>("pedestalWidth", 0.55);
    desc_hb.add<int>("zsThreshold", 8);
    desc_hb.add<std::vector<double>>("qieOffset", std::vector<double>({-0.49, 1.8, 7.2, 37.9}));
    desc_hb.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.917, 0.922, 0.923}));
    desc_hb.add<int>("qieType", 0);
    desc_hb.add<int>("mcShape",125);
    desc_hb.add<int>("recoShape",105);
    desc_hb.add<double>("photoelectronsToAnalog",0.0);
    desc_hb.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
    desc_hb.add<bool>("doRadiationDamage", false);
    desc.add<edm::ParameterSetDescription>("hb", desc_hb);

    edm::ParameterSetDescription desc_hbRaddam;
    desc_hbRaddam.add<double>("temperatureBase",20.0);
    desc_hbRaddam.add<double>("temperatureNew",-5.0);
    desc_hbRaddam.add<double>("intlumiOffset",150);
    desc_hbRaddam.add<double>("depVsTemp",0.0631);
    desc_hbRaddam.add<double>("intlumiToNeutrons",3.67e8);
    desc_hbRaddam.add<std::vector<double>>("depVsNeutrons",{5.69e-11,7.90e-11});

    edm::ParameterSetDescription desc_hbUpgrade;
    desc_hbUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
    desc_hbUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
    desc_hbUpgrade.add<double>("pedestal", 18.0);
    desc_hbUpgrade.add<double>("pedestalWidth", 5.0);
    desc_hbUpgrade.add<int>("zsThreshold", 3);
    desc_hbUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
    desc_hbUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
    desc_hbUpgrade.add<int>("qieType", 2);
    desc_hbUpgrade.add<int>("mcShape",206);
    desc_hbUpgrade.add<int>("recoShape",206);
    desc_hbUpgrade.add<double>("photoelectronsToAnalog",57.5);
    desc_hbUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
    desc_hbUpgrade.add<bool>("doRadiationDamage", true);
    desc_hbUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_hbRaddam);
    desc.add<edm::ParameterSetDescription>("hbUpgrade", desc_hbUpgrade);

    edm::ParameterSetDescription desc_he;
    desc_he.add<std::vector<double>>("gain", std::vector<double>({0.23}));
    desc_he.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
    desc_he.add<double>("pedestal", 3.0);
    desc_he.add<double>("pedestalWidth", 0.79);
    desc_he.add<int>("zsThreshold", 9);
    desc_he.add<std::vector<double>>("qieOffset", std::vector<double>({-0.38, 2.0, 7.6, 39.6}));
    desc_he.add<std::vector<double>>("qieSlope", std::vector<double>({0.912, 0.916, 0.92, 0.922}));
    desc_he.add<int>("qieType", 0);
    desc_he.add<int>("mcShape",125);
    desc_he.add<int>("recoShape",105);
    desc_he.add<double>("photoelectronsToAnalog",0.0);
    desc_he.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
    desc_he.add<bool>("doRadiationDamage", false);
    desc.add<edm::ParameterSetDescription>("he", desc_he);

    edm::ParameterSetDescription desc_heRaddam;
    desc_heRaddam.add<double>("temperatureBase",20.0);
    desc_heRaddam.add<double>("temperatureNew",5.0);
    desc_heRaddam.add<double>("intlumiOffset",75);
    desc_heRaddam.add<double>("depVsTemp",0.0631);
    desc_heRaddam.add<double>("intlumiToNeutrons",2.92e8);
    desc_heRaddam.add<std::vector<double>>("depVsNeutrons",{5.69e-11,7.90e-11});

    edm::ParameterSetDescription desc_heUpgrade;
    desc_heUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.00111111111111}));
    desc_heUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0}));
    desc_heUpgrade.add<double>("pedestal", 18.0);
    desc_heUpgrade.add<double>("pedestalWidth", 5.0);
    desc_heUpgrade.add<int>("zsThreshold", 3);
    desc_heUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0, 0.0, 0.0, 0.0}));
    desc_heUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.333, 0.333, 0.333, 0.333}));
    desc_heUpgrade.add<int>("qieType", 2);
    desc_heUpgrade.add<int>("mcShape",206);
    desc_heUpgrade.add<int>("recoShape",206);
    desc_heUpgrade.add<double>("photoelectronsToAnalog",57.5);
    desc_heUpgrade.add<std::vector<double>>("darkCurrent", std::vector<double>({0.055}));
    desc_heUpgrade.add<bool>("doRadiationDamage", true);
    desc_heUpgrade.add<edm::ParameterSetDescription>("radiationDamage", desc_heRaddam);
    desc.add<edm::ParameterSetDescription>("heUpgrade", desc_heUpgrade);

    edm::ParameterSetDescription desc_hf;
    desc_hf.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
    desc_hf.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
    desc_hf.add<double>("pedestal", 3.0);
    desc_hf.add<double>("pedestalWidth", 0.84);
    desc_hf.add<int>("zsThreshold", -9999);
    desc_hf.add<std::vector<double>>("qieOffset", std::vector<double>({-0.87, 1.4, 7.8, -29.6}));
    desc_hf.add<std::vector<double>>("qieSlope", std::vector<double>({0.359, 0.358, 0.36, 0.367}));
    desc_hf.add<int>("qieType", 0);
    desc_hf.add<int>("mcShape",301);
    desc_hf.add<int>("recoShape",301);
    desc_hf.add<double>("photoelectronsToAnalog",0.0);
    desc_hf.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
    desc_hf.add<bool>("doRadiationDamage", false);
    desc.add<edm::ParameterSetDescription>("hf", desc_hf);

    edm::ParameterSetDescription desc_hfUpgrade;
    desc_hfUpgrade.add<std::vector<double>>("gain", std::vector<double>({0.14, 0.135}));
    desc_hfUpgrade.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
    desc_hfUpgrade.add<double>("pedestal", 13.33);
    desc_hfUpgrade.add<double>("pedestalWidth", 3.33);
    desc_hfUpgrade.add<int>("zsThreshold", -9999);
    desc_hfUpgrade.add<std::vector<double>>("qieOffset", std::vector<double>({0.0697, -0.7405, 12.38, -671.9}));
    desc_hfUpgrade.add<std::vector<double>>("qieSlope", std::vector<double>({0.297, 0.298, 0.298, 0.313}));
    desc_hfUpgrade.add<int>("qieType", 1);
    desc_hfUpgrade.add<int>("mcShape",301);
    desc_hfUpgrade.add<int>("recoShape",301);
    desc_hfUpgrade.add<double>("photoelectronsToAnalog",0.0);
    desc_hfUpgrade.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
    desc_hfUpgrade.add<bool>("doRadiationDamage", false);
    desc.add<edm::ParameterSetDescription>("hfUpgrade", desc_hfUpgrade);
  
    edm::ParameterSetDescription desc_hfrecal;
    desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterA", std::vector<double>());
    desc_hfrecal.add<std::vector<double>>("HFdepthOneParameterB", std::vector<double>());
    desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterA", std::vector<double>());
    desc_hfrecal.add<std::vector<double>>("HFdepthTwoParameterB", std::vector<double>());
    desc.add<edm::ParameterSetDescription>("HFRecalParameterBlock", desc_hfrecal);

    edm::ParameterSetDescription desc_ho;
    desc_ho.add<std::vector<double>>("gain", std::vector<double>({0.006, 0.0087}));
    desc_ho.add<std::vector<double>>("gainWidth", std::vector<double>({0.0, 0.0}));
    desc_ho.add<double>("pedestal", 11.0);
    desc_ho.add<double>("pedestalWidth", 0.57);
    desc_ho.add<int>("zsThreshold", 24);
    desc_ho.add<std::vector<double>>("qieOffset", std::vector<double>({-0.44, 1.4, 7.1, 38.5}));
    desc_ho.add<std::vector<double>>("qieSlope", std::vector<double>({0.907, 0.915, 0.92, 0.921}));
    desc_ho.add<int>("qieType", 0);
    desc_ho.add<int>("mcShape",201);
    desc_ho.add<int>("recoShape",201);
    desc_ho.add<double>("photoelectronsToAnalog",4.0);
    desc_ho.add<std::vector<double>>("darkCurrent",std::vector<double>({0.0}));
    desc_ho.add<bool>("doRadiationDamage", false);
    desc.add<edm::ParameterSetDescription>("ho", desc_ho);

    edm::ParameterSetDescription validator_sipm;
    validator_sipm.add<int>("pixels",1);
    validator_sipm.add<double>("crosstalk",0);
    validator_sipm.add<double>("nonlin1",1);
    validator_sipm.add<double>("nonlin2",0);
    validator_sipm.add<double>("nonlin3",0);
    std::vector<edm::ParameterSet> default_sipm(1);
    desc.addVPSet("SiPMCharacteristics",validator_sipm,default_sipm);
    
    descriptions.addDefault(desc);
}

void HcalHardcodeCalibrations::produce ( )

inline

Definition at line 59 of file HcalHardcodeCalibrations.h.

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

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

{};

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

protected

Definition at line 454 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, dbHardcode, egammaForCoreTracking_cff::depth, HcalDetId::depth(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDetId::ieta(), HcalDetId::ietaAbs(), HcalDetId::iphi(), HcalDbHardcode::killHE(), mps_fire::result, mps_update::status, testHEPlan1, and useIeta18depth1.

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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    // Special: removal of (non-instrumented) layer "-1"("nose") = depth 1 
    // from Upgrade HE, either from  
    // (i)  HEP17 sector in 2017 or 
    // (ii) the entire HE rin=18 from 2018 through Run 3. 
    // May require a revision  by 2021.
 
    uint32_t status = 0;

    if ( !(cell.isHcalZDCDetId())) {

      HcalDetId hid =  HcalDetId(cell);
      int iphi    = hid.iphi();
      int ieta    = hid.ieta();
      int absieta = hid.ietaAbs();
      int depth   = hid.depth();

      // specific HEP17 sector (2017 only) 
      bool isHEP17 = (iphi >= 63) && (iphi <= 66) && (ieta > 0); 
      // |ieta|=18, depth=1     
      bool is18d1  = (absieta == 18) && (depth ==1);             
            
      if( (!useIeta18depth1 && is18d1 ) &&       
      ((testHEPlan1 && isHEP17) || (!testHEPlan1))) { 
    status = 0x8002;  // dead cell
      }
    }

    HcalChannelStatus item(cell.rawId(),status);
    result->addValues(item);
  }

   

  return result;
}

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

protected

Definition at line 717 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 711 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< HcalPedestals > HcalHardcodeCalibrations::produceEffectivePedestals ( const HcalPedestalsRcd &  rcd )

protected

Definition at line 369 of file HcalHardcodeCalibrations.cc.

References producePedestals_().

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                            {
  return producePedestals_(rec,true);
}

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

protected

Definition at line 377 of file HcalHardcodeCalibrations.cc.

References producePedestalWidths_().

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                           {
  return producePedestalWidths_(rec,true);
}

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

protected

Definition at line 658 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);

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

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  
  std::vector<double> coef;
  coef.push_back(0.93);
  coef.push_back(-0.38275);
  coef.push_back(-0.012667);

  for (auto cell : cells) {
    HcalFlagHFDigiTimeParam item(cell.rawId(),
                 1, //firstsample
                 3, // samplestoadd
                 2, //expectedpeak
                 40., // min energy threshold
                 coef // coefficients
                 );
    result->addValues(item);
  }
  return result;
} 

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

protected

Definition at line 841 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const 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 381 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalGain item = dbHardcode.makeGain (cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 396 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {

    // for Upgrade - include TrigPrims, for regular case - only HcalDetId 
    if(switchGainWidthsForTrigPrims) {
      HcalGainWidth item = dbHardcode.makeGainWidth (cell);
      result->addValues(item);
    } else if (!cell.isHcalTrigTowerDetId()) {
      HcalGainWidth item = dbHardcode.makeGainWidth (cell);
      result->addValues(item);
    }
  }
  return result;
}

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

protected

Definition at line 639 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalL1TriggerObject item(cell.rawId(),0., 1., 0);
    result->addValues(item);
  }
  // add tag and algo values
  result->setTagString("hardcoded");
  result->setAlgoString("hardcoded");
  return result;
}

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

protected

Definition at line 753 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  std::vector <unsigned int> mSignal; 
  mSignal.push_back(4); 
  mSignal.push_back(5); 
  mSignal.push_back(6);
  std::vector <unsigned int> mNoise;  
  mNoise.push_back(1);  
  mNoise.push_back(2);  
  mNoise.push_back(3);
  for (auto cell : cells) {
    if (cell.isHcalZDCDetId())
      {
        HcalLongRecoParam item(cell.rawId(),mSignal,mNoise);
        result->addValues(item);
      }
  }
  return result;
}

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

protected

Definition at line 578 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalLUTCorr item(cell.rawId(),1.0);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 683 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), mps_fire::result, and electronIdCutBased_cfi::threshold.

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

  const std::vector <HcalGenericDetId>& cells = allCells(*topo,dbHardcode.killHE());
  for (const auto& cell: cells) {
    float rcalib = 1.;
    int granularity = 1;
    int threshold = 0;

    if (cell.isHcalTrigTowerDetId()) {
      rcalib = 0.;
    }

    HcalLutMetadatum item(cell.rawId(), rcalib, granularity, threshold);
    result->addValues(item);
  }
  
  return result;
}

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

protected

Definition at line 794 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalMCParam item = dbHardcode.makeMCParam (cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 365 of file HcalHardcodeCalibrations.cc.

References producePedestals_().

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                   {
  return producePedestals_(rec,false);
}

std::unique_ptr< HcalPedestals > HcalHardcodeCalibrations::producePedestals_ ( const HcalPedestalsRcd &  rcd, bool  eff  )

protected

Definition at line 333 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), iLumi, HcalDbHardcode::killHE(), HcalDbHardcode::makePedestal(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produce(), produceEffectivePedestals(), and producePedestals().

                                                                                                               {
  std::string seff = eff ? "Effective" : "";
  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "Pedestals-> ...";
  edm::ESHandle<HcalTopology> htopo;
  rec.getRecord<HcalRecNumberingRecord>().get(htopo);
  const HcalTopology* topo=&(*htopo);

  auto result = std::make_unique<HcalPedestals>(topo,false);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalPedestal item = dbHardcode.makePedestal (cell, false, eff, topo, iLumi);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 373 of file HcalHardcodeCalibrations.cc.

References producePedestalWidths_().

Referenced by HcalHardcodeCalibrations(), and produce().

                                                                                                                  {
  return producePedestalWidths_(rec,false);
}

std::unique_ptr< HcalPedestalWidths > HcalHardcodeCalibrations::producePedestalWidths_ ( const HcalPedestalWidthsRcd &  rcd, bool  eff  )

protected

Definition at line 349 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), iLumi, HcalDbHardcode::killHE(), HcalDbHardcode::makePedestalWidth(), mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by produce(), produceEffectivePedestalWidths(), and producePedestalWidths().

                                                                                                                              {
  std::string seff = eff ? "Effective" : "";
  edm::LogInfo("HCAL") << "HcalHardcodeCalibrations::produce" << seff << "PedestalWidths-> ...";
  edm::ESHandle<HcalTopology> htopo;
  rec.getRecord<HcalRecNumberingRecord>().get(htopo);
  const HcalTopology* topo=&(*htopo);

  auto result = std::make_unique<HcalPedestalWidths>(topo,false);
  const std::vector <HcalGenericDetId>& cells = allCells(*htopo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalPedestalWidth item = dbHardcode.makePedestalWidth (cell, eff, topo, iLumi);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 593 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalPFCorr item(cell.rawId(),1.0);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 418 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalQIECoder coder = dbHardcode.makeQIECoder (cell);
    result->addCoder (coder);
  }
  return result;
}

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

protected

Definition at line 439 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalQIEType item = dbHardcode.makeQIEType(cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 723 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalRecoParam item = dbHardcode.makeRecoParam (cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 500 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, corr, gather_cfg::cout, dbHardcode, egammaForCoreTracking_cff::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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (const auto& cell : cells) {

    double corr = 1.0; 

    //check for layer 0 reweighting: when depth 1 has only one layer, it is layer 0
    if( useLayer0Weight && 
      ((cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap) || (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) &&
      (HcalDetId(cell).depth()==1 && dbHardcode.getLayersInDepth(HcalDetId(cell).ietaAbs(),HcalDetId(cell).depth(),topo)==1) )
    {
      //layer 0 is thicker than other layers (9mm vs 3.7mm) and brighter (Bicron vs SCSN81)
      //in Run1/Run2 (pre-2017 for HE), ODU for layer 0 had neutral density filter attached
      //NDF was simulated as weight of 0.5 applied to Geant energy deposits
      //for Phase1, NDF is removed - simulated as weight of 1.2 applied to Geant energy deposits
      //to maintain RECO calibrations, move the layer 0 energy scale back to its previous state using respcorrs
      corr = 0.5/1.2;
    }

    if ((hb_recalibration != nullptr ) && (cell.genericSubdet() == HcalGenericDetId::HcalGenBarrel)) {
      int depth_ = HcalDetId(cell).depth();
      int ieta_  = HcalDetId(cell).ieta();
      corr *= hb_recalibration->getCorr(ieta_, depth_); 
#ifdef DebugLog      
      std::cout << "HB ieta, depth = " << ieta_  << ",  " << depth_ << "   corr = "  << corr << std::endl;
#endif
    }
    else if ((he_recalibration != nullptr ) && (cell.genericSubdet() == HcalGenericDetId::HcalGenEndcap)) {
      int depth_ = HcalDetId(cell).depth();
      int ieta_  = HcalDetId(cell).ieta();
      corr *= he_recalibration->getCorr(ieta_, depth_); 
#ifdef DebugLog      
      std::cout << "HE ieta, depth = " << ieta_  << ",  " << depth_ << "   corr = "  << corr << std::endl;
#endif
    }
    else if ((hf_recalibration != nullptr ) && (cell.genericSubdet() == HcalGenericDetId::HcalGenForward)) {
      int depth_ = HcalDetId(cell).depth();
      int ieta_  = HcalDetId(cell).ieta();
      corr = hf_recalibration->getCorr(ieta_, depth_, iLumi); 
#ifdef DebugLog
      std::cout << "HF ieta, depth = " << ieta_  << ",  " << depth_ << "   corr = "  << corr << std::endl;
#endif
    }

    HcalRespCorr item(cell.rawId(),corr);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 867 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 852 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*htopo, dbHardcode.killHE());
  for (auto cell : cells) {
    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 608 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalTimeCorr item(cell.rawId(),0.0);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 738 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalTimingParam item = dbHardcode.makeTimingParam (cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 874 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*htopo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalTPChannelParameter item = dbHardcode.makeHardcodeTPChannelParameter (cell);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 889 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 668 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalValidationCorr item(cell.rawId(),1.0);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 779 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalZDCLowGainFraction item(cell.rawId(),0.0);
    result->addValues(item);
  }
  return result;
}

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

protected

Definition at line 623 of file HcalHardcodeCalibrations.cc.

References postprocess-scan-build::cells, dbHardcode, edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::getRecord(), HcalDbHardcode::killHE(), HcalDbHardcode::makeZSThreshold(), 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);
  const std::vector <HcalGenericDetId>& cells = allCells(*topo, dbHardcode.killHE());
  for (auto cell : cells) {
    HcalZSThreshold item = dbHardcode.makeZSThreshold(cell);
    result->addValues(item);
  }
  return result;
}

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

overrideprotectedvirtual

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 327 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
}

Member Data Documentation

HcalDbHardcode HcalHardcodeCalibrations::dbHardcode

private

Definition at line 108 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), produceChannelQuality(), produceDcsMap(), 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(), and produceZSThresholds().

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::hb_recalibration

private

Definition at line 110 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

std::unique_ptr<HBHERecalibration> HcalHardcodeCalibrations::he_recalibration

private

Definition at line 111 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

std::unique_ptr<HFRecalibration> HcalHardcodeCalibrations::hf_recalibration

private

Definition at line 112 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().

double HcalHardcodeCalibrations::iLumi

private

Definition at line 109 of file HcalHardcodeCalibrations.h.

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

bool HcalHardcodeCalibrations::setHBdsegm

private

Definition at line 115 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

bool HcalHardcodeCalibrations::setHEdsegm

private

Definition at line 114 of file HcalHardcodeCalibrations.h.

Referenced by produceRespCorrs().

bool HcalHardcodeCalibrations::switchGainWidthsForTrigPrims

private

Definition at line 113 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceGainWidths().

bool HcalHardcodeCalibrations::testHEPlan1

private

Definition at line 118 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

bool HcalHardcodeCalibrations::useIeta18depth1

private

Definition at line 117 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceChannelQuality().

bool HcalHardcodeCalibrations::useLayer0Weight

private

Definition at line 116 of file HcalHardcodeCalibrations.h.

Referenced by HcalHardcodeCalibrations(), and produceRespCorrs().