L1TCaloParamsOnlineProd Class Reference

Inheritance diagram for L1TCaloParamsOnlineProd:

Public Member Functions
	L1TCaloParamsOnlineProd (const edm::ParameterSet &)
std::unique_ptr< const l1t::CaloParams >	newObject (const std::string &objectKey, const L1TCaloParamsO2ORcd &record) override
	~L1TCaloParamsOnlineProd (void) override
Public Member Functions inherited from L1ConfigOnlineProdBaseExt< L1TCaloParamsO2ORcd, l1t::CaloParams >
	L1ConfigOnlineProdBaseExt (const edm::ParameterSet &)
std::unique_ptr< const l1t::CaloParams >	produce (const L1TCaloParamsO2ORcd &iRecord)
	~L1ConfigOnlineProdBaseExt () override
Public Member Functions inherited from edm::ESProducer
	ESProducer ()
	ESProducer (const ESProducer &)=delete
	ESProducer (ESProducer &&)=delete
ESResolverIndex const *	getTokenIndices (unsigned int iIndex) const
ESRecordIndex const *	getTokenRecordIndices (unsigned int iIndex) const
bool	hasMayConsumes () const noexcept
size_t	numberOfTokenIndices (unsigned int iIndex) const
ESProducer &	operator= (const ESProducer &)=delete
ESProducer &	operator= (ESProducer &&)=delete
SerialTaskQueueChain &	queue ()
template<typename Record >
std::optional< std::vector< ESResolverIndex > >	updateFromMayConsumes (unsigned int iIndex, const Record &iRecord) const
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &) final
	~ESProducer () noexcept(false) override
Public Member Functions inherited from edm::ESProductResolverFactoryProducer
	ESProductResolverFactoryProducer ()
	ESProductResolverFactoryProducer (const ESProductResolverFactoryProducer &)=delete
