#include <HcalOmdsCalibrations.h>

Inheritance diagram for HcalOmdsCalibrations:

Public Member Functions
	HcalOmdsCalibrations (const edm::ParameterSet &)
void	produce ()
	~HcalOmdsCalibrations ()
Protected Member Functions
std::auto_ptr< HcalChannelQuality >	produceChannelQuality (const HcalChannelQualityRcd &rcd)
std::auto_ptr< HcalDcsValues >	produceDcsValues (const HcalDcsRcd &rcd)
std::auto_ptr< HcalElectronicsMap >	produceElectronicsMap (const HcalElectronicsMapRcd &rcd)
std::auto_ptr< HcalGains >	produceGains (const HcalGainsRcd &rcd)
std::auto_ptr< HcalGainWidths >	produceGainWidths (const HcalGainWidthsRcd &rcd)
std::auto_ptr < HcalL1TriggerObjects >	produceL1TriggerObjects (const HcalL1TriggerObjectsRcd &rcd)
std::auto_ptr< HcalLutMetadata >	produceLutMetadata (const HcalLutMetadataRcd &rcd)
std::auto_ptr< HcalPedestals >	producePedestals (const HcalPedestalsRcd &rcd)
std::auto_ptr< HcalPedestalWidths >	producePedestalWidths (const HcalPedestalWidthsRcd &rcd)
std::auto_ptr< HcalQIEData >	produceQIEData (const HcalQIEDataRcd &rcd)
std::auto_ptr< HcalRespCorrs >	produceRespCorrs (const HcalRespCorrsRcd &rcd)
std::auto_ptr < HcalValidationCorrs >	produceValidationCorrs (const HcalValidationCorrsRcd &rcd)
std::auto_ptr< HcalZSThresholds >	produceZSThresholds (const HcalZSThresholdsRcd &rcd)
virtual void	setIntervalFor (const edm::eventsetup::EventSetupRecordKey &, const edm::IOVSyncValue &, edm::ValidityInterval &)
Private Attributes
std::map< std::string, std::string >	mAccessor
std::map< std::string, std::string >	mInputs
std::map< std::string, int >	mIOVBegin
std::map< std::string, std::string >	mQuery
std::map< std::string, int >	mSubversion
std::map< std::string, std::string >	mVersion

Detailed Description

Definition at line 31 of file HcalOmdsCalibrations.h.

Constructor & Destructor Documentation

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

Definition at line 42 of file HcalOmdsCalibrations.cc.

References dtNoiseDBValidation_cfg::cerr, AlCaHLTBitMon_QueryRunRegistry::data, edm::ParameterSet::getParameter(), summarizeEdmComparisonLogfiles::objectName, produceChannelQuality(), produceDcsValues(), produceElectronicsMap(), produceGains(), produceGainWidths(), produceL1TriggerObjects(), produceLutMetadata(), producePedestals(), producePedestalWidths(), produceQIEData(), produceRespCorrs(), produceValidationCorrs(), and produceZSThresholds().

{
  //parsing parameters
  std::vector<edm::ParameterSet> data = iConfig.getParameter<std::vector<edm::ParameterSet> >("input");
  std::vector<edm::ParameterSet>::iterator request = data.begin ();
  for (; request != data.end (); request++) {
    std::string objectName = request->getParameter<std::string> ("object");

    if (request->exists("version")) mVersion[objectName] = request->getParameter<std::string>("version");
    if (request->exists("subversion")) mSubversion[objectName] = request->getParameter<int>("subversion");
    if (request->exists("iov_begin")) mIOVBegin[objectName] = request->getParameter<int>("iov_begin");
    if (request->exists("accessor")) mAccessor[objectName] = request->getParameter<std::string>("accessor");
    if (request->exists("query")) mQuery[objectName] = request->getParameter<std::string>("query");

    mInputs [objectName] = request->getParameter<std::string>("tag");
    if (objectName == "Pedestals") {
      setWhatProduced (this, &HcalOmdsCalibrations::producePedestals);
      findingRecord <HcalPedestalsRcd> ();
    }
    else if (objectName == "PedestalWidths") {
      setWhatProduced (this, &HcalOmdsCalibrations::producePedestalWidths);
      findingRecord <HcalPedestalWidthsRcd> ();
    }
    else if (objectName == "Gains") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceGains);
      findingRecord <HcalGainsRcd> ();
    }
    else if (objectName == "GainWidths") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceGainWidths);
      findingRecord <HcalGainWidthsRcd> ();
    }
    else if (objectName == "QIEData") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceQIEData);
      findingRecord <HcalQIEDataRcd> ();
    }
    else if (objectName == "ChannelQuality") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceChannelQuality);
      findingRecord <HcalChannelQualityRcd> ();
    }
    else if (objectName == "ZSThresholds") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceZSThresholds);
      findingRecord <HcalZSThresholdsRcd> ();
    }
    else if (objectName == "RespCorrs") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceRespCorrs);
      findingRecord <HcalRespCorrsRcd> ();
    }
    else if (objectName == "L1TriggerObjects") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceL1TriggerObjects);
      findingRecord <HcalL1TriggerObjectsRcd> ();
    }
    else if (objectName == "ElectronicsMap") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceElectronicsMap);
      findingRecord <HcalElectronicsMapRcd> ();
    }
    else if (objectName == "ValidationCorrs") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceValidationCorrs);
      findingRecord <HcalValidationCorrsRcd> ();
    }
    else if (objectName == "LutMetadata") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceLutMetadata);
      findingRecord <HcalLutMetadataRcd> ();
    }
    else if (objectName == "DcsValues") {
      setWhatProduced (this, &HcalOmdsCalibrations::produceDcsValues);
      findingRecord <HcalDcsRcd> ();
    }
    else {
      std::cerr << "HcalOmdsCalibrations-> Unknown object name '" << objectName 
                << "', known names are: "
                << "Pedestals PedestalWidths Gains GainWidths QIEData ChannelQuality ElectronicsMap "
                << "ZSThresholds RespCorrs L1TriggerObjects ValidationCorrs LutMetadata DcsValues "
                << std::endl;
    }
  }
  //  setWhatProduced(this);
}

