Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-05-20 22:25:18 

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