const ESProductResolverFactoryProducer &	operator= (const ESProductResolverFactoryProducer &)=delete
	~ESProductResolverFactoryProducer () noexcept(false) override
Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
void	createKeyedResolvers (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
const ComponentDescription &	description () const
	ESProductResolverProvider ()
	ESProductResolverProvider (const ESProductResolverProvider &)=delete
void	fillRecordsNotAllowingConcurrentIOVs (std::set< EventSetupRecordKey > &recordsNotAllowingConcurrentIOVs) const
virtual void	initConcurrentIOVs (EventSetupRecordKey const &key, unsigned int nConcurrentIOVs)
bool	isUsingRecord (const EventSetupRecordKey &key) const
KeyedResolvers &	keyedResolvers (const EventSetupRecordKey &iRecordKey, unsigned int iovIndex=0)
const ESProductResolverProvider &	operator= (const ESProductResolverProvider &)=delete
void	setAppendToDataLabel (const edm::ParameterSet &)
void	setDescription (const ComponentDescription &iDescription)
std::set< EventSetupRecordKey >	usingRecords () const
virtual	~ESProductResolverProvider () noexcept(false)

Private Member Functions
bool	readCaloLayer1OnlineSettings (l1t::CaloParamsHelperO2O &paramsHelper, std::map< std::string, l1t::Parameter > &conf, std::map< std::string, l1t::Mask > &)
bool	readCaloLayer2OnlineSettings (l1t::CaloParamsHelperO2O &paramsHelper, std::map< std::string, l1t::Parameter > &conf, std::map< std::string, l1t::Mask > &)

Private Attributes
const edm::ESGetToken< l1t::CaloParams, L1TCaloParamsRcd >	baseSettings_token
const unsigned int	exclusiveLayer
const bool	transactionSafe

Additional Inherited Members
Static Public Member Functions inherited from edm::eventsetup::ESProductResolverProvider
static void	prevalidate (ConfigurationDescriptions &)
Protected Types inherited from edm::ESProductResolverFactoryProducer
using	EventSetupRecordKey = eventsetup::EventSetupRecordKey
Protected Types inherited from edm::eventsetup::ESProductResolverProvider
using	KeyedResolversVector = std::vector< std::pair< DataKey, std::shared_ptr< ESProductResolver > >>
Protected Member Functions inherited from L1ConfigOnlineProdBaseExt< L1TCaloParamsO2ORcd, l1t::CaloParams >
bool	getObjectKey (const L1TCaloParamsO2ORcd &record, std::string &objectKey)
edm::ESConsumesCollectorT< L1TCaloParamsO2ORcd >	wrappedSetWhatProduced (const edm::ParameterSet &)
Protected Member Functions inherited from edm::ESProducer
ESConsumesInfo *	consumesInfoPushBackNew ()
unsigned int	consumesInfoSize () const
template<typename CallbackT , typename TList , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>> iCallback, const TList *, const TRecord *iRecord, const es::Label &iLabel)
template<typename CallbackT , typename TRecord >
void	registerProducts (std::shared_ptr< std::pair< unsigned int, std::shared_ptr< CallbackT >>>, const eventsetup::produce::Null *, const TRecord *, const es::Label &)
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 TDecorator >
auto	setWhatProduced (T *iThis, TReturn(T ::*iMethod)(const TRecord &), const TDecorator &iDec, const es::Label &iLabel={})
template<typename TFunc >
auto	setWhatProduced (TFunc &&func, const es::Label &iLabel={})
template<typename TReturn , typename TRecord , typename TFunc , typename TDecorator >
ESConsumesCollectorT< TRecord >	setWhatProduced (TFunc &&func, TDecorator &&iDec, const es::Label &iLabel={})
void	usesResources (std::vector< std::string > const &)
Protected Member Functions inherited from edm::ESProductResolverFactoryProducer
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::ESProductResolverFactoryBase > iFactory, const std::string &iLabel=std::string())
KeyedResolversVector	registerResolvers (const EventSetupRecordKey &, unsigned int iovIndex) override
Protected Member Functions inherited from edm::eventsetup::ESProductResolverProvider
template<class T >
void	usingRecord ()
void	usingRecordWithKey (const EventSetupRecordKey &key)
Protected Attributes inherited from L1ConfigOnlineProdBaseExt< L1TCaloParamsO2ORcd, l1t::CaloParams >
bool	m_copyFromCondDB
cond::persistency::Session	m_dbSession
bool	m_forceGeneration
l1t::OMDSReader	m_omdsReader

Detailed Description

Definition at line 20 of file L1TCaloParamsOnlineProd.cc.

Constructor & Destructor Documentation

L1TCaloParamsOnlineProd()

L1TCaloParamsOnlineProd::L1TCaloParamsOnlineProd

(

const edm::ParameterSet &

iConfig

)

Definition at line 218 of file L1TCaloParamsOnlineProd.cc.

    : L1ConfigOnlineProdBaseExt<L1TCaloParamsO2ORcd, l1t::CaloParams>(iConfig),
      baseSettings_token(wrappedSetWhatProduced(iConfig).consumes()),
      exclusiveLayer(iConfig.getParameter<uint32_t>("exclusiveLayer")),
      transactionSafe(iConfig.getParameter<bool>("transactionSafe")) {}

~L1TCaloParamsOnlineProd()

L1TCaloParamsOnlineProd::~L1TCaloParamsOnlineProd ( void  )

inlineoverride

Definition at line 38 of file L1TCaloParamsOnlineProd.cc.

{}

Member Function Documentation

newObject()

std::unique_ptr< const l1t::CaloParams > L1TCaloParamsOnlineProd::newObject ( const std::string &  objectKey, const L1TCaloParamsO2ORcd &  record  )

overridevirtual

Implements L1ConfigOnlineProdBaseExt< L1TCaloParamsO2ORcd, l1t::CaloParams >.

Definition at line 224 of file L1TCaloParamsOnlineProd.cc.