HcalOmdsCalibrations::~HcalOmdsCalibrations ( )

Definition at line 122 of file HcalOmdsCalibrations.cc.

{
}

Member Function Documentation

void HcalOmdsCalibrations::produce ( ) [inline]

Definition at line 38 of file HcalOmdsCalibrations.h.

{};

std::auto_ptr< HcalChannelQuality > HcalOmdsCalibrations::produceChannelQuality ( const HcalChannelQualityRcd & rcd ) [protected]

Definition at line 217 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                             {
  return produce_impl<HcalChannelQuality> (mInputs ["ChannelQuality"], 
                                           mVersion["ChannelQuality"], 
                                           mSubversion["ChannelQuality"], 
                                           mIOVBegin["ChannelQuality"], 
                                           mQuery["ChannelQuality"], 
                                           mAccessor["ChannelQuality"]);
}

std::auto_ptr< HcalDcsValues > HcalOmdsCalibrations::produceDcsValues ( const HcalDcsRcd & rcd ) [protected]

Definition at line 280 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                        {
  return produce_impl<HcalDcsValues> (mInputs ["DcsValues"], 
                                        mVersion["DcsValues"], 
                                        mSubversion["DcsValues"], 
                                        mIOVBegin["DcsValues"], 
                                        mQuery["DcsValues"], 
                                        mAccessor["DcsValues"]);
}

std::auto_ptr< HcalElectronicsMap > HcalOmdsCalibrations::produceElectronicsMap ( const HcalElectronicsMapRcd & rcd ) [protected]

Definition at line 253 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                             {
  return produce_impl<HcalElectronicsMap> (mInputs ["ElectronicsMap"], 
                                           mVersion["ElectronicsMap"], 
                                           mSubversion["ElectronicsMap"], 
                                           mIOVBegin["ElectronicsMap"], 
                                           mQuery["ElectronicsMap"], 
                                           mAccessor["ElectronicsMap"]);
}

std::auto_ptr< HcalGains > HcalOmdsCalibrations::produceGains ( const HcalGainsRcd & rcd ) [protected]

Definition at line 190 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                              {
  return produce_impl<HcalGains> (mInputs ["Gains"], 
                                  mVersion["Gains"], 
                                  mSubversion["Gains"], 
                                  mIOVBegin["Gains"], 
                                  mQuery["Gains"], 
                                  mAccessor["Gains"]);
}

std::auto_ptr< HcalGainWidths > HcalOmdsCalibrations::produceGainWidths ( const HcalGainWidthsRcd & rcd ) [protected]

Definition at line 199 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                             {
  return produce_impl<HcalGainWidths> (mInputs ["GainWidths"], 
                                       mVersion["GainWidths"], 
                                       mSubversion["GainWidths"], 
                                       mIOVBegin["GainWidths"], 
                                       mQuery["GainWidths"], 
                                       mAccessor["GainWidths"]);
}

std::auto_ptr< HcalL1TriggerObjects > HcalOmdsCalibrations::produceL1TriggerObjects ( const HcalL1TriggerObjectsRcd & rcd ) [protected]

Definition at line 244 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                                   {
  return produce_impl<HcalL1TriggerObjects> (mInputs ["L1TriggerObjects"], 
                                             mVersion["L1TriggerObjects"], 
                                             mSubversion["L1TriggerObjects"], 
                                             mIOVBegin["L1TriggerObjects"], 
                                             mQuery["L1TriggerObjects"], 
                                             mAccessor["L1TriggerObjects"]);
}

std::auto_ptr< HcalLutMetadata > HcalOmdsCalibrations::produceLutMetadata ( const HcalLutMetadataRcd & rcd ) [protected]

Definition at line 271 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                    {
  return produce_impl<HcalLutMetadata> (mInputs ["LutMetadata"], 
                                        mVersion["LutMetadata"], 
                                        mSubversion["LutMetadata"], 
                                        mIOVBegin["LutMetadata"], 
                                        mQuery["LutMetadata"], 
                                        mAccessor["LutMetadata"]);
}

