L1GctChannelMaskOnlineProd Class Reference

Inheritance diagram for L1GctChannelMaskOnlineProd:

Public Member Functions
	L1GctChannelMaskOnlineProd (const edm::ParameterSet &iConfig)
std::unique_ptr< L1GctChannelMask >	newObject (const std::string &objectKey) override
	~L1GctChannelMaskOnlineProd () override
Public Member Functions inherited from L1ConfigOnlineProdBase< L1GctChannelMaskRcd, L1GctChannelMask >
	L1ConfigOnlineProdBase (const edm::ParameterSet &)
virtual std::unique_ptr< L1GctChannelMask >	produce (const L1GctChannelMaskRcd &iRecord)
	~L1ConfigOnlineProdBase () override
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	ESProducer (const ESProducer &)=delete
ESProxyIndex const *	getTokenIndices (unsigned int iIndex) const
ESProducer const &	operator= (const ESProducer &)=delete
template<typename Record >
void	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &) final
	~ESProducer () noexcept(false) override
Public Member Functions inherited from edm::ESProxyFactoryProducer
	ESProxyFactoryProducer ()
	ESProxyFactoryProducer (const ESProxyFactoryProducer &)=delete
const ESProxyFactoryProducer &	operator= (const ESProxyFactoryProducer &)=delete
	~ESProxyFactoryProducer () noexcept(false) override
Public Member Functions inherited from edm::eventsetup::DataProxyProvider
void	createKeyedProxies (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
	DataProxyProvider ()
	DataProxyProvider (const DataProxyProvider &)=delete
const ComponentDescription &	description () const
void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
bool	isUsingRecord (const EventSetupRecordKey &key) const
KeyedProxies &	keyedProxies (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
const DataProxyProvider &	operator= (const DataProxyProvider &)=delete
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~DataProxyProvider () noexcept(false)

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::DataProxyProvider
static void	prevalidate (ConfigurationDescriptions &)
Protected Types inherited from edm::ESProxyFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey
Protected Types inherited from edm::eventsetup::DataProxyProvider
using	KeyedProxiesVector = std::vector< std::pair< DataKey, std::shared_ptr< DataProxy > >>
Protected Member Functions inherited from L1ConfigOnlineProdBase< L1GctChannelMaskRcd, L1GctChannelMask >
bool	getObjectKey (const L1GctChannelMaskRcd &record, std::string &objectKey)
Protected Member Functions inherited from edm::ESProducer
template<typename T >
auto	setWhatProduced (T *iThis, const char *iLabel)
template<typename T >
auto	setWhatProduced (T *iThis, const es::Label &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 >
ESConsumesCollectorT< TRecord >	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 EventSetupRecordKey &iRecord, std::unique_ptr< eventsetup::ProxyFactoryBase > iFactory, const std::string &iLabel=std::string())
KeyedProxiesVector	registerProxies (const EventSetupRecordKey &, unsigned int iovIndex) override
Protected Member Functions inherited from edm::eventsetup::DataProxyProvider
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &key)
Protected Attributes inherited from L1ConfigOnlineProdBase< L1GctChannelMaskRcd, L1GctChannelMask >
bool	m_copyFromCondDB
cond::persistency::Session	m_dbSession
bool	m_forceGeneration
l1t::OMDSReader	m_omdsReader

Detailed Description

Definition at line 5 of file L1GctChannelMaskOnlineProd.cc.

Constructor & Destructor Documentation

L1GctChannelMaskOnlineProd()

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

inline

Definition at line 7 of file L1GctChannelMaskOnlineProd.cc.

      : L1ConfigOnlineProdBase<L1GctChannelMaskRcd, L1GctChannelMask>(iConfig) {}

~L1GctChannelMaskOnlineProd()

L1GctChannelMaskOnlineProd::~L1GctChannelMaskOnlineProd ( )

inlineoverride

Definition at line 9 of file L1GctChannelMaskOnlineProd.cc.

{}

Member Function Documentation

newObject()

std::unique_ptr< L1GctChannelMask > L1GctChannelMaskOnlineProd::newObject ( const std::string &  objectKey )

overridevirtual

Implements L1ConfigOnlineProdBase< L1GctChannelMaskRcd, L1GctChannelMask >.

Definition at line 16 of file L1GctChannelMaskOnlineProd.cc.

                                                                                                {
  // get EM mask data
  l1t::OMDSReader::QueryResults emMaskResults = m_omdsReader.basicQuery(
      "GCT_EM_MASK", "CMS_GCT", "GCT_MASKS", "GCT_MASKS.CONFIG_KEY", m_omdsReader.singleAttribute(objectKey));
 
  if (emMaskResults.queryFailed()) {  // check if query was successful
    edm::LogError("L1-O2O") << "Problem with L1GctChannelMask EM mask for key " << objectKey;
    return std::unique_ptr<L1GctChannelMask>();
  }
 
  int emMask = -1;
  emMaskResults.fillVariable(emMask);
 
  // get region masks
  l1t::OMDSReader::QueryResults rgnMaskKeyResults = m_omdsReader.basicQuery(
      "GCT_RGN_MASK_KEY", "CMS_GCT", "GCT_MASKS", "GCT_MASKS.CONFIG_KEY", m_omdsReader.singleAttribute(objectKey));
 
  if (rgnMaskKeyResults.queryFailed()) {  // check if query was successful
    edm::LogError("L1-O2O") << "Problem with L1GctChannelMask region mask for key " << objectKey;
    return std::unique_ptr<L1GctChannelMask>();
  }
 
  std::string rgnKey;
  rgnMaskKeyResults.fillVariable(rgnKey);
 
  std::vector<std::string> rgnMaskCols;
  rgnMaskCols.push_back("RCT_CRATE_0_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_1_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_2_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_3_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_4_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_5_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_6_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_7_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_8_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_9_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_10_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_11_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_12_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_13_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_14_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_15_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_16_RGN_MASK");
  rgnMaskCols.push_back("RCT_CRATE_17_RGN_MASK");
 
  l1t::OMDSReader::QueryResults rgnMaskResults = m_omdsReader.basicQuery(
      rgnMaskCols, "CMS_GCT", "GCT_RGN_MASKS", "GCT_RGN_MASKS.CONFIG_KEY", m_omdsReader.singleAttribute(rgnKey));
 
  // get energy sum masks
  l1t::OMDSReader::QueryResults esumMaskKeyResults = m_omdsReader.basicQuery(
      "GCT_ESUM_MASK_KEY", "CMS_GCT", "GCT_MASKS", "GCT_MASKS.CONFIG_KEY", m_omdsReader.singleAttribute(objectKey));
 
  if (esumMaskKeyResults.queryFailed()) {  // check if query was successful
    edm::LogError("L1-O2O") << "Problem with L1GctChannelMask energy sum mask for key " << objectKey;
    return std::unique_ptr<L1GctChannelMask>();
  }
 
  std::string esumKey;
  esumMaskKeyResults.fillVariable(esumKey);
 
  std::vector<std::string> esumMaskCols;
  esumMaskCols.push_back("GCT_TET_MASK");
  esumMaskCols.push_back("GCT_MET_MASK");
  esumMaskCols.push_back("GCT_HT_MASK");
  esumMaskCols.push_back("GCT_MHT_MASK");
 
  l1t::OMDSReader::QueryResults esumMaskResults = m_omdsReader.basicQuery(
      esumMaskCols, "CMS_GCT", "GCT_ESUM_MASKS", "GCT_ESUM_MASKS.CONFIG_KEY", m_omdsReader.singleAttribute(esumKey));
 
  // create masks object
  auto masks = std::make_unique<L1GctChannelMask>();
 
  // set EM masks
  for (int i = 0; i < 18; i++) {
    if ((emMask & (1 << i)) != 0)
      masks->maskEmCrate(i);  // mask crate if emMask bit i is set
  }
 
  // set region masks
  for (unsigned irct = 0; irct < 18; irct++) {
    std::stringstream rgnCol;
    rgnCol << "RCT_CRATE_" << std::dec << irct << "_RGN_MASK";
    int mask;
    rgnMaskResults.fillVariable(rgnCol.str(), mask);
    if (mask != 0) {
      for (unsigned irgn = 0; irgn < 22; ++irgn) {
        if ((mask & (1 << irgn)) != 0) {
          edm::LogError("L1-O2O") << "Masked region, but no O2O code!";
        }
      }
    }
  }
 
  // set esum masks
  int tetMask, metMask, htMask, mhtMask;
  esumMaskResults.fillVariable("GCT_TET_MASK", tetMask);
  esumMaskResults.fillVariable("GCT_MET_MASK", metMask);
  esumMaskResults.fillVariable("GCT_HT_MASK", htMask);
  esumMaskResults.fillVariable("GCT_MHT_MASK", mhtMask);
 
  for (int ieta = 0; ieta < 22; ieta++) {
    if ((tetMask & (1 << ieta)) != 0)
      masks->maskTotalEt(ieta);
    if ((metMask & (1 << ieta)) != 0)
      masks->maskMissingEt(ieta);
    if ((htMask & (1 << ieta)) != 0)
      masks->maskTotalHt(ieta);
    if ((mhtMask & (1 << ieta)) != 0)
      masks->maskMissingHt(ieta);
  }
 
  return masks;
}

References l1t::OMDSReader::basicQuery(), TauDecayModes::dec, l1t::OMDSReader::QueryResults::fillVariable(), mps_fire::i, LEDCalibrationChannels::ieta, L1ConfigOnlineProdBase< L1GctChannelMaskRcd, L1GctChannelMask >::m_omdsReader, l1t::OMDSReader::QueryResults::queryFailed(), l1t::OMDSReader::singleAttribute(), and AlCaHLTBitMon_QueryRunRegistry::string.