References l1t::TriggerSystem::addProcessor(), mps_setup::append, baseSettings_token, MillePedeFileConverter_cfg::e, exclusiveLayer, l1t::OnlineDBqueryHelper::fetch(), edm::eventsetup::EventSetupRecordImplementation< T >::get(), l1t::TriggerSystem::getParameters(), submitPVResolutionJobs::key, L1ConfigOnlineProdBaseExt< L1TCaloParamsO2ORcd, l1t::CaloParams >::m_omdsReader, L1TriggerKeyDummy_cfi::objectKey, convertSQLitetoXML_cfg::output, readCaloLayer1OnlineSettings(), readCaloLayer2OnlineSettings(), l1t::XmlConfigParser::readDOMFromString(), l1t::XmlConfigParser::readRootElement(), Hcal_FrontierConditions_cff::record, L1SubsystemKeysOnlineExt_cfi::rsKey, l1t::TriggerSystem::setConfigured(), AlCaHLTBitMon_QueryRunRegistry::string, transactionSafe, and L1SubsystemKeysOnlineExt_cfi::tscKey.

                                                                                                             {
  const L1TCaloParamsRcd& baseRcd = record.template getRecord<L1TCaloParamsRcd>();
  auto const& baseSettings = baseRcd.get(baseSettings_token);

  if (objectKey.empty()) {
    edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "Key is empty";
    if (transactionSafe)
      throw std::runtime_error("SummaryForFunctionManager: Calo  | Faulty  | Empty objectKey");
    else {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
      return std::make_unique<const l1t::CaloParams>(baseSettings);
    }
  }

  std::string tscKey = objectKey.substr(0, objectKey.find(':'));
  std::string rsKey = objectKey.substr(objectKey.find(':') + 1, std::string::npos);

  edm::LogInfo("L1-O2O: L1TCaloParamsOnlineProd")
      << "Producing L1TCaloParamsOnlineProd with TSC key = " << tscKey << " and RS key = " << rsKey;

  std::string calol1_top_key, calol1_algo_key;
  std::string calol1_algo_payload;
  std::string calol2_top_key, calol2_algo_key, calol2_hw_key;
  std::string calol2_hw_payload;
  std::map<std::string, std::string> calol2_algo_payloads;  // key -> XML payload
  try {
    std::map<std::string, std::string> topKeys =
        l1t::OnlineDBqueryHelper::fetch({"CALOL1_KEY", "CALOL2_KEY"}, "L1_TRG_CONF_KEYS", tscKey, m_omdsReader);

    if (exclusiveLayer == 0 || exclusiveLayer == 1) {
      calol1_top_key = topKeys["CALOL1_KEY"];

      calol1_algo_key = l1t::OnlineDBqueryHelper::fetch({"ALGO"}, "CALOL1_KEYS", calol1_top_key, m_omdsReader)["ALGO"];

      calol1_algo_payload =
          l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL1_CLOBS", calol1_algo_key, m_omdsReader)["CONF"];
    }

    if (exclusiveLayer == 0 || exclusiveLayer == 2) {
      calol2_top_key = topKeys["CALOL2_KEY"];

      std::map<std::string, std::string> calol2_keys =
          l1t::OnlineDBqueryHelper::fetch({"ALGO", "HW"}, "CALOL2_KEYS", calol2_top_key, m_omdsReader);

      calol2_hw_key = calol2_keys["HW"];
      calol2_hw_payload =
          l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL2_CLOBS", calol2_hw_key, m_omdsReader)["CONF"];

      calol2_algo_key = calol2_keys["ALGO"];

      std::map<std::string, std::string> calol2_algo_keys =
          l1t::OnlineDBqueryHelper::fetch({"DEMUX", "MPS_COMMON", "MPS_JET", "MP_EGAMMA", "MP_SUM", "MP_TAU"},
                                          "CALOL2_ALGO_KEYS",
                                          calol2_algo_key,
                                          m_omdsReader);

      for (auto& key : calol2_algo_keys)
        calol2_algo_payloads[key.second] =
            l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL2_CLOBS", key.second, m_omdsReader)["CONF"];
    }

  } catch (std::runtime_error& e) {
    edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
    if (transactionSafe)
      throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
    else {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
      return std::make_unique<const l1t::CaloParams>(baseSettings);
    }
  }

  if (exclusiveLayer == 0 || exclusiveLayer == 2) {
    // for debugging purposes dump the configs to local files
    for (auto& conf : calol2_algo_payloads) {
      std::ofstream output(std::string("/tmp/").append(conf.first.substr(0, conf.first.find("/"))).append(".xml"));
      output << conf.second;
      output.close();
    }
    std::ofstream output(std::string("/tmp/").append(calol2_hw_key.substr(0, calol2_hw_key.find('/'))).append(".xml"));
    output << calol2_hw_payload;
    output.close();
  }
  if (exclusiveLayer == 0 || exclusiveLayer == 1) {
    std::ofstream output(
        std::string("/tmp/").append(calol1_algo_key.substr(0, calol1_algo_key.find('/'))).append(".xml"));
    output << calol1_algo_payload;
    output.close();
  }

  l1t::CaloParamsHelperO2O m_params_helper(baseSettings);

  if (exclusiveLayer == 0 || exclusiveLayer == 1) {
    try {
      l1t::XmlConfigParser xmlReader1;
      xmlReader1.readDOMFromString(calol1_algo_payload);

      l1t::TriggerSystem calol1;
      calol1.addProcessor("processors", "processors", "-1", "-1");
      xmlReader1.readRootElement(calol1, "calol1");
      calol1.setConfigured();

      std::map<std::string, l1t::Parameter> calol1_conf = calol1.getParameters("processors");
      std::map<std::string, l1t::Mask> calol1_rs;  //= calol1.getMasks   ("processors");

      if (!readCaloLayer1OnlineSettings(m_params_helper, calol1_conf, calol1_rs))
        throw std::runtime_error("Parsing error for CaloLayer1");

    } catch (std::runtime_error& e) {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
      if (transactionSafe)
        throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
      else {
        edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
        return std::make_unique<const l1t::CaloParams>(baseSettings);
      }
    }
  }

  if (exclusiveLayer == 0 || exclusiveLayer == 2) {
    try {
      l1t::TriggerSystem calol2;
      l1t::XmlConfigParser xmlReader2;
      xmlReader2.readDOMFromString(calol2_hw_payload);
      xmlReader2.readRootElement(calol2, "calol2");

      for (auto& conf : calol2_algo_payloads) {
        xmlReader2.readDOMFromString(conf.second);
        xmlReader2.readRootElement(calol2, "calol2");
      }

      //            calol2.setSystemId("calol2");
      calol2.setConfigured();

      std::map<std::string, l1t::Parameter> calol2_conf = calol2.getParameters("MP1");
      std::map<std::string, l1t::Parameter> calol2_conf_demux = calol2.getParameters("DEMUX");
      calol2_conf.insert(calol2_conf_demux.begin(), calol2_conf_demux.end());
      std::map<std::string, l1t::Mask> calol2_rs;  //= calol2.getMasks   ("processors");

      if (!readCaloLayer2OnlineSettings(m_params_helper, calol2_conf, calol2_rs))
        throw std::runtime_error("Parsing error for CaloLayer2");

    } catch (std::runtime_error& e) {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
      if (transactionSafe)
        throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
      else {
        edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
        return std::make_unique<const l1t::CaloParams>(baseSettings);
      }
    }
  }

  auto retval = std::make_unique<const l1t::CaloParams>(m_params_helper);

  edm::LogInfo("L1-O2O: L1TCaloParamsOnlineProd") << "SummaryForFunctionManager: Calo  | OK      | All looks good";
  return retval;
}