std::auto_ptr< HcalPedestals > HcalOmdsCalibrations::producePedestals ( const HcalPedestalsRcd & rcd ) [protected]

Definition at line 172 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                          {
  return produce_impl<HcalPedestals> (mInputs ["Pedestals"],
                                      mVersion["Pedestals"], 
                                      mSubversion["Pedestals"], 
                                      mIOVBegin["Pedestals"], 
                                      mQuery["Pedestals"], 
                                      mAccessor["Pedestals"]);
}

std::auto_ptr< HcalPedestalWidths > HcalOmdsCalibrations::producePedestalWidths ( const HcalPedestalWidthsRcd & rcd ) [protected]

Definition at line 181 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                         {
  return produce_impl<HcalPedestalWidths> (mInputs ["PedestalWidths"], 
                                           mVersion["PedestalWidths"], 
                                           mSubversion["PedestalWidths"], 
                                           mIOVBegin["PedestalWidths"], 
                                           mQuery["PedestalWidths"], 
                                           mAccessor["PedestalWidths"]);
}

std::auto_ptr< HcalQIEData > HcalOmdsCalibrations::produceQIEData ( const HcalQIEDataRcd & rcd ) [protected]

Definition at line 208 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                        {
  return produce_impl<HcalQIEData> (mInputs ["QIEData"], 
                                    mVersion["QIEData"], 
                                    mSubversion["QIEData"], 
                                    mIOVBegin["QIEData"], 
                                    mQuery["QIEData"], 
                                    mAccessor["QIEData"]);
}

std::auto_ptr< HcalRespCorrs > HcalOmdsCalibrations::produceRespCorrs ( const HcalRespCorrsRcd & rcd ) [protected]

Definition at line 235 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                              {
  return produce_impl<HcalRespCorrs> (mInputs ["RespCorrs"], 
                                      mVersion["RespCorrs"], 
                                      mSubversion["RespCorrs"], 
                                      mIOVBegin["RespCorrs"], 
                                      mQuery["RespCorrs"], 
                                      mAccessor["RespCorrs"]);
}

std::auto_ptr< HcalValidationCorrs > HcalOmdsCalibrations::produceValidationCorrs ( const HcalValidationCorrsRcd & rcd ) [protected]

Definition at line 262 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                                {
  return produce_impl<HcalValidationCorrs> (mInputs ["ValidationCorrs"], 
                                            mVersion["ValidationCorrs"], 
                                            mSubversion["ValidationCorrs"], 
                                            mIOVBegin["ValidationCorrs"], 
                                            mQuery["ValidationCorrs"], 
                                            mAccessor["ValidationCorrs"]);
}

std::auto_ptr< HcalZSThresholds > HcalOmdsCalibrations::produceZSThresholds ( const HcalZSThresholdsRcd & rcd ) [protected]

Definition at line 226 of file HcalOmdsCalibrations.cc.

Referenced by HcalOmdsCalibrations().

                                                                                                       {
  return produce_impl<HcalZSThresholds> (mInputs ["ZSThresholds"], 
                                         mVersion["ZSThresholds"], 
                                         mSubversion["ZSThresholds"], 
                                         mIOVBegin["ZSThresholds"], 
                                         mQuery["ZSThresholds"], 
                                         mAccessor["ZSThresholds"]);
}

void HcalOmdsCalibrations::setIntervalFor	(	const edm::eventsetup::EventSetupRecordKey &	iKey,
		const edm::IOVSyncValue &	iTime,
		edm::ValidityInterval &	oInterval
	)		`[protected, virtual]`

Implements edm::EventSetupRecordIntervalFinder.

Definition at line 131 of file HcalOmdsCalibrations.cc.

References edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime(), edm::eventsetup::EventSetupRecordKey::name(), and record.

                                                                                                                                                 {
  std::string record = iKey.name ();
  oInterval = edm::ValidityInterval (edm::IOVSyncValue::beginOfTime(), edm::IOVSyncValue::endOfTime()); //infinite
}

Member Data Documentation

std::map<std::string, std::string> HcalOmdsCalibrations::mAccessor [private]

Definition at line 65 of file HcalOmdsCalibrations.h.

std::map<std::string, std::string> HcalOmdsCalibrations::mInputs [private]

Definition at line 61 of file HcalOmdsCalibrations.h.

std::map<std::string, int> HcalOmdsCalibrations::mIOVBegin [private]

Definition at line 64 of file HcalOmdsCalibrations.h.

std::map<std::string, std::string> HcalOmdsCalibrations::mQuery [private]

Definition at line 66 of file HcalOmdsCalibrations.h.

std::map<std::string, int> HcalOmdsCalibrations::mSubversion [private]

Definition at line 63 of file HcalOmdsCalibrations.h.

std::map<std::string, std::string> HcalOmdsCalibrations::mVersion [private]

Definition at line 62 of file HcalOmdsCalibrations.h.

HcalOmdsCalibrations Class Reference

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation