Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-06 12:22:23 

0001 #include <iostream>
0002 #include <fstream>
0003 #include <stdexcept>
0004 #include <sstream>
0005 
0006 #include "CondTools/L1TriggerExt/interface/L1ConfigOnlineProdBaseExt.h"
0007 #include "CondFormats/L1TObjects/interface/CaloParams.h"
0008 #include "CondFormats/DataRecord/interface/L1TCaloParamsRcd.h"
0009 #include "CondFormats/DataRecord/interface/L1TCaloParamsO2ORcd.h"
0010 #include "L1Trigger/L1TCommon/interface/TriggerSystem.h"
0011 #include "L1Trigger/L1TCommon/interface/XmlConfigParser.h"
0012 #include "L1Trigger/L1TCommon/interface/ConvertToLUT.h"
0013 //#include "L1Trigger/L1TCalorimeter/interface/CaloParamsHelper.h"
0014 #include "CaloParamsHelperO2O.h"
0015 #include "OnlineDBqueryHelper.h"
0016 
0017 #include "xercesc/util/PlatformUtils.hpp"
0018 using namespace XERCES_CPP_NAMESPACE;
0019 
0020 class L1TCaloParamsOnlineProd : public L1ConfigOnlineProdBaseExt<L1TCaloParamsO2ORcd, l1t::CaloParams> {
0021 private:
0022   const edm::ESGetToken<l1t::CaloParams, L1TCaloParamsRcd> baseSettings_token;
0023   const unsigned int exclusiveLayer;  // 0 - process calol1 and calol2, 1 - only calol1, 2 - only calol2
0024   const bool transactionSafe;
0025 
0026   bool readCaloLayer1OnlineSettings(l1t::CaloParamsHelperO2O& paramsHelper,
0027                                     std::map<std::string, l1t::Parameter>& conf,
0028                                     std::map<std::string, l1t::Mask>&);
0029   bool readCaloLayer2OnlineSettings(l1t::CaloParamsHelperO2O& paramsHelper,
0030                                     std::map<std::string, l1t::Parameter>& conf,
0031                                     std::map<std::string, l1t::Mask>&);
0032 
0033 public:
0034   std::unique_ptr<const l1t::CaloParams> newObject(const std::string& objectKey,
0035                                                    const L1TCaloParamsO2ORcd& record) override;
0036 
0037   L1TCaloParamsOnlineProd(const edm::ParameterSet&);
0038   ~L1TCaloParamsOnlineProd(void) override {}
0039 };
0040 
0041 bool L1TCaloParamsOnlineProd::readCaloLayer1OnlineSettings(l1t::CaloParamsHelperO2O& paramsHelper,
0042                                                            std::map<std::string, l1t::Parameter>& conf,
0043                                                            std::map<std::string, l1t::Mask>&) {
0044   const char* expectedParams[] = {
0045       "layer1ECalScaleFactors",
0046       "layer1HCalScaleFactors",
0047       "layer1HFScaleFactors",
0048       "layer1ECalScaleETBins",
0049       "layer1HCalScaleETBins",
0050       "layer1HFScaleETBins"
0051       // Optional params
0052       //"layer1ECalScalePhiBins",
0053       //"layer1HCalScalePhiBins",
0054       //"layer1HFScalePhiBins",
0055       //"layer1SecondStageLUT",
0056       //"layer1HCalFBLUTUpper",
0057       //"layer1HCalFBLUTLower"
0058   };
0059   for (const auto param : expectedParams) {
0060     if (conf.find(param) == conf.end()) {
0061       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd")
0062           << "Unable to locate expected CaloLayer1 parameter: " << param << " in L1 settings payload!";
0063       return false;
0064     }
0065   }
0066   // Layer 1 LUT specification
0067   paramsHelper.setLayer1ECalScaleFactors((conf["layer1ECalScaleFactors"].getVector<double>()));
0068   paramsHelper.setLayer1HCalScaleFactors((conf["layer1HCalScaleFactors"].getVector<double>()));
0069   paramsHelper.setLayer1HFScaleFactors((conf["layer1HFScaleFactors"].getVector<double>()));
0070   paramsHelper.setLayer1ECalScaleETBins(conf["layer1ECalScaleETBins"].getVector<int>());
0071   paramsHelper.setLayer1HCalScaleETBins(conf["layer1HCalScaleETBins"].getVector<int>());
0072   paramsHelper.setLayer1HFScaleETBins(conf["layer1HFScaleETBins"].getVector<int>());
0073 
0074   if (conf.find("layer1ECalScalePhiBins") != conf.end())
0075     paramsHelper.setLayer1ECalScalePhiBins(
0076         conf["layer1ECalScalePhiBins"].getVector<unsigned int>());  // std::vector<unsigned>(36,0)
0077   if (conf.find("layer1HCalScalePhiBins") != conf.end())
0078     paramsHelper.setLayer1HCalScalePhiBins(conf["layer1HCalScalePhiBins"].getVector<unsigned int>());
0079   if (conf.find("layer1HFScalePhiBins") != conf.end())
0080     paramsHelper.setLayer1HFScalePhiBins(conf["layer1HFScalePhiBins"].getVector<unsigned int>());
0081   if (conf.find("layer1SecondStageLUT") != conf.end())
0082     paramsHelper.setLayer1SecondStageLUT(conf["layer1SecondStageLUT"].getVector<unsigned int>());
0083   if (conf.find("layer1HCalFBLUTUpper") != conf.end())
0084     paramsHelper.setLayer1HCalFBLUTUpper(conf["layer1HCalFBLUTUpper"].getVector<unsigned int>());
0085   if (conf.find("layer1HCalFBLUTLower") != conf.end())
0086     paramsHelper.setLayer1HCalFBLUTLower(conf["layer1HCalFBLUTLower"].getVector<unsigned int>());
0087 
0088   return true;
0089 }
0090 
0091 bool L1TCaloParamsOnlineProd::readCaloLayer2OnlineSettings(l1t::CaloParamsHelperO2O& paramsHelper,
0092                                                            std::map<std::string, l1t::Parameter>& conf,
0093                                                            std::map<std::string, l1t::Mask>&) {
0094   const char* expectedParams[] = {
0095       "leptonSeedThreshold",
0096       "leptonTowerThreshold",
0097       "pileUpTowerThreshold",
0098       "egammaRelaxationThreshold",
0099       "egammaMaxEta",
0100       "egammaBypassCuts",
0101       "egammaBypassShape",
0102       "egammaBypassEcalFG",
0103       "egammaBypassExtendedHOverE",
0104       "egammaHOverECut_iEtaLT15",
0105       "egammaHOverECut_iEtaGTEq15",
0106       "egammaEnergyCalibLUT",
0107       "egammaIsoLUT1",
0108       "egammaIsoLUT2",
0109       "tauMaxEta",
0110       "tauEnergyCalibLUT",
0111       "tauIsoLUT",
0112       "tauTrimmingLUT",
0113       "jetSeedThreshold",
0114       "HTMHT_maxJetEta",
0115       "HT_jetThreshold",
0116       "MHT_jetThreshold",
0117       "jetBypassPileUpSub",
0118       "jetEnergyCalibLUT",
0119       "jetPUSUsePhiRing",
0120       "towerCountThreshold",
0121       "towerCountMaxEta",
0122       "ETMET_maxTowerEta",
0123       "ecalET_towerThresholdLUT",
0124       "ET_towerThresholdLUT",
0125       "MET_towerThresholdLUT",
0126       "ET_centralityLowerThresholds",
0127       "ET_centralityUpperThresholds",
0128       "ET_energyCalibLUT",
0129       "ecalET_energyCalibLUT",
0130       "MET_energyCalibLUT",
0131       "METHF_energyCalibLUT",
0132       "MET_phiCalibLUT",
0133       "METHF_phiCalibLUT",
0134   };
0135 
0136   for (const auto param : expectedParams) {
0137     if (conf.find(param) == conf.end()) {
0138       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd")
0139           << "Unable to locate expected CaloLayer2 parameter: " << param << " in L1 settings payload!";
0140       return false;
0141     }
0142   }
0143   // Layer 2 params specification
0144   paramsHelper.setEgSeedThreshold((conf["leptonSeedThreshold"].getValue<int>()) / 2.);
0145   paramsHelper.setTauSeedThreshold((conf["leptonSeedThreshold"].getValue<int>()) / 2.);
0146   paramsHelper.setEgNeighbourThreshold((conf["leptonTowerThreshold"].getValue<int>()) / 2.);
0147   paramsHelper.setTauNeighbourThreshold((conf["leptonTowerThreshold"].getValue<int>()) / 2.);
0148   paramsHelper.setPileUpTowerThreshold((conf["pileUpTowerThreshold"].getValue<int>()) / 2.);
0149 
0150   paramsHelper.setEgMaxPtHOverE((conf["egammaRelaxationThreshold"].getValue<int>()) / 2.);
0151   paramsHelper.setEgEtaCut((conf["egammaMaxEta"].getValue<int>()));
0152   paramsHelper.setEgBypassEGVetos(conf["egammaBypassCuts"].getValue<bool>());
0153   paramsHelper.setEgBypassShape(conf["egammaBypassShape"].getValue<bool>());
0154   paramsHelper.setEgBypassECALFG(conf["egammaBypassEcalFG"].getValue<bool>());
0155   paramsHelper.setEgBypassExtHOverE(conf["egammaBypassExtendedHOverE"].getValue<bool>());
0156   paramsHelper.setEgHOverEcutBarrel(conf["egammaHOverECut_iEtaLT15"].getValue<int>());
0157   paramsHelper.setEgHOverEcutEndcap(conf["egammaHOverECut_iEtaGTEq15"].getValue<int>());
0158   paramsHelper.setEgCalibrationLUT(l1t::convertToLUT(conf["egammaEnergyCalibLUT"].getVector<int>()));
0159   paramsHelper.setEgIsolationLUT(l1t::convertToLUT(conf["egammaIsoLUT1"].getVector<int>()));
0160   paramsHelper.setEgIsolationLUT2(l1t::convertToLUT(conf["egammaIsoLUT2"].getVector<int>()));
0161 
0162   paramsHelper.setIsoTauEtaMax((conf["tauMaxEta"].getValue<int>()));
0163   paramsHelper.setTauCalibrationLUT(l1t::convertToLUT(conf["tauEnergyCalibLUT"].getVector<int>()));
0164   paramsHelper.setTauIsolationLUT(l1t::convertToLUT(conf["tauIsoLUT"].getVector<int>()));
0165   paramsHelper.setTauTrimmingShapeVetoLUT(l1t::convertToLUT(conf["tauTrimmingLUT"].getVector<int>()));
0166 
0167   paramsHelper.setJetSeedThreshold((conf["jetSeedThreshold"].getValue<int>()) / 2.);
0168   paramsHelper.setJetBypassPUS(conf["jetBypassPileUpSub"].getValue<bool>());
0169   paramsHelper.setJetPUSUsePhiRing(conf["jetPUSUsePhiRing"].getValue<bool>());
0170   paramsHelper.setJetCalibrationLUT(l1t::convertToLUT(conf["jetEnergyCalibLUT"].getVector<uint32_t>()));
0171 
0172   std::vector<int> etSumEtaMax;
0173   std::vector<int> etSumEtThresh;
0174 
0175   etSumEtaMax.push_back(conf["ETMET_maxTowerEta"].getValue<int>());
0176   etSumEtaMax.push_back(conf["HTMHT_maxJetEta"].getValue<int>());
0177   etSumEtaMax.push_back(conf["ETMET_maxTowerEta"].getValue<int>());
0178   etSumEtaMax.push_back(conf["HTMHT_maxJetEta"].getValue<int>());
0179   etSumEtaMax.push_back(conf["towerCountMaxEta"].getValue<int>());
0180 
0181   etSumEtThresh.push_back(0);  //deprecated by EttPUSLUT
0182   etSumEtThresh.push_back(conf["HT_jetThreshold"].getValue<int>() / 2.);
0183   etSumEtThresh.push_back(0);  //deprecated by MetPUSLUT
0184   etSumEtThresh.push_back(conf["MHT_jetThreshold"].getValue<int>() / 2.);
0185   etSumEtThresh.push_back(conf["towerCountThreshold"].getValue<int>() / 2.);
0186 
0187   for (uint i = 0; i < 5; ++i) {
0188     paramsHelper.setEtSumEtaMax(i, etSumEtaMax.at(i));
0189     paramsHelper.setEtSumEtThreshold(i, etSumEtThresh.at(i));
0190   }
0191 
0192   paramsHelper.setEtSumMetPUSLUT(l1t::convertToLUT(conf["MET_towerThresholdLUT"].getVector<int>()));
0193   paramsHelper.setEtSumEttPUSLUT(l1t::convertToLUT(conf["ET_towerThresholdLUT"].getVector<int>()));
0194   paramsHelper.setEtSumEcalSumPUSLUT(l1t::convertToLUT(conf["ecalET_towerThresholdLUT"].getVector<int>()));
0195 
0196   std::vector<double> etSumCentLowerValues;
0197   std::vector<double> etSumCentUpperValues;
0198 
0199   etSumCentLowerValues = conf["ET_centralityLowerThresholds"].getVector<double>();
0200   etSumCentUpperValues = conf["ET_centralityUpperThresholds"].getVector<double>();
0201 
0202   for (uint i = 0; i < 8; ++i) {
0203     paramsHelper.setEtSumCentLower(i, etSumCentLowerValues[i] / 2.);
0204     paramsHelper.setEtSumCentUpper(i, etSumCentUpperValues[i] / 2.);
0205   }
0206 
0207   // demux tower sum calib LUTs
0208   paramsHelper.setEtSumEttCalibrationLUT(l1t::convertToLUT(conf["ET_energyCalibLUT"].getVector<int>()));
0209   paramsHelper.setEtSumEcalSumCalibrationLUT(l1t::convertToLUT(conf["ecalET_energyCalibLUT"].getVector<int>()));
0210   paramsHelper.setMetCalibrationLUT(l1t::convertToLUT(conf["MET_energyCalibLUT"].getVector<int>()));
0211   paramsHelper.setMetHFCalibrationLUT(l1t::convertToLUT(conf["METHF_energyCalibLUT"].getVector<int>()));
0212   paramsHelper.setMetPhiCalibrationLUT(l1t::convertToLUT(conf["MET_phiCalibLUT"].getVector<int>()));
0213   paramsHelper.setMetHFPhiCalibrationLUT(l1t::convertToLUT(conf["METHF_phiCalibLUT"].getVector<int>()));
0214 
0215   return true;
0216 }
0217 
0218 L1TCaloParamsOnlineProd::L1TCaloParamsOnlineProd(const edm::ParameterSet& iConfig)
0219     : L1ConfigOnlineProdBaseExt<L1TCaloParamsO2ORcd, l1t::CaloParams>(iConfig),
0220       baseSettings_token(wrappedSetWhatProduced(iConfig).consumes()),
0221       exclusiveLayer(iConfig.getParameter<uint32_t>("exclusiveLayer")),
0222       transactionSafe(iConfig.getParameter<bool>("transactionSafe")) {}
0223 
0224 std::unique_ptr<const l1t::CaloParams> L1TCaloParamsOnlineProd::newObject(const std::string& objectKey,
0225                                                                           const L1TCaloParamsO2ORcd& record) {
0226   const L1TCaloParamsRcd& baseRcd = record.template getRecord<L1TCaloParamsRcd>();
0227   auto const& baseSettings = baseRcd.get(baseSettings_token);
0228 
0229   if (objectKey.empty()) {
0230     edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "Key is empty";
0231     if (transactionSafe)
0232       throw std::runtime_error("SummaryForFunctionManager: Calo  | Faulty  | Empty objectKey");
0233     else {
0234       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
0235       return std::make_unique<const l1t::CaloParams>(baseSettings);
0236     }
0237   }
0238 
0239   std::string tscKey = objectKey.substr(0, objectKey.find(':'));
0240   std::string rsKey = objectKey.substr(objectKey.find(':') + 1, std::string::npos);
0241 
0242   edm::LogInfo("L1-O2O: L1TCaloParamsOnlineProd")
0243       << "Producing L1TCaloParamsOnlineProd with TSC key = " << tscKey << " and RS key = " << rsKey;
0244 
0245   std::string calol1_top_key, calol1_algo_key;
0246   std::string calol1_algo_payload;
0247   std::string calol2_top_key, calol2_algo_key, calol2_hw_key;
0248   std::string calol2_hw_payload;
0249   std::map<std::string, std::string> calol2_algo_payloads;  // key -> XML payload
0250   try {
0251     std::map<std::string, std::string> topKeys =
0252         l1t::OnlineDBqueryHelper::fetch({"CALOL1_KEY", "CALOL2_KEY"}, "L1_TRG_CONF_KEYS", tscKey, m_omdsReader);
0253 
0254     if (exclusiveLayer == 0 || exclusiveLayer == 1) {
0255       calol1_top_key = topKeys["CALOL1_KEY"];
0256 
0257       calol1_algo_key = l1t::OnlineDBqueryHelper::fetch({"ALGO"}, "CALOL1_KEYS", calol1_top_key, m_omdsReader)["ALGO"];
0258 
0259       calol1_algo_payload =
0260           l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL1_CLOBS", calol1_algo_key, m_omdsReader)["CONF"];
0261     }
0262 
0263     if (exclusiveLayer == 0 || exclusiveLayer == 2) {
0264       calol2_top_key = topKeys["CALOL2_KEY"];
0265 
0266       std::map<std::string, std::string> calol2_keys =
0267           l1t::OnlineDBqueryHelper::fetch({"ALGO", "HW"}, "CALOL2_KEYS", calol2_top_key, m_omdsReader);
0268 
0269       calol2_hw_key = calol2_keys["HW"];
0270       calol2_hw_payload =
0271           l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL2_CLOBS", calol2_hw_key, m_omdsReader)["CONF"];
0272 
0273       calol2_algo_key = calol2_keys["ALGO"];
0274 
0275       std::map<std::string, std::string> calol2_algo_keys =
0276           l1t::OnlineDBqueryHelper::fetch({"DEMUX", "MPS_COMMON", "MPS_JET", "MP_EGAMMA", "MP_SUM", "MP_TAU"},
0277                                           "CALOL2_ALGO_KEYS",
0278                                           calol2_algo_key,
0279                                           m_omdsReader);
0280 
0281       for (auto& key : calol2_algo_keys)
0282         calol2_algo_payloads[key.second] =
0283             l1t::OnlineDBqueryHelper::fetch({"CONF"}, "CALOL2_CLOBS", key.second, m_omdsReader)["CONF"];
0284     }
0285 
0286   } catch (std::runtime_error& e) {
0287     edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
0288     if (transactionSafe)
0289       throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
0290     else {
0291       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
0292       return std::make_unique<const l1t::CaloParams>(baseSettings);
0293     }
0294   }
0295 
0296   if (exclusiveLayer == 0 || exclusiveLayer == 2) {
0297     // for debugging purposes dump the configs to local files
0298     for (auto& conf : calol2_algo_payloads) {
0299       std::ofstream output(std::string("/tmp/").append(conf.first.substr(0, conf.first.find("/"))).append(".xml"));
0300       output << conf.second;
0301       output.close();
0302     }
0303     std::ofstream output(std::string("/tmp/").append(calol2_hw_key.substr(0, calol2_hw_key.find('/'))).append(".xml"));
0304     output << calol2_hw_payload;
0305     output.close();
0306   }
0307   if (exclusiveLayer == 0 || exclusiveLayer == 1) {
0308     std::ofstream output(
0309         std::string("/tmp/").append(calol1_algo_key.substr(0, calol1_algo_key.find('/'))).append(".xml"));
0310     output << calol1_algo_payload;
0311     output.close();
0312   }
0313 
0314   l1t::CaloParamsHelperO2O m_params_helper(baseSettings);
0315 
0316   if (exclusiveLayer == 0 || exclusiveLayer == 1) {
0317     try {
0318       l1t::XmlConfigParser xmlReader1;
0319       xmlReader1.readDOMFromString(calol1_algo_payload);
0320 
0321       l1t::TriggerSystem calol1;
0322       calol1.addProcessor("processors", "processors", "-1", "-1");
0323       xmlReader1.readRootElement(calol1, "calol1");
0324       calol1.setConfigured();
0325 
0326       std::map<std::string, l1t::Parameter> calol1_conf = calol1.getParameters("processors");
0327       std::map<std::string, l1t::Mask> calol1_rs;  //= calol1.getMasks   ("processors");
0328 
0329       if (!readCaloLayer1OnlineSettings(m_params_helper, calol1_conf, calol1_rs))
0330         throw std::runtime_error("Parsing error for CaloLayer1");
0331 
0332     } catch (std::runtime_error& e) {
0333       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
0334       if (transactionSafe)
0335         throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
0336       else {
0337         edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
0338         return std::make_unique<const l1t::CaloParams>(baseSettings);
0339       }
0340     }
0341   }
0342 
0343   if (exclusiveLayer == 0 || exclusiveLayer == 2) {
0344     try {
0345       l1t::TriggerSystem calol2;
0346       l1t::XmlConfigParser xmlReader2;
0347       xmlReader2.readDOMFromString(calol2_hw_payload);
0348       xmlReader2.readRootElement(calol2, "calol2");
0349 
0350       for (auto& conf : calol2_algo_payloads) {
0351         xmlReader2.readDOMFromString(conf.second);
0352         xmlReader2.readRootElement(calol2, "calol2");
0353       }
0354 
0355       //            calol2.setSystemId("calol2");
0356       calol2.setConfigured();
0357 
0358       std::map<std::string, l1t::Parameter> calol2_conf = calol2.getParameters("MP1");
0359       std::map<std::string, l1t::Parameter> calol2_conf_demux = calol2.getParameters("DEMUX");
0360       calol2_conf.insert(calol2_conf_demux.begin(), calol2_conf_demux.end());
0361       std::map<std::string, l1t::Mask> calol2_rs;  //= calol2.getMasks   ("processors");
0362 
0363       if (!readCaloLayer2OnlineSettings(m_params_helper, calol2_conf, calol2_rs))
0364         throw std::runtime_error("Parsing error for CaloLayer2");
0365 
0366     } catch (std::runtime_error& e) {
0367       edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << e.what();
0368       if (transactionSafe)
0369         throw std::runtime_error(std::string("SummaryForFunctionManager: Calo  | Faulty  | ") + e.what());
0370       else {
0371         edm::LogError("L1-O2O: L1TCaloParamsOnlineProd") << "returning unmodified prototype of l1t::CaloParams";
0372         return std::make_unique<const l1t::CaloParams>(baseSettings);
0373       }
0374     }
0375   }
0376 
0377   auto retval = std::make_unique<const l1t::CaloParams>(m_params_helper);
0378 
0379   edm::LogInfo("L1-O2O: L1TCaloParamsOnlineProd") << "SummaryForFunctionManager: Calo  | OK      | All looks good";
0380   return retval;
0381 }
0382 
0383 //define this as a plug-in
0384 DEFINE_FWK_EVENTSETUP_MODULE(L1TCaloParamsOnlineProd);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!