readCaloLayer1OnlineSettings()

bool L1TCaloParamsOnlineProd::readCaloLayer1OnlineSettings ( l1t::CaloParamsHelperO2O &  paramsHelper, std::map< std::string, l1t::Parameter > &  conf, std::map< std::string, l1t::Mask > &    )

private

Definition at line 41 of file L1TCaloParamsOnlineProd.cc.

References l1t::CaloParamsHelperO2O::setLayer1ECalScaleETBins(), l1t::CaloParamsHelperO2O::setLayer1ECalScaleFactors(), l1t::CaloParamsHelperO2O::setLayer1ECalScalePhiBins(), l1t::CaloParamsHelperO2O::setLayer1HCalFBLUTLower(), l1t::CaloParamsHelperO2O::setLayer1HCalFBLUTUpper(), l1t::CaloParamsHelperO2O::setLayer1HCalScaleETBins(), l1t::CaloParamsHelperO2O::setLayer1HCalScaleFactors(), l1t::CaloParamsHelperO2O::setLayer1HCalScalePhiBins(), l1t::CaloParamsHelperO2O::setLayer1HFScaleETBins(), l1t::CaloParamsHelperO2O::setLayer1HFScaleFactors(), l1t::CaloParamsHelperO2O::setLayer1HFScalePhiBins(), and l1t::CaloParamsHelperO2O::setLayer1SecondStageLUT().

