File indexing completed on 2024-04-06 12:09:36
0001 #include "DQMOffline/L1Trigger/interface/L1TStage2CaloLayer2Offline.h"
0002 #include "DQMOffline/L1Trigger/interface/L1TFillWithinLimits.h"
0003 #include "DQMOffline/L1Trigger/interface/L1TCommon.h"
0004
0005 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0006 #include "FWCore/Framework/interface/MakerMacros.h"
0007
0008 #include "DataFormats/Math/interface/deltaR.h"
0009 #include "DataFormats/Math/interface/deltaPhi.h"
0010 #include "DataFormats/Math/interface/LorentzVector.h"
0011 #include "TLorentzVector.h"
0012
0013 const std::map<std::string, unsigned int> L1TStage2CaloLayer2Offline::PlotConfigNames = {
0014 {"nVertex", PlotConfig::nVertex}, {"ETvsET", PlotConfig::ETvsET}, {"PHIvsPHI", PlotConfig::PHIvsPHI}};
0015
0016
0017
0018
0019 L1TStage2CaloLayer2Offline::L1TStage2CaloLayer2Offline(const edm::ParameterSet& ps)
0020 : thePFJetCollection_(consumes<reco::PFJetCollection>(ps.getParameter<edm::InputTag>("pfJetCollection"))),
0021 thecaloMETCollection_(consumes<reco::CaloMETCollection>(ps.getParameter<edm::InputTag>("caloMETCollection"))),
0022 thecaloETMHFCollection_(consumes<reco::CaloMETCollection>(ps.getParameter<edm::InputTag>("caloETMHFCollection"))),
0023 thePFMETNoMuCollection_(consumes<reco::PFMETCollection>(ps.getParameter<edm::InputTag>("pfMETNoMuCollection"))),
0024 thePVCollection_(consumes<reco::VertexCollection>(ps.getParameter<edm::InputTag>("PVCollection"))),
0025 theBSCollection_(consumes<reco::BeamSpot>(ps.getParameter<edm::InputTag>("beamSpotCollection"))),
0026 triggerInputTag_(consumes<trigger::TriggerEvent>(ps.getParameter<edm::InputTag>("triggerInputTag"))),
0027 triggerResultsInputTag_(consumes<edm::TriggerResults>(ps.getParameter<edm::InputTag>("triggerResults"))),
0028 triggerProcess_(ps.getParameter<std::string>("triggerProcess")),
0029 triggerNames_(ps.getParameter<std::vector<std::string>>("triggerNames")),
0030 histFolderEtSum_(ps.getParameter<std::string>("histFolderEtSum")),
0031 histFolderJet_(ps.getParameter<std::string>("histFolderJet")),
0032 efficiencyFolderEtSum_(histFolderEtSum_ + "/efficiency_raw"),
0033 efficiencyFolderJet_(histFolderJet_ + "/efficiency_raw"),
0034 stage2CaloLayer2JetToken_(
0035 consumes<l1t::JetBxCollection>(ps.getParameter<edm::InputTag>("stage2CaloLayer2JetSource"))),
0036 stage2CaloLayer2EtSumToken_(
0037 consumes<l1t::EtSumBxCollection>(ps.getParameter<edm::InputTag>("stage2CaloLayer2EtSumSource"))),
0038 jetEfficiencyThresholds_(ps.getParameter<std::vector<double>>("jetEfficiencyThresholds")),
0039 metEfficiencyThresholds_(ps.getParameter<std::vector<double>>("metEfficiencyThresholds")),
0040 mhtEfficiencyThresholds_(ps.getParameter<std::vector<double>>("mhtEfficiencyThresholds")),
0041 ettEfficiencyThresholds_(ps.getParameter<std::vector<double>>("ettEfficiencyThresholds")),
0042 httEfficiencyThresholds_(ps.getParameter<std::vector<double>>("httEfficiencyThresholds")),
0043 jetEfficiencyBins_(ps.getParameter<std::vector<double>>("jetEfficiencyBins")),
0044 metEfficiencyBins_(ps.getParameter<std::vector<double>>("metEfficiencyBins")),
0045 mhtEfficiencyBins_(ps.getParameter<std::vector<double>>("mhtEfficiencyBins")),
0046 ettEfficiencyBins_(ps.getParameter<std::vector<double>>("ettEfficiencyBins")),
0047 httEfficiencyBins_(ps.getParameter<std::vector<double>>("httEfficiencyBins")),
0048 recoHTTMaxEta_(ps.getParameter<double>("recoHTTMaxEta")),
0049 recoMHTMaxEta_(ps.getParameter<double>("recoMHTMaxEta")),
0050 hltConfig_(),
0051 triggerIndices_(),
0052 triggerResults_(),
0053 triggerEvent_(),
0054 histDefinitions_(dqmoffline::l1t::readHistDefinitions(ps.getParameterSet("histDefinitions"), PlotConfigNames)),
0055 h_nVertex_(),
0056 h_controlPlots_(),
0057 h_L1METvsCaloMET_(),
0058 h_L1ETMHFvsCaloETMHF_(),
0059 h_L1METvsPFMetNoMu_(),
0060 h_L1MHTvsRecoMHT_(),
0061 h_L1METTvsCaloETT_(),
0062 h_L1HTTvsRecoHTT_(),
0063 h_L1METPhivsCaloMETPhi_(),
0064 h_L1ETMHFPhivsCaloETMHFPhi_(),
0065 h_L1METPhivsPFMetNoMuPhi_(),
0066 h_L1MHTPhivsRecoMHTPhi_(),
0067 h_resolutionMET_(),
0068 h_resolutionETMHF_(),
0069 h_resolutionPFMetNoMu_(),
0070 h_resolutionMHT_(),
0071 h_resolutionETT_(),
0072 h_resolutionHTT_(),
0073 h_resolutionMETPhi_(),
0074 h_resolutionETMHFPhi_(),
0075 h_resolutionPFMetNoMuPhi_(),
0076 h_resolutionMHTPhi_(),
0077 h_efficiencyMET_pass_(),
0078 h_efficiencyETMHF_pass_(),
0079 h_efficiencyPFMetNoMu_pass_(),
0080 h_efficiencyMHT_pass_(),
0081 h_efficiencyETT_pass_(),
0082 h_efficiencyHTT_pass_(),
0083 h_efficiencyMET_total_(),
0084 h_efficiencyETMHF_total_(),
0085 h_efficiencyPFMetNoMu_total_(),
0086 h_efficiencyMHT_total_(),
0087 h_efficiencyETT_total_(),
0088 h_efficiencyHTT_total_(),
0089 h_L1JetETvsPFJetET_HB_(),
0090 h_L1JetETvsPFJetET_HE_(),
0091 h_L1JetETvsPFJetET_HF_(),
0092 h_L1JetETvsPFJetET_HB_HE_(),
0093 h_L1JetPhivsPFJetPhi_HB_(),
0094 h_L1JetPhivsPFJetPhi_HE_(),
0095 h_L1JetPhivsPFJetPhi_HF_(),
0096 h_L1JetPhivsPFJetPhi_HB_HE_(),
0097 h_L1JetEtavsPFJetEta_(),
0098 h_resolutionJetET_HB_(),
0099 h_resolutionJetET_HE_(),
0100 h_resolutionJetET_HF_(),
0101 h_resolutionJetET_HB_HE_(),
0102 h_resolutionJetPhi_HB_(),
0103 h_resolutionJetPhi_HE_(),
0104 h_resolutionJetPhi_HF_(),
0105 h_resolutionJetPhi_HB_HE_(),
0106 h_resolutionJetEta_(),
0107 h_efficiencyJetEt_HB_pass_(),
0108 h_efficiencyJetEt_HE_pass_(),
0109 h_efficiencyJetEt_HF_pass_(),
0110 h_efficiencyJetEt_HB_HE_pass_(),
0111 h_efficiencyJetEt_HB_total_(),
0112 h_efficiencyJetEt_HE_total_(),
0113 h_efficiencyJetEt_HF_total_(),
0114 h_efficiencyJetEt_HB_HE_total_() {
0115 edm::LogInfo("L1TStage2CaloLayer2Offline") << "Constructor "
0116 << "L1TStage2CaloLayer2Offline::L1TStage2CaloLayer2Offline " << std::endl;
0117 }
0118
0119
0120
0121
0122 L1TStage2CaloLayer2Offline::~L1TStage2CaloLayer2Offline() {
0123 edm::LogInfo("L1TStage2CaloLayer2Offline")
0124 << "Destructor L1TStage2CaloLayer2Offline::~L1TStage2CaloLayer2Offline " << std::endl;
0125 }
0126
0127
0128
0129
0130 void L1TStage2CaloLayer2Offline::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0131 edm::LogInfo("L1TStage2CaloLayer2Offline") << "L1TStage2CaloLayer2Offline::beginRun" << std::endl;
0132 bool changed(true);
0133 if (!hltConfig_.init(iRun, iSetup, triggerProcess_, changed)) {
0134 edm::LogError("L1TStage2CaloLayer2Offline")
0135 << " HLT config extraction failure with process name " << triggerProcess_ << std::endl;
0136 triggerNames_.clear();
0137 } else {
0138 triggerIndices_ = dqmoffline::l1t::getTriggerIndices(triggerNames_, hltConfig_.triggerNames());
0139 }
0140 }
0141
0142
0143
0144 void L1TStage2CaloLayer2Offline::bookHistograms(DQMStore::IBooker& ibooker_, edm::Run const&, edm::EventSetup const&) {
0145 edm::LogInfo("L1TStage2CaloLayer2Offline") << "L1TStage2CaloLayer2Offline::bookHistograms" << std::endl;
0146
0147
0148 bookHistos(ibooker_);
0149 }
0150
0151
0152
0153 void L1TStage2CaloLayer2Offline::analyze(edm::Event const& e, edm::EventSetup const& eSetup) {
0154 edm::LogInfo("L1TStage2CaloLayer2Offline") << "L1TStage2CaloLayer2Offline::analyze" << std::endl;
0155
0156 edm::Handle<edm::TriggerResults> triggerResultHandle;
0157 e.getByToken(triggerResultsInputTag_, triggerResultHandle);
0158 if (!triggerResultHandle.isValid()) {
0159 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid edm::TriggerResults handle" << std::endl;
0160 return;
0161 }
0162 triggerResults_ = *triggerResultHandle;
0163
0164 edm::Handle<trigger::TriggerEvent> triggerEventHandle;
0165 e.getByToken(triggerInputTag_, triggerEventHandle);
0166 if (!triggerEventHandle.isValid()) {
0167 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid trigger::TriggerEvent handle" << std::endl;
0168 return;
0169 }
0170 triggerEvent_ = *triggerEventHandle;
0171
0172 edm::Handle<reco::VertexCollection> vertexHandle;
0173 e.getByToken(thePVCollection_, vertexHandle);
0174 if (!vertexHandle.isValid()) {
0175 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: vertex " << std::endl;
0176 return;
0177 }
0178
0179 unsigned int nVertex = vertexHandle->size();
0180 dqmoffline::l1t::fillWithinLimits(h_nVertex_, nVertex);
0181
0182
0183 if (!dqmoffline::l1t::passesAnyTriggerFromList(triggerIndices_, triggerResults_)) {
0184 return;
0185 }
0186 fillEnergySums(e, nVertex);
0187 fillJets(e, nVertex);
0188 }
0189
0190 void L1TStage2CaloLayer2Offline::fillEnergySums(edm::Event const& e, const unsigned int nVertex) {
0191 edm::Handle<l1t::EtSumBxCollection> l1EtSums;
0192 e.getByToken(stage2CaloLayer2EtSumToken_, l1EtSums);
0193
0194 edm::Handle<reco::PFJetCollection> pfJets;
0195 e.getByToken(thePFJetCollection_, pfJets);
0196
0197 edm::Handle<reco::CaloMETCollection> caloMETs;
0198 e.getByToken(thecaloMETCollection_, caloMETs);
0199
0200 edm::Handle<reco::CaloMETCollection> caloETMHFs;
0201 e.getByToken(thecaloETMHFCollection_, caloETMHFs);
0202
0203 edm::Handle<reco::PFMETCollection> pfMETNoMus;
0204 e.getByToken(thePFMETNoMuCollection_, pfMETNoMus);
0205
0206 if (!pfJets.isValid()) {
0207 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: PF jets " << std::endl;
0208 return;
0209 }
0210 if (!caloMETs.isValid()) {
0211 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: Offline E_{T}^{miss} " << std::endl;
0212 return;
0213 }
0214 if (!caloETMHFs.isValid()) {
0215 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: Offline E_{T}^{miss} (HF) " << std::endl;
0216 return;
0217 }
0218 if (!pfMETNoMus.isValid()) {
0219 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: Offline PF E_{T}^{miss} No Mu" << std::endl;
0220 return;
0221 }
0222 if (!l1EtSums.isValid()) {
0223 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: L1 ET sums " << std::endl;
0224 return;
0225 }
0226
0227 int bunchCrossing = 0;
0228
0229 double l1MET(0);
0230 double l1METPhi(0);
0231 double l1ETMHF(0);
0232 double l1ETMHFPhi(0);
0233 double l1MHT(0);
0234 double l1MHTPhi(0);
0235 double l1ETT(0);
0236 double l1HTT(0);
0237
0238 for (auto etSum = l1EtSums->begin(bunchCrossing); etSum != l1EtSums->end(bunchCrossing); ++etSum) {
0239 double et = etSum->et();
0240 double phi = etSum->phi();
0241
0242 switch (etSum->getType()) {
0243 case l1t::EtSum::EtSumType::kMissingEt:
0244 l1MET = et;
0245 l1METPhi = phi;
0246 break;
0247 case l1t::EtSum::EtSumType::kMissingEtHF:
0248 l1ETMHF = et;
0249 l1ETMHFPhi = phi;
0250 break;
0251 case l1t::EtSum::EtSumType::kTotalEt:
0252 l1ETT = et;
0253 break;
0254 case l1t::EtSum::EtSumType::kMissingHt:
0255 l1MHT = et;
0256 l1MHTPhi = phi;
0257 break;
0258 case l1t::EtSum::EtSumType::kTotalHt:
0259 l1HTT = et;
0260 default:
0261 break;
0262 }
0263 }
0264
0265 double recoMET(caloMETs->front().et());
0266 double recoMETPhi(caloMETs->front().phi());
0267 double recoETMHF(caloETMHFs->front().et());
0268 double recoETMHFPhi(caloETMHFs->front().phi());
0269 double recoPFMetNoMu(pfMETNoMus->front().et());
0270 double recoPFMetNoMuPhi(pfMETNoMus->front().phi());
0271 double recoMHT(0);
0272 double recoMHTPhi(0);
0273 double recoETT(caloMETs->front().sumEt());
0274 double recoHTT(0);
0275
0276 TVector2 mht(0., 0.);
0277
0278 for (auto jet = pfJets->begin(); jet != pfJets->end(); ++jet) {
0279 double et = jet->et();
0280 if (et < 30) {
0281 continue;
0282 }
0283 TVector2 jetVec(et * cos(jet->phi()), et * sin(jet->phi()));
0284 if (std::abs(jet->eta()) < recoHTTMaxEta_) {
0285 recoHTT += et;
0286 }
0287 if (std::abs(jet->eta()) < recoMHTMaxEta_) {
0288 mht -= jetVec;
0289 }
0290 }
0291 recoMHT = mht.Mod();
0292
0293 recoMHTPhi = TVector2::Phi_mpi_pi(mht.Phi());
0294
0295
0296 double outOfBounds = 9999;
0297
0298 double resolutionMET = recoMET > 0 ? (l1MET - recoMET) / recoMET : outOfBounds;
0299 double resolutionMETPhi = reco::deltaPhi(l1METPhi, recoMETPhi);
0300
0301 double resolutionETMHF = recoETMHF > 0 ? (l1ETMHF - recoETMHF) / recoETMHF : outOfBounds;
0302 double resolutionETMHFPhi = reco::deltaPhi(l1ETMHFPhi, recoETMHFPhi);
0303
0304 double resolutionPFMetNoMu = recoETMHF > 0 ? (l1MET - recoPFMetNoMu) / recoPFMetNoMu : outOfBounds;
0305 double resolutionPFMetNoMuPhi = reco::deltaPhi(l1METPhi, recoPFMetNoMuPhi);
0306
0307 double resolutionMHT = recoMHT > 0 ? (l1MHT - recoMHT) / recoMHT : outOfBounds;
0308 double resolutionMHTPhi = reco::deltaPhi(l1MHTPhi, recoMHTPhi);
0309
0310 double resolutionETT = recoETT > 0 ? (l1ETT - recoETT) / recoETT : outOfBounds;
0311 double resolutionHTT = recoHTT > 0 ? (l1HTT - recoHTT) / recoHTT : outOfBounds;
0312
0313 using namespace dqmoffline::l1t;
0314
0315 fillWithinLimits(h_controlPlots_[ControlPlots::L1MET], l1MET);
0316 fillWithinLimits(h_controlPlots_[ControlPlots::L1ETMHF], l1ETMHF);
0317 fillWithinLimits(h_controlPlots_[ControlPlots::L1MHT], l1MHT);
0318 fillWithinLimits(h_controlPlots_[ControlPlots::L1ETT], l1ETT);
0319 fillWithinLimits(h_controlPlots_[ControlPlots::L1HTT], l1HTT);
0320 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineMET], recoMET);
0321 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineETMHF], recoETMHF);
0322 fillWithinLimits(h_controlPlots_[ControlPlots::OfflinePFMetNoMu], recoPFMetNoMu);
0323 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineMHT], recoMHT);
0324 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineETT], recoETT);
0325 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineHTT], recoHTT);
0326
0327 fill2DWithinLimits(h_L1METvsCaloMET_, recoMET, l1MET);
0328 fill2DWithinLimits(h_L1ETMHFvsCaloETMHF_, recoETMHF, l1ETMHF);
0329 fill2DWithinLimits(h_L1METvsPFMetNoMu_, recoPFMetNoMu, l1MET);
0330 fill2DWithinLimits(h_L1MHTvsRecoMHT_, recoMHT, l1MHT);
0331 fill2DWithinLimits(h_L1METTvsCaloETT_, recoETT, l1ETT);
0332 fill2DWithinLimits(h_L1HTTvsRecoHTT_, recoHTT, l1HTT);
0333
0334 fill2DWithinLimits(h_L1METPhivsCaloMETPhi_, recoMETPhi, l1METPhi);
0335 fill2DWithinLimits(h_L1ETMHFPhivsCaloETMHFPhi_, recoETMHFPhi, l1ETMHFPhi);
0336 fill2DWithinLimits(h_L1METPhivsPFMetNoMuPhi_, recoPFMetNoMuPhi, l1METPhi);
0337 fill2DWithinLimits(h_L1MHTPhivsRecoMHTPhi_, recoMHTPhi, l1MHTPhi);
0338
0339 fillWithinLimits(h_resolutionMET_, resolutionMET);
0340 fillWithinLimits(h_resolutionETMHF_, resolutionETMHF);
0341 fillWithinLimits(h_resolutionPFMetNoMu_, resolutionPFMetNoMu);
0342 fillWithinLimits(h_resolutionMHT_, resolutionMHT);
0343 fillWithinLimits(h_resolutionETT_, resolutionETT);
0344 if (resolutionMHT < outOfBounds) {
0345 fillWithinLimits(h_resolutionMHT_, resolutionMHT);
0346 }
0347 if (resolutionHTT < outOfBounds) {
0348 fillWithinLimits(h_resolutionHTT_, resolutionHTT);
0349 }
0350
0351 fillWithinLimits(h_resolutionMETPhi_, resolutionMETPhi);
0352 fillWithinLimits(h_resolutionETMHFPhi_, resolutionETMHFPhi);
0353 fillWithinLimits(h_resolutionPFMetNoMuPhi_, resolutionPFMetNoMuPhi);
0354 fillWithinLimits(h_resolutionMHTPhi_, resolutionMHTPhi);
0355
0356
0357 for (auto threshold : metEfficiencyThresholds_) {
0358 fillWithinLimits(h_efficiencyMET_total_[threshold], recoMET);
0359 fillWithinLimits(h_efficiencyETMHF_total_[threshold], recoETMHF);
0360 fillWithinLimits(h_efficiencyPFMetNoMu_total_[threshold], recoPFMetNoMu);
0361 if (l1MET > threshold) {
0362 fillWithinLimits(h_efficiencyMET_pass_[threshold], recoMET);
0363 fillWithinLimits(h_efficiencyETMHF_pass_[threshold], recoETMHF);
0364 fillWithinLimits(h_efficiencyPFMetNoMu_pass_[threshold], recoPFMetNoMu);
0365 }
0366 }
0367
0368 for (auto threshold : mhtEfficiencyThresholds_) {
0369 fillWithinLimits(h_efficiencyMHT_total_[threshold], recoMHT);
0370 if (l1MHT > threshold)
0371 fillWithinLimits(h_efficiencyMHT_pass_[threshold], recoMHT);
0372 }
0373
0374 for (auto threshold : ettEfficiencyThresholds_) {
0375 fillWithinLimits(h_efficiencyETT_total_[threshold], recoETT);
0376 if (l1ETT > threshold)
0377 fillWithinLimits(h_efficiencyETT_pass_[threshold], recoETT);
0378 }
0379
0380 for (auto threshold : httEfficiencyThresholds_) {
0381 fillWithinLimits(h_efficiencyHTT_total_[threshold], recoHTT);
0382 if (l1HTT > threshold)
0383 fillWithinLimits(h_efficiencyHTT_pass_[threshold], recoHTT);
0384 }
0385 }
0386
0387 void L1TStage2CaloLayer2Offline::fillJets(edm::Event const& e, const unsigned int nVertex) {
0388 edm::Handle<l1t::JetBxCollection> l1Jets;
0389 e.getByToken(stage2CaloLayer2JetToken_, l1Jets);
0390
0391 edm::Handle<reco::PFJetCollection> pfJets;
0392 e.getByToken(thePFJetCollection_, pfJets);
0393
0394 if (!pfJets.isValid()) {
0395 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: PF jets " << std::endl;
0396 return;
0397 }
0398 if (!l1Jets.isValid()) {
0399 edm::LogWarning("L1TStage2CaloLayer2Offline") << "invalid collection: L1 jets " << std::endl;
0400 return;
0401 }
0402
0403 if (pfJets->empty()) {
0404 LogDebug("L1TStage2CaloLayer2Offline") << "no PF jets found" << std::endl;
0405 return;
0406 }
0407
0408 auto leadingRecoJet = pfJets->front();
0409
0410
0411 double minDeltaR = 0.3;
0412 l1t::Jet closestL1Jet;
0413 bool foundMatch = false;
0414
0415
0416 int bunchCrossing = 0;
0417 for (auto jet = l1Jets->begin(bunchCrossing); jet != l1Jets->end(bunchCrossing); ++jet) {
0418 double currentDeltaR = deltaR(jet->eta(), jet->phi(), leadingRecoJet.eta(), leadingRecoJet.phi());
0419 if (currentDeltaR >= minDeltaR) {
0420 continue;
0421 } else {
0422 minDeltaR = currentDeltaR;
0423 closestL1Jet = *jet;
0424 foundMatch = true;
0425 }
0426 }
0427
0428
0429 if (!foundMatch) {
0430 LogDebug("L1TStage2CaloLayer2Offline") << "Could not find a matching L1 Jet " << std::endl;
0431 }
0432
0433 if (!doesNotOverlapWithHLTObjects(closestL1Jet)) {
0434 return;
0435 }
0436
0437 double recoEt = leadingRecoJet.et();
0438 double recoEta = leadingRecoJet.eta();
0439 double recoPhi = leadingRecoJet.phi();
0440
0441 double outOfBounds = 9999;
0442 double l1Et = foundMatch ? closestL1Jet.et() : 0;
0443 double l1Eta = foundMatch ? closestL1Jet.eta() : outOfBounds;
0444 double l1Phi = foundMatch ? closestL1Jet.phi() : outOfBounds;
0445
0446 double resolutionEt = recoEt > 0 ? (l1Et - recoEt) / recoEt : outOfBounds;
0447 double resolutionEta = l1Eta - recoEta;
0448 double resolutionPhi = l1Phi < outOfBounds ? reco::deltaPhi(l1Phi, recoPhi) : outOfBounds;
0449
0450 using namespace dqmoffline::l1t;
0451
0452 fillJetEfficiencies(recoEt, l1Et, recoEta);
0453
0454 fillWithinLimits(h_controlPlots_[ControlPlots::L1JetET], l1Et);
0455 fillWithinLimits(h_controlPlots_[ControlPlots::OfflineJetET], recoEt);
0456
0457 if (!foundMatch) {
0458 return;
0459 }
0460
0461
0462 fill2DWithinLimits(h_L1JetEtavsPFJetEta_, recoEta, l1Eta);
0463 fillWithinLimits(h_resolutionJetEta_, resolutionEta);
0464
0465 if (std::abs(recoEta) <= 1.479) {
0466
0467 fill2DWithinLimits(h_L1JetETvsPFJetET_HB_, recoEt, l1Et);
0468 fill2DWithinLimits(h_L1JetETvsPFJetET_HB_HE_, recoEt, l1Et);
0469
0470 fillWithinLimits(h_resolutionJetET_HB_, resolutionEt);
0471 fillWithinLimits(h_resolutionJetET_HB_HE_, resolutionEt);
0472
0473 fill2DWithinLimits(h_L1JetPhivsPFJetPhi_HB_, recoPhi, l1Phi);
0474 fill2DWithinLimits(h_L1JetPhivsPFJetPhi_HB_HE_, recoPhi, l1Phi);
0475
0476 fillWithinLimits(h_resolutionJetPhi_HB_, resolutionPhi);
0477 fillWithinLimits(h_resolutionJetPhi_HB_HE_, resolutionPhi);
0478 } else if (std::abs(recoEta) <= 3.0) {
0479
0480 fill2DWithinLimits(h_L1JetETvsPFJetET_HE_, recoEt, l1Et);
0481 fill2DWithinLimits(h_L1JetETvsPFJetET_HB_HE_, recoEt, l1Et);
0482
0483 fillWithinLimits(h_resolutionJetET_HE_, resolutionEt);
0484 fillWithinLimits(h_resolutionJetET_HB_HE_, resolutionEt);
0485
0486 fill2DWithinLimits(h_L1JetPhivsPFJetPhi_HE_, recoPhi, l1Phi);
0487 fill2DWithinLimits(h_L1JetPhivsPFJetPhi_HB_HE_, recoPhi, l1Phi);
0488
0489 fillWithinLimits(h_resolutionJetPhi_HE_, resolutionPhi);
0490 fillWithinLimits(h_resolutionJetPhi_HB_HE_, resolutionPhi);
0491 } else {
0492
0493 fill2DWithinLimits(h_L1JetETvsPFJetET_HF_, recoEt, l1Et);
0494
0495 fillWithinLimits(h_resolutionJetET_HF_, resolutionEt);
0496
0497 fill2DWithinLimits(h_L1JetPhivsPFJetPhi_HF_, recoPhi, l1Phi);
0498
0499 fillWithinLimits(h_resolutionJetPhi_HF_, resolutionPhi);
0500 }
0501 }
0502
0503 void L1TStage2CaloLayer2Offline::fillJetEfficiencies(const double& recoEt, const double& l1Et, const double& recoEta) {
0504 using namespace dqmoffline::l1t;
0505 if (std::abs(recoEta) <= 1.479) {
0506 for (auto threshold : jetEfficiencyThresholds_) {
0507 fillWithinLimits(h_efficiencyJetEt_HB_total_[threshold], recoEt);
0508 fillWithinLimits(h_efficiencyJetEt_HB_HE_total_[threshold], recoEt);
0509 if (l1Et > threshold) {
0510 fillWithinLimits(h_efficiencyJetEt_HB_pass_[threshold], recoEt);
0511 fillWithinLimits(h_efficiencyJetEt_HB_HE_pass_[threshold], recoEt);
0512 }
0513 }
0514 } else if (std::abs(recoEta) <= 3.0) {
0515 for (auto threshold : jetEfficiencyThresholds_) {
0516 fillWithinLimits(h_efficiencyJetEt_HE_total_[threshold], recoEt);
0517 fillWithinLimits(h_efficiencyJetEt_HB_HE_total_[threshold], recoEt);
0518 if (l1Et > threshold) {
0519 fillWithinLimits(h_efficiencyJetEt_HE_pass_[threshold], recoEt);
0520 fillWithinLimits(h_efficiencyJetEt_HB_HE_pass_[threshold], recoEt);
0521 }
0522 }
0523 } else {
0524 for (auto threshold : jetEfficiencyThresholds_) {
0525 fillWithinLimits(h_efficiencyJetEt_HF_total_[threshold], recoEt);
0526 if (l1Et > threshold) {
0527 fillWithinLimits(h_efficiencyJetEt_HF_pass_[threshold], recoEt);
0528 }
0529 }
0530 }
0531 }
0532
0533
0534
0535
0536
0537
0538
0539 void L1TStage2CaloLayer2Offline::bookHistos(DQMStore::IBooker& ibooker) {
0540 bookEnergySumHistos(ibooker);
0541 bookJetHistos(ibooker);
0542 }
0543
0544 void L1TStage2CaloLayer2Offline::bookEnergySumHistos(DQMStore::IBooker& ibooker) {
0545 ibooker.cd();
0546 ibooker.setCurrentFolder(histFolderEtSum_);
0547
0548 dqmoffline::l1t::HistDefinition nVertexDef = histDefinitions_[PlotConfig::nVertex];
0549 h_nVertex_ = ibooker.book1D(nVertexDef.name, nVertexDef.title, nVertexDef.nbinsX, nVertexDef.xmin, nVertexDef.xmax);
0550
0551
0552 h_controlPlots_[ControlPlots::L1MET] =
0553 ibooker.book1D("L1MET", "L1 E_{T}^{miss}; L1 E_{T}^{miss} (GeV); events", 500, -0.5, 4999.5);
0554 h_controlPlots_[ControlPlots::L1ETMHF] =
0555 ibooker.book1D("L1ETMHF", "L1 E_{T}^{miss} (HF); L1 E_{T}^{miss} (HF) (GeV); events", 500, -0.5, 4999.5);
0556 h_controlPlots_[ControlPlots::L1MHT] = ibooker.book1D("L1MHT", "L1 MHT; L1 MHT (GeV); events", 500, -0.5, 4999.5);
0557 h_controlPlots_[ControlPlots::L1ETT] = ibooker.book1D("L1ETT", "L1 ETT; L1 ETT (GeV); events", 500, -0.5, 4999.5);
0558 h_controlPlots_[ControlPlots::L1HTT] = ibooker.book1D("L1HTT", "L1 HTT; L1 HTT (GeV); events", 500, -0.5, 4999.5);
0559
0560 h_controlPlots_[ControlPlots::OfflineMET] =
0561 ibooker.book1D("OfflineMET", "Offline E_{T}^{miss}; Offline E_{T}^{miss} (GeV); events", 500, -0.5, 4999.5);
0562 h_controlPlots_[ControlPlots::OfflineETMHF] = ibooker.book1D(
0563 "OfflineETMHF", "Offline E_{T}^{miss} (HF); Offline E_{T}^{miss} (HF) (GeV); events", 500, -0.5, 4999.5);
0564 h_controlPlots_[ControlPlots::OfflinePFMetNoMu] =
0565 ibooker.book1D("OfflinePFMetNoMu",
0566 "Offline E_{T}^{miss} (PFMetNoMu); Offline E_{T}^{miss} (PFMetNoMu) (GeV); events",
0567 500,
0568 -0.5,
0569 4999.5);
0570 h_controlPlots_[ControlPlots::OfflineMHT] =
0571 ibooker.book1D("OfflineMHT", "Offline MHT; Offline MHT (GeV); events", 500, -0.5, 4999.5);
0572 h_controlPlots_[ControlPlots::OfflineETT] =
0573 ibooker.book1D("OfflineETT", "Offline ETT; Offline ETT (GeV); events", 500, -0.5, 4999.5);
0574 h_controlPlots_[ControlPlots::OfflineHTT] =
0575 ibooker.book1D("OfflineHTT", "Offline HTT; Offline HTT (GeV); events", 500, -0.5, 4999.5);
0576
0577
0578 dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
0579 h_L1METvsCaloMET_ =
0580 ibooker.book2D("L1METvsCaloMET",
0581 "L1 E_{T}^{miss} vs Offline E_{T}^{miss};Offline E_{T}^{miss} (GeV);L1 E_{T}^{miss} (GeV)",
0582 templateETvsET.nbinsX,
0583 &templateETvsET.binsX[0],
0584 templateETvsET.nbinsY,
0585 &templateETvsET.binsY[0]);
0586 h_L1ETMHFvsCaloETMHF_ = ibooker.book2D(
0587 "L1ETMHFvsCaloETMHF",
0588 "L1 E_{T}^{miss} vs Offline E_{T}^{miss} (HF);Offline E_{T}^{miss} (HF) (GeV);L1 E_{T}^{miss} (HF) (GeV)",
0589 templateETvsET.nbinsX,
0590 &templateETvsET.binsX[0],
0591 templateETvsET.nbinsY,
0592 &templateETvsET.binsY[0]);
0593 h_L1METvsPFMetNoMu_ = ibooker.book2D("L1METvsPFMetNoMu",
0594 "L1 E_{T}^{miss} vs Offline E_{T}^{miss} (PFMetNoMu);Offline E_{T}^{miss} "
0595 "(PFMetNoMu) (GeV);L1 E_{T}^{miss} (GeV)",
0596 templateETvsET.nbinsX,
0597 &templateETvsET.binsX[0],
0598 templateETvsET.nbinsY,
0599 &templateETvsET.binsY[0]);
0600 h_L1MHTvsRecoMHT_ = ibooker.book2D("L1MHTvsRecoMHT",
0601 "L1 MHT vs reco MHT;reco MHT (GeV);L1 MHT (GeV)",
0602 templateETvsET.nbinsX,
0603 &templateETvsET.binsX[0],
0604 templateETvsET.nbinsY,
0605 &templateETvsET.binsY[0]);
0606 h_L1METTvsCaloETT_ = ibooker.book2D("L1ETTvsCaloETT",
0607 "L1 ETT vs calo ETT;calo ETT (GeV);L1 ETT (GeV)",
0608 templateETvsET.nbinsX,
0609 &templateETvsET.binsX[0],
0610 templateETvsET.nbinsY,
0611 &templateETvsET.binsY[0]);
0612 h_L1HTTvsRecoHTT_ =
0613 ibooker.book2D("L1HTTvsRecoHTT",
0614 "L1 Total H_{T} vs Offline Total H_{T};Offline Total H_{T} (GeV);L1 Total H_{T} (GeV)",
0615 templateETvsET.nbinsX,
0616 &templateETvsET.binsX[0],
0617 templateETvsET.nbinsY,
0618 &templateETvsET.binsY[0]);
0619
0620 dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
0621 h_L1METPhivsCaloMETPhi_ =
0622 ibooker.book2D("L1METPhivsCaloMETPhi",
0623 "L1 E_{T}^{miss} #phi vs Offline E_{T}^{miss} #phi;Offline E_{T}^{miss} #phi;L1 E_{T}^{miss} #phi",
0624 templatePHIvsPHI.nbinsX,
0625 templatePHIvsPHI.xmin,
0626 templatePHIvsPHI.xmax,
0627 templatePHIvsPHI.nbinsY,
0628 templatePHIvsPHI.ymin,
0629 templatePHIvsPHI.ymax);
0630 h_L1ETMHFPhivsCaloETMHFPhi_ = ibooker.book2D(
0631 "L1ETMHFPhivsCaloETMHFPhi",
0632 "L1 E_{T}^{miss} #phi vs Offline E_{T}^{miss} (HF) #phi;Offline E_{T}^{miss} (HF) #phi;L1 E_{T}^{miss} #phi",
0633 templatePHIvsPHI.nbinsX,
0634 templatePHIvsPHI.xmin,
0635 templatePHIvsPHI.xmax,
0636 templatePHIvsPHI.nbinsY,
0637 templatePHIvsPHI.ymin,
0638 templatePHIvsPHI.ymax);
0639 h_L1METPhivsPFMetNoMuPhi_ = ibooker.book2D("L1METPhivsPFMetNoMuPhi",
0640 "L1 E_{T}^{miss} #phi vs Offline E_{T}^{miss} (PFMetNoMu) #phi;Offline "
0641 "E_{T}^{miss} (PFMetNoMu) #phi;L1 E_{T}^{miss} #phi",
0642 templatePHIvsPHI.nbinsX,
0643 templatePHIvsPHI.xmin,
0644 templatePHIvsPHI.xmax,
0645 templatePHIvsPHI.nbinsY,
0646 templatePHIvsPHI.ymin,
0647 templatePHIvsPHI.ymax);
0648 h_L1MHTPhivsRecoMHTPhi_ = ibooker.book2D("L1MHTPhivsRecoMHTPhi",
0649 "L1 MHT #phi vs reco MHT #phi;reco MHT #phi;L1 MHT #phi",
0650 templatePHIvsPHI.nbinsX,
0651 templatePHIvsPHI.xmin,
0652 templatePHIvsPHI.xmax,
0653 templatePHIvsPHI.nbinsY,
0654 templatePHIvsPHI.ymin,
0655 templatePHIvsPHI.ymax);
0656
0657
0658 h_resolutionMET_ =
0659 ibooker.book1D("resolutionMET",
0660 "MET resolution; (L1 E_{T}^{miss} - Offline E_{T}^{miss})/Offline E_{T}^{miss}; events",
0661 70,
0662 -1.0,
0663 2.5);
0664 h_resolutionETMHF_ =
0665 ibooker.book1D("resolutionETMHF",
0666 "MET resolution (HF); (L1 E_{T}^{miss} - Offline E_{T}^{miss})/Offline E_{T}^{miss} (HF); events",
0667 70,
0668 -1.0,
0669 2.5);
0670 h_resolutionPFMetNoMu_ = ibooker.book1D(
0671 "resolutionPFMetNoMu",
0672 "PFMetNoMu resolution; (L1 E_{T}^{miss} - Offline E_{T}^{miss})/Offline E_{T}^{miss} (PFMetNoMu); events",
0673 70,
0674 -1.0,
0675 2.5);
0676 h_resolutionMHT_ =
0677 ibooker.book1D("resolutionMHT", "MHT resolution; (L1 MHT - reco MHT)/reco MHT; events", 70, -1.0, 2.5);
0678 h_resolutionETT_ =
0679 ibooker.book1D("resolutionETT", "ETT resolution; (L1 ETT - calo ETT)/calo ETT; events", 70, -1.0, 2.5);
0680 h_resolutionHTT_ =
0681 ibooker.book1D("resolutionHTT",
0682 "HTT resolution; (L1 Total H_{T} - Offline Total H_{T})/Offline Total H_{T}; events",
0683 70,
0684 -1.0,
0685 2.5);
0686
0687 h_resolutionMETPhi_ = ibooker.book1D(
0688 "resolutionMETPhi", "MET #phi resolution; (L1 E_{T}^{miss} #phi - reco MET #phi); events", 200, -1, 1);
0689 h_resolutionETMHFPhi_ = ibooker.book1D(
0690 "resolutionETMHFPhi", "MET #phi resolution (HF); (L1 E_{T}^{miss} #phi - reco MET #phi) (HF); events", 200, -1, 1);
0691 h_resolutionPFMetNoMuPhi_ =
0692 ibooker.book1D("resolutionPFMetNoMuPhi",
0693 "MET #phi resolution (PFMetNoMu); (L1 E_{T}^{miss} #phi - reco MET #phi) (PFMetNoMu); events",
0694 200,
0695 -1,
0696 1);
0697 h_resolutionMHTPhi_ =
0698 ibooker.book1D("resolutionMHTPhi", "MET #phi resolution; (L1 MHT #phi - reco MHT #phi); events", 200, -1, 1);
0699
0700
0701 ibooker.setCurrentFolder(efficiencyFolderEtSum_);
0702
0703 std::vector<float> metBins(metEfficiencyBins_.begin(), metEfficiencyBins_.end());
0704 std::vector<float> mhtBins(mhtEfficiencyBins_.begin(), mhtEfficiencyBins_.end());
0705 std::vector<float> ettBins(ettEfficiencyBins_.begin(), ettEfficiencyBins_.end());
0706 std::vector<float> httBins(httEfficiencyBins_.begin(), httEfficiencyBins_.end());
0707
0708 for (auto threshold : metEfficiencyThresholds_) {
0709 std::string str_threshold = std::to_string(int(threshold));
0710 h_efficiencyMET_pass_[threshold] = ibooker.book1D("efficiencyMET_threshold_" + str_threshold + "_Num",
0711 "MET efficiency (numerator); Offline E_{T}^{miss} (GeV);",
0712 metBins.size() - 1,
0713 &(metBins[0]));
0714 h_efficiencyMET_total_[threshold] = ibooker.book1D("efficiencyMET_threshold_" + str_threshold + "_Den",
0715 "MET efficiency (denominator); Offline E_{T}^{miss} (GeV);",
0716 metBins.size() - 1,
0717 &(metBins[0]));
0718
0719 h_efficiencyETMHF_pass_[threshold] = ibooker.book1D("efficiencyETMHF_threshold_" + str_threshold + "_Num",
0720 "MET efficiency (numerator); Offline E_{T}^{miss} (GeV) (HF);",
0721 metBins.size() - 1,
0722 &(metBins[0]));
0723 h_efficiencyETMHF_total_[threshold] =
0724 ibooker.book1D("efficiencyETMHF_threshold_" + str_threshold + "_Den",
0725 "MET efficiency (denominator); Offline E_{T}^{miss} (GeV) (HF);",
0726 metBins.size() - 1,
0727 &(metBins[0]));
0728
0729 h_efficiencyPFMetNoMu_pass_[threshold] =
0730 ibooker.book1D("efficiencyPFMetNoMu_threshold_" + str_threshold + "_Num",
0731 "MET efficiency (numerator); Offline E_{T}^{miss} (GeV) (PFMetNoMu);",
0732 metBins.size() - 1,
0733 &(metBins[0]));
0734 h_efficiencyPFMetNoMu_total_[threshold] =
0735 ibooker.book1D("efficiencyPFMetNoMu_threshold_" + str_threshold + "_Den",
0736 "MET efficiency (denominator); Offline E_{T}^{miss} (GeV) (PFMetNoMu);",
0737 metBins.size() - 1,
0738 &(metBins[0]));
0739 }
0740
0741 for (auto threshold : mhtEfficiencyThresholds_) {
0742 std::string str_threshold = std::to_string(int(threshold));
0743 h_efficiencyMHT_pass_[threshold] = ibooker.book1D("efficiencyMHT_threshold_" + str_threshold + "_Num",
0744 "MHT efficiency (numerator); Offline MHT (GeV);",
0745 mhtBins.size() - 1,
0746 &(mhtBins[0]));
0747 h_efficiencyMHT_total_[threshold] = ibooker.book1D("efficiencyMHT_threshold_" + str_threshold + "_Den",
0748 "MHT efficiency (denominator); Offline MHT (GeV);",
0749 mhtBins.size() - 1,
0750 &(mhtBins[0]));
0751 }
0752
0753 for (auto threshold : ettEfficiencyThresholds_) {
0754 std::string str_threshold = std::to_string(int(threshold));
0755 h_efficiencyETT_pass_[threshold] = ibooker.book1D("efficiencyETT_threshold_" + str_threshold + "_Num",
0756 "ETT efficiency (numerator); Offline ETT (GeV);",
0757 ettBins.size() - 1,
0758 &(ettBins[0]));
0759 h_efficiencyETT_total_[threshold] = ibooker.book1D("efficiencyETT_threshold_" + str_threshold + "_Den",
0760 "ETT efficiency (denominator); Offline ETT (GeV);",
0761 ettBins.size() - 1,
0762 &(ettBins[0]));
0763 }
0764 for (auto threshold : httEfficiencyThresholds_) {
0765 std::string str_threshold = std::to_string(int(threshold));
0766 h_efficiencyHTT_pass_[threshold] = ibooker.book1D("efficiencyHTT_threshold_" + str_threshold + "_Num",
0767 "HTT efficiency (numerator); Offline Total H_{T} (GeV);",
0768 httBins.size() - 1,
0769 &(httBins[0]));
0770 h_efficiencyHTT_total_[threshold] = ibooker.book1D("efficiencyHTT_threshold_" + str_threshold + "_Den",
0771 "HTT efficiency (denominator); Offline Total H_{T} (GeV);",
0772 httBins.size() - 1,
0773 &(httBins[0]));
0774 }
0775
0776 ibooker.cd();
0777 }
0778
0779 void L1TStage2CaloLayer2Offline::bookJetHistos(DQMStore::IBooker& ibooker) {
0780 ibooker.cd();
0781 ibooker.setCurrentFolder(histFolderJet_);
0782
0783 h_controlPlots_[ControlPlots::L1JetET] =
0784 ibooker.book1D("L1JetET", "L1 Jet E_{T}; L1 Jet E_{T} (GeV); events", 500, 0, 5e3);
0785 h_controlPlots_[ControlPlots::OfflineJetET] =
0786 ibooker.book1D("OfflineJetET", "Offline Jet E_{T}; Offline Jet E_{T} (GeV); events", 500, 0, 5e3);
0787
0788 dqmoffline::l1t::HistDefinition templateETvsET = histDefinitions_[PlotConfig::ETvsET];
0789 h_L1JetETvsPFJetET_HB_ =
0790 ibooker.book2D("L1JetETvsPFJetET_HB",
0791 "L1 Jet E_{T} vs Offline Jet E_{T} (HB); Offline Jet E_{T} (GeV); L1 Jet E_{T} (GeV)",
0792 templateETvsET.nbinsX,
0793 &templateETvsET.binsX[0],
0794 templateETvsET.nbinsY,
0795 &templateETvsET.binsY[0]);
0796 h_L1JetETvsPFJetET_HE_ =
0797 ibooker.book2D("L1JetETvsPFJetET_HE",
0798 "L1 Jet E_{T} vs Offline Jet E_{T} (HE); Offline Jet E_{T} (GeV); L1 Jet E_{T} (GeV)",
0799 templateETvsET.nbinsX,
0800 &templateETvsET.binsX[0],
0801 templateETvsET.nbinsY,
0802 &templateETvsET.binsY[0]);
0803 h_L1JetETvsPFJetET_HF_ =
0804 ibooker.book2D("L1JetETvsPFJetET_HF",
0805 "L1 Jet E_{T} vs Offline Jet E_{T} (HF); Offline Jet E_{T} (GeV); L1 Jet E_{T} (GeV)",
0806 templateETvsET.nbinsX,
0807 &templateETvsET.binsX[0],
0808 templateETvsET.nbinsY,
0809 &templateETvsET.binsY[0]);
0810 h_L1JetETvsPFJetET_HB_HE_ =
0811 ibooker.book2D("L1JetETvsPFJetET_HB_HE",
0812 "L1 Jet E_{T} vs Offline Jet E_{T} (HB+HE); Offline Jet E_{T} (GeV); L1 Jet E_{T} (GeV)",
0813 templateETvsET.nbinsX,
0814 &templateETvsET.binsX[0],
0815 templateETvsET.nbinsY,
0816 &templateETvsET.binsY[0]);
0817
0818 dqmoffline::l1t::HistDefinition templatePHIvsPHI = histDefinitions_[PlotConfig::PHIvsPHI];
0819 h_L1JetPhivsPFJetPhi_HB_ =
0820 ibooker.book2D("L1JetPhivsPFJetPhi_HB",
0821 "#phi_{jet}^{L1} vs #phi_{jet}^{offline} (HB); #phi_{jet}^{offline}; #phi_{jet}^{L1}",
0822 templatePHIvsPHI.nbinsX,
0823 templatePHIvsPHI.xmin,
0824 templatePHIvsPHI.xmax,
0825 templatePHIvsPHI.nbinsY,
0826 templatePHIvsPHI.ymin,
0827 templatePHIvsPHI.ymax);
0828 h_L1JetPhivsPFJetPhi_HE_ =
0829 ibooker.book2D("L1JetPhivsPFJetPhi_HE",
0830 "#phi_{jet}^{L1} vs #phi_{jet}^{offline} (HE); #phi_{jet}^{offline}; #phi_{jet}^{L1}",
0831 templatePHIvsPHI.nbinsX,
0832 templatePHIvsPHI.xmin,
0833 templatePHIvsPHI.xmax,
0834 templatePHIvsPHI.nbinsY,
0835 templatePHIvsPHI.ymin,
0836 templatePHIvsPHI.ymax);
0837 h_L1JetPhivsPFJetPhi_HF_ =
0838 ibooker.book2D("L1JetPhivsPFJetPhi_HF",
0839 "#phi_{jet}^{L1} vs #phi_{jet}^{offline} (HF); #phi_{jet}^{offline}; #phi_{jet}^{L1}",
0840 templatePHIvsPHI.nbinsX,
0841 templatePHIvsPHI.xmin,
0842 templatePHIvsPHI.xmax,
0843 templatePHIvsPHI.nbinsY,
0844 templatePHIvsPHI.ymin,
0845 templatePHIvsPHI.ymax);
0846 h_L1JetPhivsPFJetPhi_HB_HE_ =
0847 ibooker.book2D("L1JetPhivsPFJetPhi_HB_HE",
0848 "#phi_{jet}^{L1} vs #phi_{jet}^{offline} (HB+HE); #phi_{jet}^{offline}; #phi_{jet}^{L1}",
0849 templatePHIvsPHI.nbinsX,
0850 templatePHIvsPHI.xmin,
0851 templatePHIvsPHI.xmax,
0852 templatePHIvsPHI.nbinsY,
0853 templatePHIvsPHI.ymin,
0854 templatePHIvsPHI.ymax);
0855
0856 h_L1JetEtavsPFJetEta_ = ibooker.book2D("L1JetEtavsPFJetEta_HB",
0857 "L1 Jet #eta vs Offline Jet #eta; Offline Jet #eta; L1 Jet #eta",
0858 100,
0859 -10,
0860 10,
0861 100,
0862 -10,
0863 10);
0864
0865
0866 h_resolutionJetET_HB_ =
0867 ibooker.book1D("resolutionJetET_HB",
0868 "jet ET resolution (HB); (L1 Jet E_{T} - Offline Jet E_{T})/Offline Jet E_{T}; events",
0869 50,
0870 -1,
0871 1.5);
0872 h_resolutionJetET_HE_ =
0873 ibooker.book1D("resolutionJetET_HE",
0874 "jet ET resolution (HE); (L1 Jet E_{T} - Offline Jet E_{T})/Offline Jet E_{T}; events",
0875 50,
0876 -1,
0877 1.5);
0878 h_resolutionJetET_HF_ =
0879 ibooker.book1D("resolutionJetET_HF",
0880 "jet ET resolution (HF); (L1 Jet E_{T} - Offline Jet E_{T})/Offline Jet E_{T}; events",
0881 50,
0882 -1,
0883 1.5);
0884 h_resolutionJetET_HB_HE_ =
0885 ibooker.book1D("resolutionJetET_HB_HE",
0886 "jet ET resolution (HB+HE); (L1 Jet E_{T} - Offline Jet E_{T})/Offline Jet E_{T}; events",
0887 50,
0888 -1,
0889 1.5);
0890
0891 h_resolutionJetPhi_HB_ =
0892 ibooker.book1D("resolutionJetPhi_HB",
0893 "#phi_{jet} resolution (HB); (#phi_{jet}^{L1} - #phi_{jet}^{offline}); events",
0894 120,
0895 -0.3,
0896 0.3);
0897 h_resolutionJetPhi_HE_ = ibooker.book1D("resolutionJetPhi_HE",
0898 "jet #phi resolution (HE); (#phi_{jet}^{L1} - #phi_{jet}^{offline}); events",
0899 120,
0900 -0.3,
0901 0.3);
0902 h_resolutionJetPhi_HF_ = ibooker.book1D("resolutionJetPhi_HF",
0903 "jet #phi resolution (HF); (#phi_{jet}^{L1} - #phi_{jet}^{offline}); events",
0904 120,
0905 -0.3,
0906 0.3);
0907 h_resolutionJetPhi_HB_HE_ =
0908 ibooker.book1D("resolutionJetPhi_HB_HE",
0909 "jet #phi resolution (HB+HE); (#phi_{jet}^{L1} - #phi_{jet}^{offline}); events",
0910 120,
0911 -0.3,
0912 0.3);
0913
0914 h_resolutionJetEta_ = ibooker.book1D(
0915 "resolutionJetEta", "jet #eta resolution (HB); (L1 Jet #eta - Offline Jet #eta); events", 120, -0.3, 0.3);
0916
0917
0918 ibooker.setCurrentFolder(efficiencyFolderJet_);
0919 std::vector<float> jetBins(jetEfficiencyBins_.begin(), jetEfficiencyBins_.end());
0920 int nBins = jetBins.size() - 1;
0921 float* jetBinArray = &(jetBins[0]);
0922
0923 for (auto threshold : jetEfficiencyThresholds_) {
0924 std::string str_threshold = std::to_string(int(threshold));
0925 h_efficiencyJetEt_HB_pass_[threshold] =
0926 ibooker.book1D("efficiencyJetEt_HB_threshold_" + str_threshold + "_Num",
0927 "jet efficiency (HB) (numerator); Offline Jet E_{T} (GeV); events",
0928 nBins,
0929 jetBinArray);
0930 h_efficiencyJetEt_HE_pass_[threshold] =
0931 ibooker.book1D("efficiencyJetEt_HE_threshold_" + str_threshold + "_Num",
0932 "jet efficiency (HE) (numerator); Offline Jet E_{T} (GeV); events",
0933 nBins,
0934 jetBinArray);
0935 h_efficiencyJetEt_HF_pass_[threshold] =
0936 ibooker.book1D("efficiencyJetEt_HF_threshold_" + str_threshold + "_Num",
0937 "jet efficiency (HF) (numerator); Offline Jet E_{T} (GeV); events",
0938 nBins,
0939 jetBinArray);
0940 h_efficiencyJetEt_HB_HE_pass_[threshold] =
0941 ibooker.book1D("efficiencyJetEt_HB_HE_threshold_" + str_threshold + "_Num",
0942 "jet efficiency (HB+HE) (numerator); Offline Jet E_{T} (GeV); events",
0943 nBins,
0944 jetBinArray);
0945
0946 h_efficiencyJetEt_HB_total_[threshold] =
0947 ibooker.book1D("efficiencyJetEt_HB_threshold_" + str_threshold + "_Den",
0948 "jet efficiency (HB) (denominator); Offline Jet E_{T} (GeV); events",
0949 nBins,
0950 jetBinArray);
0951 h_efficiencyJetEt_HE_total_[threshold] =
0952 ibooker.book1D("efficiencyJetEt_HE_threshold_" + str_threshold + "_Den",
0953 "jet efficiency (HE) (denominator); Offline Jet E_{T} (GeV); events",
0954 nBins,
0955 jetBinArray);
0956 h_efficiencyJetEt_HF_total_[threshold] =
0957 ibooker.book1D("efficiencyJetEt_HF_threshold_" + str_threshold + "_Den",
0958 "jet efficiency (HF) (denominator); Offline Jet E_{T} (GeV); events",
0959 nBins,
0960 jetBinArray);
0961 h_efficiencyJetEt_HB_HE_total_[threshold] =
0962 ibooker.book1D("efficiencyJetEt_HB_HE_threshold_" + str_threshold + "_Den",
0963 "jet efficiency (HB+HE) (denominator); Offline Jet E_{T} (GeV); events",
0964 nBins,
0965 jetBinArray);
0966 }
0967
0968 ibooker.cd();
0969 }
0970
0971 bool L1TStage2CaloLayer2Offline::doesNotOverlapWithHLTObjects(const l1t::Jet& jet) const {
0972
0973 using namespace dqmoffline::l1t;
0974 std::vector<bool> results = getTriggerResults(triggerIndices_, triggerResults_);
0975 std::vector<unsigned int> firedTriggers = getFiredTriggerIndices(triggerIndices_, results);
0976 std::vector<edm::InputTag> hltFilters = getHLTFilters(firedTriggers, hltConfig_, triggerProcess_);
0977 const trigger::TriggerObjectCollection hltObjects = getTriggerObjects(hltFilters, triggerEvent_);
0978
0979 trigger::TriggerObjectCollection filteredHltObjects;
0980 std::copy_if(hltObjects.begin(), hltObjects.end(), std::back_inserter(filteredHltObjects), [](auto obj) {
0981 return obj.et() > 27;
0982 });
0983 double l1Eta = jet.eta();
0984 double l1Phi = jet.phi();
0985 const trigger::TriggerObjectCollection matchedObjects = getMatchedTriggerObjects(l1Eta, l1Phi, 0.3, hltObjects);
0986
0987 return matchedObjects.empty();
0988 }
0989
0990 void L1TStage2CaloLayer2Offline::normalise2DHistogramsToBinArea() {
0991 std::vector<MonitorElement*> monElementstoNormalize = {
0992 h_L1METvsCaloMET_, h_L1ETMHFvsCaloETMHF_, h_L1METvsPFMetNoMu_, h_L1MHTvsRecoMHT_,
0993 h_L1METTvsCaloETT_, h_L1HTTvsRecoHTT_, h_L1METPhivsCaloMETPhi_, h_L1ETMHFPhivsCaloETMHFPhi_,
0994 h_L1METPhivsPFMetNoMuPhi_, h_L1MHTPhivsRecoMHTPhi_, h_L1JetETvsPFJetET_HB_, h_L1JetETvsPFJetET_HE_,
0995 h_L1JetETvsPFJetET_HF_, h_L1JetETvsPFJetET_HB_HE_, h_L1JetPhivsPFJetPhi_HB_, h_L1JetPhivsPFJetPhi_HE_,
0996 h_L1JetPhivsPFJetPhi_HF_, h_L1JetPhivsPFJetPhi_HB_HE_, h_L1JetEtavsPFJetEta_,
0997 };
0998
0999 for (auto mon : monElementstoNormalize) {
1000 if (mon != nullptr) {
1001 auto h = mon->getTH2F();
1002 if (h != nullptr) {
1003 h->Scale(1, "width");
1004 }
1005 }
1006 }
1007 }
1008
1009
1010 DEFINE_FWK_MODULE(L1TStage2CaloLayer2Offline);
