File indexing completed on 2024-09-07 04:36:02
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020 #include <memory>
0021 #include <sys/time.h>
0022 #include <cstdlib>
0023
0024
0025 #include "DataFormats/Common/interface/TriggerResults.h"
0026 #include "DataFormats/HLTReco/interface/TriggerObject.h"
0027 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
0028 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
0029
0030 #include "FWCore/Framework/interface/Frameworkfwd.h"
0031 #include "FWCore/Framework/interface/Event.h"
0032 #include "FWCore/Framework/interface/MakerMacros.h"
0033 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0034 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0035
0036 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
0037
0038
0039 #include "HLTrigger/JetMET/interface/AlphaT.h"
0040 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0041 #include "DataFormats/METReco/interface/MET.h"
0042 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidate.h"
0043 #include "DataFormats/BTauReco/interface/JetTag.h"
0044 #include "DataFormats/RecoCandidate/interface/RecoChargedCandidateFwd.h"
0045 #include "DataFormats/Math/interface/deltaR.h"
0046 #include "DataFormats/JetReco/interface/PFJet.h"
0047 #include "DataFormats/JetReco/interface/CaloJet.h"
0048
0049 #include "DQMServices/Core/interface/DQMStore.h"
0050 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0051
0052 #include "TMath.h"
0053 #include "TStyle.h"
0054 #include "TLorentzVector.h"
0055
0056 #include <unordered_map>
0057
0058
0059
0060
0061
0062 using namespace trigger;
0063 using std::string;
0064 using std::unordered_map;
0065 using std::vector;
0066
0067 class HLTObjectMonitorProtonLead : public DQMEDAnalyzer {
0068 struct hltPlot {
0069 MonitorElement* ME;
0070 string pathName;
0071 string pathNameOR;
0072 string moduleName;
0073 string moduleNameOR;
0074 int pathIndex = -99;
0075 int pathIndexOR = -99;
0076 string plotLabel;
0077 string xAxisLabel;
0078 int nBins;
0079 double xMin;
0080 double xMax;
0081 bool displayInPrimary;
0082 };
0083
0084 public:
0085 explicit HLTObjectMonitorProtonLead(const edm::ParameterSet&);
0086
0087
0088
0089 private:
0090 void analyze(const edm::Event&, const edm::EventSetup&) override;
0091 void bookHistograms(DQMStore::IBooker& i, edm::Run const&, edm::EventSetup const&) override;
0092 void dqmBeginRun(edm::Run const&, edm::EventSetup const&) override;
0093 vector<hltPlot*> plotList;
0094 double get_wall_time(void);
0095
0096
0097 bool debugPrint;
0098 HLTConfigProvider hltConfig_;
0099 string topDirectoryName;
0100 string mainShifterFolder;
0101 string backupFolder;
0102 unordered_map<string, bool> acceptMap;
0103 unordered_map<hltPlot*, edm::ParameterSet*> plotMap;
0104
0105
0106 edm::EDGetTokenT<edm::TriggerResults> triggerResultsToken_;
0107 edm::EDGetTokenT<trigger::TriggerEvent> aodTriggerToken_;
0108
0109
0110
0111 edm::ParameterSet caloAK4JetPt_pset;
0112 edm::ParameterSet caloAK4JetEta_pset;
0113 edm::ParameterSet caloAK4JetPhi_pset;
0114 edm::ParameterSet pfAK4JetPt_pset;
0115 edm::ParameterSet pfAK4JetEta_pset;
0116 edm::ParameterSet pfAK4JetPhi_pset;
0117 edm::ParameterSet caloDiAK4JetPt_pset;
0118 edm::ParameterSet caloDiAK4JetEta_pset;
0119 edm::ParameterSet caloDiAK4JetPhi_pset;
0120 edm::ParameterSet pfDiAK4JetPt_pset;
0121 edm::ParameterSet pfDiAK4JetEta_pset;
0122 edm::ParameterSet pfDiAK4JetPhi_pset;
0123 edm::ParameterSet photonPt_pset;
0124 edm::ParameterSet photonEta_pset;
0125 edm::ParameterSet photonPhi_pset;
0126 edm::ParameterSet photonPPPt_pset;
0127 edm::ParameterSet photonPPEta_pset;
0128 edm::ParameterSet photonPPPhi_pset;
0129 edm::ParameterSet caloBJetPt_pset;
0130 edm::ParameterSet caloBJetEta_pset;
0131 edm::ParameterSet caloBJetPhi_pset;
0132 edm::ParameterSet pfBJetPt_pset;
0133 edm::ParameterSet pfBJetEta_pset;
0134 edm::ParameterSet pfBJetPhi_pset;
0135 edm::ParameterSet electronPt_pset;
0136 edm::ParameterSet electronEta_pset;
0137 edm::ParameterSet electronPhi_pset;
0138 edm::ParameterSet l3muon3Pt_pset;
0139 edm::ParameterSet l3muon3Eta_pset;
0140 edm::ParameterSet l3muon3Phi_pset;
0141 edm::ParameterSet l2muon12Pt_pset;
0142 edm::ParameterSet l2muon12Eta_pset;
0143 edm::ParameterSet l2muon12Phi_pset;
0144 edm::ParameterSet l3muon12Pt_pset;
0145 edm::ParameterSet l3muon12Eta_pset;
0146 edm::ParameterSet l3muon12Phi_pset;
0147 edm::ParameterSet pAL1DoubleMuZMass_pset;
0148 edm::ParameterSet pAL2DoubleMuZMass_pset;
0149 edm::ParameterSet pAL3DoubleMuZMass_pset;
0150 edm::ParameterSet wallTime_pset;
0151
0152 string processName_;
0153
0154 hltPlot caloAK4JetPt_;
0155 hltPlot caloAK4JetEta_;
0156 hltPlot caloAK4JetPhi_;
0157 hltPlot pfAK4JetPt_;
0158 hltPlot pfAK4JetEta_;
0159 hltPlot pfAK4JetPhi_;
0160 hltPlot caloDiAK4JetPt_;
0161 hltPlot caloDiAK4JetEta_;
0162 hltPlot caloDiAK4JetPhi_;
0163 hltPlot pfDiAK4JetPt_;
0164 hltPlot pfDiAK4JetEta_;
0165 hltPlot pfDiAK4JetPhi_;
0166 hltPlot photonPt_;
0167 hltPlot photonEta_;
0168 hltPlot photonPhi_;
0169 hltPlot photonPPPt_;
0170 hltPlot photonPPEta_;
0171 hltPlot photonPPPhi_;
0172 hltPlot caloBJetPt_;
0173 hltPlot caloBJetEta_;
0174 hltPlot caloBJetPhi_;
0175 hltPlot pfBJetPt_;
0176 hltPlot pfBJetEta_;
0177 hltPlot pfBJetPhi_;
0178 hltPlot electronPt_;
0179 hltPlot electronEta_;
0180 hltPlot electronPhi_;
0181 hltPlot l3muon3Pt_;
0182 hltPlot l3muon3Eta_;
0183 hltPlot l3muon3Phi_;
0184 hltPlot l2muon12Pt_;
0185 hltPlot l2muon12Eta_;
0186 hltPlot l2muon12Phi_;
0187 hltPlot l3muon12Pt_;
0188 hltPlot l3muon12Eta_;
0189 hltPlot l3muon12Phi_;
0190 hltPlot pAL1DoubleMuZMass_;
0191 hltPlot pAL2DoubleMuZMass_;
0192 hltPlot pAL3DoubleMuZMass_;
0193 hltPlot wallTime_;
0194 };
0195
0196
0197
0198
0199
0200
0201
0202
0203
0204
0205
0206
0207 HLTObjectMonitorProtonLead::HLTObjectMonitorProtonLead(const edm::ParameterSet& iConfig)
0208
0209 {
0210
0211 debugPrint = false;
0212
0213 topDirectoryName = "HLT/ObjectMonitor";
0214 mainShifterFolder = topDirectoryName + "/MainShifter";
0215 backupFolder = topDirectoryName + "/Backup";
0216
0217
0218 processName_ = iConfig.getParameter<string>("processName");
0219
0220 caloAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPt");
0221 plotMap[&caloAK4JetPt_] = &caloAK4JetPt_pset;
0222 caloAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetEta");
0223 plotMap[&caloAK4JetEta_] = &caloAK4JetEta_pset;
0224 caloAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloAK4JetPhi");
0225 plotMap[&caloAK4JetPhi_] = &caloAK4JetPhi_pset;
0226 pfAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPt");
0227 plotMap[&pfAK4JetPt_] = &pfAK4JetPt_pset;
0228 pfAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetEta");
0229 plotMap[&pfAK4JetEta_] = &pfAK4JetEta_pset;
0230 pfAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfAK4JetPhi");
0231 plotMap[&pfAK4JetPhi_] = &pfAK4JetPhi_pset;
0232 caloDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPt");
0233 plotMap[&caloDiAK4JetPt_] = &caloDiAK4JetPt_pset;
0234 caloDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetEta");
0235 plotMap[&caloDiAK4JetEta_] = &caloDiAK4JetEta_pset;
0236 caloDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloDiAK4JetPhi");
0237 plotMap[&caloDiAK4JetPhi_] = &caloDiAK4JetPhi_pset;
0238 pfDiAK4JetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPt");
0239 plotMap[&pfDiAK4JetPt_] = &pfDiAK4JetPt_pset;
0240 pfDiAK4JetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetEta");
0241 plotMap[&pfDiAK4JetEta_] = &pfDiAK4JetEta_pset;
0242 pfDiAK4JetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfDiAK4JetPhi");
0243 plotMap[&pfDiAK4JetPhi_] = &pfDiAK4JetPhi_pset;
0244 photonPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPt");
0245 plotMap[&photonPt_] = &photonPt_pset;
0246 photonEta_pset = iConfig.getParameter<edm::ParameterSet>("photonEta");
0247 plotMap[&photonEta_] = &photonEta_pset;
0248 photonPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPhi");
0249 plotMap[&photonPhi_] = &photonPhi_pset;
0250 photonPPPt_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPt");
0251 plotMap[&photonPPPt_] = &photonPPPt_pset;
0252 photonPPEta_pset = iConfig.getParameter<edm::ParameterSet>("photonPPEta");
0253 plotMap[&photonPPEta_] = &photonPPEta_pset;
0254 photonPPPhi_pset = iConfig.getParameter<edm::ParameterSet>("photonPPPhi");
0255 plotMap[&photonPPPhi_] = &photonPPPhi_pset;
0256 caloBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPt");
0257 plotMap[&caloBJetPt_] = &caloBJetPt_pset;
0258 caloBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetEta");
0259 plotMap[&caloBJetEta_] = &caloBJetEta_pset;
0260 caloBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("caloBJetPhi");
0261 plotMap[&caloBJetPhi_] = &caloBJetPhi_pset;
0262 pfBJetPt_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPt");
0263 plotMap[&pfBJetPt_] = &pfBJetPt_pset;
0264 pfBJetEta_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetEta");
0265 plotMap[&pfBJetEta_] = &pfBJetEta_pset;
0266 pfBJetPhi_pset = iConfig.getParameter<edm::ParameterSet>("pfBJetPhi");
0267 plotMap[&pfBJetPhi_] = &pfBJetPhi_pset;
0268 electronPt_pset = iConfig.getParameter<edm::ParameterSet>("electronPt");
0269 plotMap[&electronPt_] = &electronPt_pset;
0270 electronEta_pset = iConfig.getParameter<edm::ParameterSet>("electronEta");
0271 plotMap[&electronEta_] = &electronEta_pset;
0272 electronPhi_pset = iConfig.getParameter<edm::ParameterSet>("electronPhi");
0273 plotMap[&electronPhi_] = &electronPhi_pset;
0274 l3muon3Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Pt");
0275 plotMap[&l3muon3Pt_] = &l3muon3Pt_pset;
0276 l3muon3Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Eta");
0277 plotMap[&l3muon3Eta_] = &l3muon3Eta_pset;
0278 l3muon3Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon3Phi");
0279 plotMap[&l3muon3Phi_] = &l3muon3Phi_pset;
0280 l2muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Pt");
0281 plotMap[&l2muon12Pt_] = &l2muon12Pt_pset;
0282 l2muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Eta");
0283 plotMap[&l2muon12Eta_] = &l2muon12Eta_pset;
0284 l2muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l2muon12Phi");
0285 plotMap[&l2muon12Phi_] = &l2muon12Phi_pset;
0286 l3muon12Pt_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Pt");
0287 plotMap[&l3muon12Pt_] = &l3muon12Pt_pset;
0288 l3muon12Eta_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Eta");
0289 plotMap[&l3muon12Eta_] = &l3muon12Eta_pset;
0290 l3muon12Phi_pset = iConfig.getParameter<edm::ParameterSet>("l3muon12Phi");
0291 plotMap[&l3muon12Phi_] = &l3muon12Phi_pset;
0292 pAL1DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL1DoubleMuZMass");
0293 plotMap[&pAL1DoubleMuZMass_] = &pAL1DoubleMuZMass_pset;
0294 pAL2DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL2DoubleMuZMass");
0295 plotMap[&pAL2DoubleMuZMass_] = &pAL2DoubleMuZMass_pset;
0296 pAL3DoubleMuZMass_pset = iConfig.getParameter<edm::ParameterSet>("pAL3DoubleMuZMass");
0297 plotMap[&pAL3DoubleMuZMass_] = &pAL3DoubleMuZMass_pset;
0298 wallTime_pset = iConfig.getParameter<edm::ParameterSet>("wallTime");
0299 plotMap[&wallTime_] = &wallTime_pset;
0300
0301 for (auto item = plotMap.begin(); item != plotMap.end(); item++) {
0302 (*item->first).pathName = (*item->second).getParameter<string>("pathName");
0303 (*item->first).moduleName = (*item->second).getParameter<string>("moduleName");
0304 (*item->first).nBins = (*item->second).getParameter<int>("NbinsX");
0305 (*item->first).xMin = (*item->second).getParameter<double>("Xmin");
0306 (*item->first).xMax = (*item->second).getParameter<double>("Xmax");
0307 (*item->first).xAxisLabel = (*item->second).getParameter<string>("axisLabel");
0308 (*item->first).plotLabel = (*item->second).getParameter<string>("plotLabel");
0309 (*item->first).displayInPrimary = (*item->second).getParameter<bool>("mainWorkspace");
0310
0311 if ((*item->second).exists("pathName_OR")) {
0312 (*item->first).pathNameOR = (*item->second).getParameter<string>("pathName_OR");
0313 }
0314 if ((*item->second).exists("moduleName_OR")) {
0315 (*item->first).moduleNameOR = (*item->second).getParameter<string>("moduleName_OR");
0316 }
0317
0318 plotList.push_back(item->first);
0319 }
0320 plotMap.clear();
0321
0322
0323 triggerResultsToken_ = consumes<edm::TriggerResults>(iConfig.getParameter<edm::InputTag>("triggerResults"));
0324 aodTriggerToken_ = consumes<trigger::TriggerEvent>(iConfig.getParameter<edm::InputTag>("triggerEvent"));
0325 }
0326
0327
0328
0329
0330
0331
0332 void HLTObjectMonitorProtonLead::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0333 double start = get_wall_time();
0334
0335 using namespace edm;
0336
0337 if (debugPrint)
0338 std::cout << "Inside analyze(). " << std::endl;
0339
0340
0341 edm::Handle<edm::TriggerResults> triggerResults;
0342 iEvent.getByToken(triggerResultsToken_, triggerResults);
0343 if (!triggerResults.isValid())
0344 return;
0345
0346 edm::Handle<trigger::TriggerEvent> aodTriggerEvent;
0347 iEvent.getByToken(aodTriggerToken_, aodTriggerEvent);
0348 if (!aodTriggerEvent.isValid())
0349 return;
0350
0351
0352 unordered_map<string, bool> firedMap = acceptMap;
0353 for (auto plot : plotList)
0354 {
0355 if (firedMap[plot->pathName])
0356 continue;
0357 bool triggerAccept = false;
0358 const TriggerObjectCollection objects = aodTriggerEvent->getObjects();
0359 edm::InputTag moduleFilter;
0360 std::string pathName;
0361 if (plot->pathIndex > 0 && triggerResults->accept(plot->pathIndex) && hltConfig_.saveTags(plot->moduleName)) {
0362 moduleFilter = edm::InputTag(plot->moduleName, "", processName_);
0363 pathName = plot->pathName;
0364 triggerAccept = true;
0365 } else if (plot->pathIndexOR > 0 && triggerResults->accept(plot->pathIndexOR) &&
0366 hltConfig_.saveTags(plot->moduleNameOR)) {
0367 if (firedMap[plot->pathNameOR])
0368 continue;
0369 moduleFilter = edm::InputTag(plot->moduleNameOR, "", processName_);
0370 pathName = plot->pathNameOR;
0371 triggerAccept = true;
0372 }
0373
0374 if (triggerAccept) {
0375 unsigned int moduleFilterIndex = aodTriggerEvent->filterIndex(moduleFilter);
0376
0377 if (moduleFilterIndex + 1 > aodTriggerEvent->sizeFilters())
0378 return;
0379 const Keys& keys = aodTriggerEvent->filterKeys(moduleFilterIndex);
0380
0381
0382
0383
0384
0385
0386
0387
0388 if (pathName == caloAK4JetPt_.pathName) {
0389 for (const auto& key : keys) {
0390 caloAK4JetPt_.ME->Fill(objects[key].pt());
0391 caloAK4JetEta_.ME->Fill(objects[key].eta());
0392 caloAK4JetPhi_.ME->Fill(objects[key].phi());
0393 }
0394 }
0395
0396 else if (pathName == pfAK4JetPt_.pathName) {
0397 for (const auto& key : keys) {
0398 pfAK4JetPt_.ME->Fill(objects[key].pt());
0399 pfAK4JetEta_.ME->Fill(objects[key].eta());
0400 pfAK4JetPhi_.ME->Fill(objects[key].phi());
0401 }
0402 }
0403
0404 else if (pathName == caloDiAK4JetPt_.pathName) {
0405 for (const auto& key : keys) {
0406 caloDiAK4JetPt_.ME->Fill(objects[key].pt());
0407 caloDiAK4JetEta_.ME->Fill(objects[key].eta());
0408 caloDiAK4JetPhi_.ME->Fill(objects[key].phi());
0409 }
0410 }
0411
0412 else if (pathName == pfDiAK4JetPt_.pathName) {
0413 for (const auto& key : keys) {
0414 pfDiAK4JetPt_.ME->Fill(objects[key].pt());
0415 pfDiAK4JetEta_.ME->Fill(objects[key].eta());
0416 pfDiAK4JetPhi_.ME->Fill(objects[key].phi());
0417 }
0418 }
0419
0420 else if (pathName == photonPt_.pathName) {
0421 for (const auto& key : keys) {
0422 photonPt_.ME->Fill(objects[key].pt());
0423 photonEta_.ME->Fill(objects[key].eta());
0424 photonPhi_.ME->Fill(objects[key].phi());
0425 }
0426 }
0427
0428 else if (pathName == photonPPPt_.pathName) {
0429 for (const auto& key : keys) {
0430 photonPPPt_.ME->Fill(objects[key].pt());
0431 photonPPEta_.ME->Fill(objects[key].eta());
0432 photonPPPhi_.ME->Fill(objects[key].phi());
0433 }
0434 }
0435
0436 else if (pathName == caloBJetPt_.pathName) {
0437 for (const auto& key : keys) {
0438 caloBJetPt_.ME->Fill(objects[key].pt());
0439 caloBJetEta_.ME->Fill(objects[key].eta());
0440 caloBJetPhi_.ME->Fill(objects[key].phi());
0441 }
0442 }
0443
0444 else if (pathName == pfBJetPt_.pathName) {
0445 for (const auto& key : keys) {
0446 pfBJetPt_.ME->Fill(objects[key].pt());
0447 pfBJetEta_.ME->Fill(objects[key].eta());
0448 pfBJetPhi_.ME->Fill(objects[key].phi());
0449 }
0450 }
0451
0452 else if (pathName == electronPt_.pathName) {
0453 for (const auto& key : keys) {
0454 electronPt_.ME->Fill(objects[key].pt());
0455 electronEta_.ME->Fill(objects[key].eta());
0456 electronPhi_.ME->Fill(objects[key].phi());
0457 }
0458 } else if (pathName == l3muon3Pt_.pathName) {
0459 for (const auto& key : keys) {
0460 l3muon3Pt_.ME->Fill(objects[key].pt());
0461 l3muon3Eta_.ME->Fill(objects[key].eta());
0462 l3muon3Phi_.ME->Fill(objects[key].phi());
0463 }
0464 } else if (pathName == l2muon12Pt_.pathName) {
0465 for (const auto& key : keys) {
0466 l2muon12Pt_.ME->Fill(objects[key].pt());
0467 l2muon12Eta_.ME->Fill(objects[key].eta());
0468 l2muon12Phi_.ME->Fill(objects[key].phi());
0469 }
0470 } else if (pathName == l3muon12Pt_.pathName) {
0471 for (const auto& key : keys) {
0472 l3muon12Pt_.ME->Fill(objects[key].pt());
0473 l3muon12Eta_.ME->Fill(objects[key].eta());
0474 l3muon12Phi_.ME->Fill(objects[key].phi());
0475 }
0476 }
0477
0478
0479
0480
0481
0482
0483
0484 else if (pathName == pAL1DoubleMuZMass_.pathName) {
0485 const double mu_mass(.105658);
0486 unsigned int kCnt0 = 0;
0487 for (const auto& key0 : keys) {
0488 unsigned int kCnt1 = 0;
0489 for (const auto& key1 : keys) {
0490 if (key0 != key1 &&
0491 kCnt1 > kCnt0) {
0492
0493 TLorentzVector mu1, mu2, dimu;
0494 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0495 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0496 dimu = mu1 + mu2;
0497 if (dimu.M() > pAL1DoubleMuZMass_.xMin && dimu.M() < pAL1DoubleMuZMass_.xMax)
0498 pAL1DoubleMuZMass_.ME->Fill(dimu.M());
0499 }
0500 kCnt1 += 1;
0501 }
0502 kCnt0 += 1;
0503 }
0504 } else if (pathName == pAL2DoubleMuZMass_.pathName) {
0505 const double mu_mass(.105658);
0506 unsigned int kCnt0 = 0;
0507 for (const auto& key0 : keys) {
0508 unsigned int kCnt1 = 0;
0509 for (const auto& key1 : keys) {
0510 if (key0 != key1 &&
0511 kCnt1 > kCnt0) {
0512 if (abs(objects[key0].id()) == 13 &&
0513 (objects[key0].id() + objects[key1].id() == 0)) {
0514 TLorentzVector mu1, mu2, dimu;
0515 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0516 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0517 dimu = mu1 + mu2;
0518 if (dimu.M() > pAL2DoubleMuZMass_.xMin && dimu.M() < pAL2DoubleMuZMass_.xMax)
0519 pAL2DoubleMuZMass_.ME->Fill(dimu.M());
0520 }
0521 }
0522 kCnt1 += 1;
0523 }
0524 kCnt0 += 1;
0525 }
0526 } else if (pathName == pAL3DoubleMuZMass_.pathName) {
0527 const double mu_mass(.105658);
0528 unsigned int kCnt0 = 0;
0529 for (const auto& key0 : keys) {
0530 unsigned int kCnt1 = 0;
0531 for (const auto& key1 : keys) {
0532 if (key0 != key1 &&
0533 kCnt1 > kCnt0) {
0534 if (abs(objects[key0].id()) == 13 &&
0535 (objects[key0].id() + objects[key1].id() == 0)) {
0536 TLorentzVector mu1, mu2, dimu;
0537 mu1.SetPtEtaPhiM(objects[key0].pt(), objects[key0].eta(), objects[key0].phi(), mu_mass);
0538 mu2.SetPtEtaPhiM(objects[key1].pt(), objects[key1].eta(), objects[key1].phi(), mu_mass);
0539 dimu = mu1 + mu2;
0540 if (dimu.M() > pAL3DoubleMuZMass_.xMin && dimu.M() < pAL3DoubleMuZMass_.xMax)
0541 pAL3DoubleMuZMass_.ME->Fill(dimu.M());
0542 }
0543 }
0544 kCnt1 += 1;
0545 }
0546 kCnt0 += 1;
0547 }
0548 }
0549
0550 firedMap[pathName] = true;
0551 }
0552 }
0553
0554
0555 double end = get_wall_time();
0556 double wallTime = end - start;
0557 wallTime_.ME->Fill(wallTime);
0558 }
0559
0560
0561 void HLTObjectMonitorProtonLead::dqmBeginRun(edm::Run const& iRun, edm::EventSetup const& iSetup) {
0562 if (debugPrint)
0563 std::cout << "Calling beginRun. " << std::endl;
0564 bool changed = true;
0565 if (hltConfig_.init(iRun, iSetup, processName_, changed)) {
0566 if (debugPrint)
0567 std::cout << "Extracting HLTconfig. " << std::endl;
0568 }
0569
0570
0571 string pathName_noVersion;
0572 vector<string> triggerPaths = hltConfig_.triggerNames();
0573
0574 for (const auto& pathName : triggerPaths) {
0575 pathName_noVersion = hltConfig_.removeVersion(pathName);
0576 for (auto plot : plotList) {
0577 if (plot->pathName == pathName_noVersion) {
0578 (*plot).pathIndex = hltConfig_.triggerIndex(pathName);
0579 } else if (plot->pathNameOR == pathName_noVersion) {
0580 (*plot).pathIndexOR = hltConfig_.triggerIndex(pathName);
0581 }
0582 }
0583 }
0584 vector<hltPlot*> plotList_temp;
0585 for (auto plot : plotList) {
0586 if (plot->pathIndex > 0 || plot->pathIndexOR > 0) {
0587 plotList_temp.push_back(plot);
0588 acceptMap[plot->pathName] = false;
0589 if (plot->pathIndexOR > 0)
0590 acceptMap[plot->pathNameOR] = false;
0591 }
0592 }
0593
0594 plotList = plotList_temp;
0595 plotList_temp.clear();
0596 }
0597
0598
0599
0600 void HLTObjectMonitorProtonLead::bookHistograms(DQMStore::IBooker& ibooker,
0601 edm::Run const& iRun,
0602 edm::EventSetup const& iSetup) {
0603
0604
0605
0606
0607
0608
0609
0610 ibooker.setCurrentFolder(mainShifterFolder);
0611 wallTime_.ME =
0612 ibooker.book1D(wallTime_.plotLabel, wallTime_.pathName, wallTime_.nBins, wallTime_.xMin, wallTime_.xMax);
0613 wallTime_.ME->setAxisTitle(wallTime_.xAxisLabel);
0614
0615 for (auto plot : plotList) {
0616 std::string display_pathNames = plot->pathName;
0617 if (!plot->pathNameOR.empty())
0618 display_pathNames = plot->pathName + " OR " + plot->pathNameOR;
0619
0620 if (plot->displayInPrimary) {
0621 ibooker.setCurrentFolder(mainShifterFolder);
0622 (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0623 (*plot).ME->setAxisTitle(plot->xAxisLabel);
0624
0625 } else {
0626 ibooker.setCurrentFolder(backupFolder);
0627 (*plot).ME = ibooker.book1D(plot->plotLabel, display_pathNames.c_str(), plot->nBins, plot->xMin, plot->xMax);
0628 (*plot).ME->setAxisTitle(plot->xAxisLabel);
0629 }
0630 }
0631 }
0632
0633 double HLTObjectMonitorProtonLead::get_wall_time() {
0634 struct timeval time;
0635 if (gettimeofday(&time, nullptr))
0636 return 0;
0637 return (double)time.tv_sec + (double)time.tv_usec * .000001;
0638 }
0639
0640
0641
0642
0643
0644
0645
0646
0647
0648
0649
0650
0651
0652
0653
0654
0655
0656
0657
0658
0659
0660
0661
0662
0663
0664
0665
0666
0667 DEFINE_FWK_MODULE(HLTObjectMonitorProtonLead);