Referenced by newObject().

                                                                                        {
  const char* expectedParams[] = {
      "layer1ECalScaleFactors",
      "layer1HCalScaleFactors",
      "layer1HFScaleFactors",
      "layer1ECalScaleETBins",
      "layer1HCalScaleETBins",
      "layer1HFScaleETBins"
      // Optional params
      //"layer1ECalScalePhiBins",
      //"layer1HCalScalePhiBins",
      //"layer1HFScalePhiBins",
      //"layer1SecondStageLUT",
      //"layer1HCalFBLUTUpper",
      //"layer1HCalFBLUTLower"
  };
  for (const auto param : expectedParams) {
    if (conf.find(param) == conf.end()) {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd")
          << "Unable to locate expected CaloLayer1 parameter: " << param << " in L1 settings payload!";
      return false;
    }
  }
  // Layer 1 LUT specification
  paramsHelper.setLayer1ECalScaleFactors((conf["layer1ECalScaleFactors"].getVector<double>()));
  paramsHelper.setLayer1HCalScaleFactors((conf["layer1HCalScaleFactors"].getVector<double>()));
  paramsHelper.setLayer1HFScaleFactors((conf["layer1HFScaleFactors"].getVector<double>()));
  paramsHelper.setLayer1ECalScaleETBins(conf["layer1ECalScaleETBins"].getVector<int>());
  paramsHelper.setLayer1HCalScaleETBins(conf["layer1HCalScaleETBins"].getVector<int>());
  paramsHelper.setLayer1HFScaleETBins(conf["layer1HFScaleETBins"].getVector<int>());

  if (conf.find("layer1ECalScalePhiBins") != conf.end())
    paramsHelper.setLayer1ECalScalePhiBins(
        conf["layer1ECalScalePhiBins"].getVector<unsigned int>());  // std::vector<unsigned>(36,0)
  if (conf.find("layer1HCalScalePhiBins") != conf.end())
    paramsHelper.setLayer1HCalScalePhiBins(conf["layer1HCalScalePhiBins"].getVector<unsigned int>());
  if (conf.find("layer1HFScalePhiBins") != conf.end())
    paramsHelper.setLayer1HFScalePhiBins(conf["layer1HFScalePhiBins"].getVector<unsigned int>());
  if (conf.find("layer1SecondStageLUT") != conf.end())
    paramsHelper.setLayer1SecondStageLUT(conf["layer1SecondStageLUT"].getVector<unsigned int>());
  if (conf.find("layer1HCalFBLUTUpper") != conf.end())
    paramsHelper.setLayer1HCalFBLUTUpper(conf["layer1HCalFBLUTUpper"].getVector<unsigned int>());
  if (conf.find("layer1HCalFBLUTLower") != conf.end())
    paramsHelper.setLayer1HCalFBLUTLower(conf["layer1HCalFBLUTLower"].getVector<unsigned int>());

  return true;
}

readCaloLayer2OnlineSettings()

bool L1TCaloParamsOnlineProd::readCaloLayer2OnlineSettings ( l1t::CaloParamsHelperO2O &  paramsHelper, std::map< std::string, l1t::Parameter > &  conf, std::map< std::string, l1t::Mask > &    )

private

Definition at line 91 of file L1TCaloParamsOnlineProd.cc.

References l1t::convertToLUT(), caloParams_2018_v1_0_ECALZS_inconsistent_cfi::etSumEtaMax, mps_fire::i, l1t::CaloParamsHelperO2O::setEgBypassECALFG(), l1t::CaloParamsHelperO2O::setEgBypassEGVetos(), l1t::CaloParamsHelperO2O::setEgBypassExtHOverE(), l1t::CaloParamsHelperO2O::setEgBypassShape(), l1t::CaloParamsHelperO2O::setEgCalibrationLUT(), l1t::CaloParamsHelperO2O::setEgEtaCut(), l1t::CaloParamsHelperO2O::setEgHOverEcutBarrel(), l1t::CaloParamsHelperO2O::setEgHOverEcutEndcap(), l1t::CaloParamsHelperO2O::setEgIsolationLUT(), l1t::CaloParamsHelperO2O::setEgIsolationLUT2(), l1t::CaloParamsHelperO2O::setEgMaxPtHOverE(), l1t::CaloParamsHelperO2O::setEgNeighbourThreshold(), l1t::CaloParamsHelperO2O::setEgSeedThreshold(), l1t::CaloParamsHelperO2O::setEtSumCentLower(), l1t::CaloParamsHelperO2O::setEtSumCentUpper(), l1t::CaloParamsHelperO2O::setEtSumEcalSumCalibrationLUT(), l1t::CaloParamsHelperO2O::setEtSumEcalSumPUSLUT(), l1t::CaloParamsHelperO2O::setEtSumEtaMax(), l1t::CaloParamsHelperO2O::setEtSumEttCalibrationLUT(), l1t::CaloParamsHelperO2O::setEtSumEtThreshold(), l1t::CaloParamsHelperO2O::setEtSumEttPUSLUT(), l1t::CaloParamsHelperO2O::setEtSumMetPUSLUT(), l1t::CaloParamsHelperO2O::setIsoTauEtaMax(), l1t::CaloParamsHelperO2O::setJetBypassPUS(), l1t::CaloParamsHelperO2O::setJetCalibrationLUT(), l1t::CaloParamsHelperO2O::setJetPUSUsePhiRing(), l1t::CaloParamsHelperO2O::setJetSeedThreshold(), l1t::CaloParamsHelperO2O::setMetCalibrationLUT(), l1t::CaloParamsHelperO2O::setMetHFCalibrationLUT(), l1t::CaloParamsHelperO2O::setMetHFPhiCalibrationLUT(), l1t::CaloParamsHelperO2O::setMetPhiCalibrationLUT(), l1t::CaloParamsHelperO2O::setPileUpTowerThreshold(), l1t::CaloParamsHelperO2O::setTauCalibrationLUT(), l1t::CaloParamsHelperO2O::setTauIsolationLUT(), l1t::CaloParamsHelperO2O::setTauNeighbourThreshold(), l1t::CaloParamsHelperO2O::setTauSeedThreshold(), l1t::CaloParamsHelperO2O::setTauTrimmingShapeVetoLUT(), and parallelization::uint.

Referenced by newObject().

                                                                                        {
  const char* expectedParams[] = {
      "leptonSeedThreshold",
      "leptonTowerThreshold",
      "pileUpTowerThreshold",
      "egammaRelaxationThreshold",
      "egammaMaxEta",
      "egammaBypassCuts",
      "egammaBypassShape",
      "egammaBypassEcalFG",
      "egammaBypassExtendedHOverE",
      "egammaHOverECut_iEtaLT15",
      "egammaHOverECut_iEtaGTEq15",
      "egammaEnergyCalibLUT",
      "egammaIsoLUT1",
      "egammaIsoLUT2",
      "tauMaxEta",
      "tauEnergyCalibLUT",
      "tauIsoLUT",
      "tauTrimmingLUT",
      "jetSeedThreshold",
      "HTMHT_maxJetEta",
      "HT_jetThreshold",
      "MHT_jetThreshold",
      "jetBypassPileUpSub",
      "jetEnergyCalibLUT",
      "jetPUSUsePhiRing",
      "towerCountThreshold",
      "towerCountMaxEta",
      "ETMET_maxTowerEta",
      "ecalET_towerThresholdLUT",
      "ET_towerThresholdLUT",
      "MET_towerThresholdLUT",
      "ET_centralityLowerThresholds",
      "ET_centralityUpperThresholds",
      "ET_energyCalibLUT",
      "ecalET_energyCalibLUT",
      "MET_energyCalibLUT",
      "METHF_energyCalibLUT",
      "MET_phiCalibLUT",
      "METHF_phiCalibLUT",
  };

  for (const auto param : expectedParams) {
    if (conf.find(param) == conf.end()) {
      edm::LogError("L1-O2O: L1TCaloParamsOnlineProd")
          << "Unable to locate expected CaloLayer2 parameter: " << param << " in L1 settings payload!";
      return false;
    }
  }
  // Layer 2 params specification
  paramsHelper.setEgSeedThreshold((conf["leptonSeedThreshold"].getValue<int>()) / 2.);
  paramsHelper.setTauSeedThreshold((conf["leptonSeedThreshold"].getValue<int>()) / 2.);
  paramsHelper.setEgNeighbourThreshold((conf["leptonTowerThreshold"].getValue<int>()) / 2.);
  paramsHelper.setTauNeighbourThreshold((conf["leptonTowerThreshold"].getValue<int>()) / 2.);
  paramsHelper.setPileUpTowerThreshold((conf["pileUpTowerThreshold"].getValue<int>()) / 2.);

  paramsHelper.setEgMaxPtHOverE((conf["egammaRelaxationThreshold"].getValue<int>()) / 2.);
  paramsHelper.setEgEtaCut((conf["egammaMaxEta"].getValue<int>()));
  paramsHelper.setEgBypassEGVetos(conf["egammaBypassCuts"].getValue<bool>());
  paramsHelper.setEgBypassShape(conf["egammaBypassShape"].getValue<bool>());
  paramsHelper.setEgBypassECALFG(conf["egammaBypassEcalFG"].getValue<bool>());
  paramsHelper.setEgBypassExtHOverE(conf["egammaBypassExtendedHOverE"].getValue<bool>());
  paramsHelper.setEgHOverEcutBarrel(conf["egammaHOverECut_iEtaLT15"].getValue<int>());
  paramsHelper.setEgHOverEcutEndcap(conf["egammaHOverECut_iEtaGTEq15"].getValue<int>());
  paramsHelper.setEgCalibrationLUT(l1t::convertToLUT(conf["egammaEnergyCalibLUT"].getVector<int>()));
  paramsHelper.setEgIsolationLUT(l1t::convertToLUT(conf["egammaIsoLUT1"].getVector<int>()));
  paramsHelper.setEgIsolationLUT2(l1t::convertToLUT(conf["egammaIsoLUT2"].getVector<int>()));

  paramsHelper.setIsoTauEtaMax((conf["tauMaxEta"].getValue<int>()));
  paramsHelper.setTauCalibrationLUT(l1t::convertToLUT(conf["tauEnergyCalibLUT"].getVector<int>()));
  paramsHelper.setTauIsolationLUT(l1t::convertToLUT(conf["tauIsoLUT"].getVector<int>()));
  paramsHelper.setTauTrimmingShapeVetoLUT(l1t::convertToLUT(conf["tauTrimmingLUT"].getVector<int>()));

  paramsHelper.setJetSeedThreshold((conf["jetSeedThreshold"].getValue<int>()) / 2.);
  paramsHelper.setJetBypassPUS(conf["jetBypassPileUpSub"].getValue<bool>());
  paramsHelper.setJetPUSUsePhiRing(conf["jetPUSUsePhiRing"].getValue<bool>());
  paramsHelper.setJetCalibrationLUT(l1t::convertToLUT(conf["jetEnergyCalibLUT"].getVector<uint32_t>()));

  std::vector<int> etSumEtaMax;
  std::vector<int> etSumEtThresh;

  etSumEtaMax.push_back(conf["ETMET_maxTowerEta"].getValue<int>());
  etSumEtaMax.push_back(conf["HTMHT_maxJetEta"].getValue<int>());
  etSumEtaMax.push_back(conf["ETMET_maxTowerEta"].getValue<int>());
  etSumEtaMax.push_back(conf["HTMHT_maxJetEta"].getValue<int>());
  etSumEtaMax.push_back(conf["towerCountMaxEta"].getValue<int>());

  etSumEtThresh.push_back(0);  //deprecated by EttPUSLUT
  etSumEtThresh.push_back(conf["HT_jetThreshold"].getValue<int>() / 2.);
  etSumEtThresh.push_back(0);  //deprecated by MetPUSLUT
  etSumEtThresh.push_back(conf["MHT_jetThreshold"].getValue<int>() / 2.);
  etSumEtThresh.push_back(conf["towerCountThreshold"].getValue<int>() / 2.);

  for (uint i = 0; i < 5; ++i) {
    paramsHelper.setEtSumEtaMax(i, etSumEtaMax.at(i));
    paramsHelper.setEtSumEtThreshold(i, etSumEtThresh.at(i));
  }

  paramsHelper.setEtSumMetPUSLUT(l1t::convertToLUT(conf["MET_towerThresholdLUT"].getVector<int>()));
  paramsHelper.setEtSumEttPUSLUT(l1t::convertToLUT(conf["ET_towerThresholdLUT"].getVector<int>()));
  paramsHelper.setEtSumEcalSumPUSLUT(l1t::convertToLUT(conf["ecalET_towerThresholdLUT"].getVector<int>()));

  std::vector<double> etSumCentLowerValues;
  std::vector<double> etSumCentUpperValues;

  etSumCentLowerValues = conf["ET_centralityLowerThresholds"].getVector<double>();
  etSumCentUpperValues = conf["ET_centralityUpperThresholds"].getVector<double>();

  for (uint i = 0; i < 8; ++i) {
    paramsHelper.setEtSumCentLower(i, etSumCentLowerValues[i] / 2.);
    paramsHelper.setEtSumCentUpper(i, etSumCentUpperValues[i] / 2.);
  }

  // demux tower sum calib LUTs
  paramsHelper.setEtSumEttCalibrationLUT(l1t::convertToLUT(conf["ET_energyCalibLUT"].getVector<int>()));
  paramsHelper.setEtSumEcalSumCalibrationLUT(l1t::convertToLUT(conf["ecalET_energyCalibLUT"].getVector<int>()));
  paramsHelper.setMetCalibrationLUT(l1t::convertToLUT(conf["MET_energyCalibLUT"].getVector<int>()));
  paramsHelper.setMetHFCalibrationLUT(l1t::convertToLUT(conf["METHF_energyCalibLUT"].getVector<int>()));
  paramsHelper.setMetPhiCalibrationLUT(l1t::convertToLUT(conf["MET_phiCalibLUT"].getVector<int>()));
  paramsHelper.setMetHFPhiCalibrationLUT(l1t::convertToLUT(conf["METHF_phiCalibLUT"].getVector<int>()));

  return true;
}

Member Data Documentation

baseSettings_token

const edm::ESGetToken<l1t::CaloParams, L1TCaloParamsRcd> L1TCaloParamsOnlineProd::baseSettings_token

private

Definition at line 22 of file L1TCaloParamsOnlineProd.cc.

Referenced by newObject().

exclusiveLayer

const unsigned int L1TCaloParamsOnlineProd::exclusiveLayer

private

Definition at line 23 of file L1TCaloParamsOnlineProd.cc.

Referenced by newObject().

transactionSafe

const bool L1TCaloParamsOnlineProd::transactionSafe

private

Definition at line 24 of file L1TCaloParamsOnlineProd.cc.

Referenced by newObject().