CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
FourVectorHLTOffline.cc
Go to the documentation of this file.
1 // See header file for information.
2 #include "TMath.h"
3 #include "DQMOffline/Trigger/interface/FourVectorHLTOffline.h"
4 #include "FWCore/Common/interface/TriggerNames.h"
5 
6 #include <map>
7 #include <utility>
8 
9 using namespace edm;
10 using namespace trigger;
11 using namespace std;
12 using namespace muon;
13 
14 FourVectorHLTOffline::FourVectorHLTOffline(const edm::ParameterSet& iConfig): currentRun_(-99)
15 {
16 
17  LogDebug("FourVectorHLTOffline") << "constructor...." ;
18 
19  useUM = false;
20  fIsSetup = false;
21  fSelectedMuons = new reco::MuonCollection;
22  fSelectedElectrons = new reco::GsfElectronCollection;
23  fSelectedPhotons = new reco::PhotonCollection;
24  fSelectedJets = new reco::CaloJetCollection;
25  fSelectedMet = new reco::CaloMETCollection;
26  //fSelectedTaus = new reco::CaloTauCollection;
27  fSelectedTaus = new reco::PFTauCollection;
28 
29  dbe_ = Service < DQMStore > ().operator->();
30  if ( ! dbe_ ) {
31  LogInfo("FourVectorHLTOffline") << "unabel to get DQMStore service?";
32  }
33  if (iConfig.getUntrackedParameter < bool > ("DQMStore", false)) {
34  dbe_->setVerbose(0);
35  }
36 
37  dirname_ = iConfig.getUntrackedParameter("dirname", std::string("HLT/FourVector/"));
38  //dirname_ += iConfig.getParameter<std::string>("@module_label");
39 
40  if (dbe_ != 0 ) {
41  dbe_->setCurrentFolder(dirname_);
42  }
43 
44 
45  doCombineRuns_ = iConfig.getUntrackedParameter<bool>("doCombineRuns", false);
46 
47  processname_ = iConfig.getParameter<std::string>("processname");
48  fCustomBXPath = iConfig.getUntrackedParameter<std::string>("customBXPath", std::string("HLT_MinBiasBSC"));
49 
50  referenceBX_ = iConfig.getUntrackedParameter<unsigned int>("referenceBX",51);
51  Nbx_ = iConfig.getUntrackedParameter<unsigned int>("Nbx",3564);
52 
53  // plotting paramters
54  ptMin_ = iConfig.getUntrackedParameter<double>("ptMin",0.);
55  ptMax_ = iConfig.getUntrackedParameter<double>("ptMax",1000.);
56  nBins_ = iConfig.getUntrackedParameter<unsigned int>("Nbins",20);
57  nBins2D_ = iConfig.getUntrackedParameter<unsigned int>("Nbins2D",40);
58  dRMax_ = iConfig.getUntrackedParameter<double>("dRMax",1.0);
59  nBinsDR_ = iConfig.getUntrackedParameter<unsigned int>("NbinsDR",10);
60  nBinsOneOverEt_ = iConfig.getUntrackedParameter<unsigned int>("NbinsOneOverEt",10000);
61  nLS_ = iConfig.getUntrackedParameter<unsigned int>("NLuminositySegments",10);
62  LSsize_ = iConfig.getUntrackedParameter<double>("LuminositySegmentSize",23);
63  thresholdFactor_ = iConfig.getUntrackedParameter<double>("thresholdFactor",1.5);
64 
65 
66  plotAll_ = iConfig.getUntrackedParameter<bool>("plotAll", false);
67  // this is the list of paths to look at.
68  std::vector<edm::ParameterSet> paths =
69  iConfig.getParameter<std::vector<edm::ParameterSet> >("paths");
70 
71  for(std::vector<edm::ParameterSet>::iterator pathconf = paths.begin() ; pathconf != paths.end(); pathconf++) {
72 
73  //std::pair<std::string, std::string> custompathnamepair;
74  //custompathnamepair.first =pathconf->getParameter<std::string>("pathname");
75  //custompathnamepair.second = pathconf->getParameter<std::string>("denompathname");
76  //custompathnamepairs_.push_back(custompathnamepair);
77  custompathnamepairs_.push_back(
78  make_pair(
79  pathconf->getParameter<std::string>("pathname"),
80  pathconf->getParameter<std::string>("denompathname")
81  )
82  );
83 
84  }
85 
86  if (hltPaths_.size() > 0)
87  {
88  // book a histogram of scalers
89  scalersSelect = dbe_->book1D("selectedScalers","Selected Scalers", hltPaths_.size(), 0.0, (double)hltPaths_.size());
90 
91  }
92 
93  triggerSummaryLabel_ = iConfig.getParameter<edm::InputTag>("triggerSummaryLabel");
94  triggerResultsLabel_ = iConfig.getParameter<edm::InputTag>("triggerResultsLabel");
95  triggerSummaryToken = consumes <trigger::TriggerEvent> (triggerSummaryLabel_);
96  triggerResultsToken = consumes <TriggerResults> (triggerResultsLabel_);
97  triggerSummaryFUToken = consumes <trigger::TriggerEvent> (edm::InputTag(triggerSummaryLabel_.label(),triggerSummaryLabel_.instance(),std::string("FU")));
98  triggerResultsFUToken = consumes <TriggerResults> (edm::InputTag(triggerResultsLabel_.label(),triggerResultsLabel_.instance(),std::string("FU")));
99  muonRecoCollectionToken = consumes <reco::MuonCollection> (iConfig.getUntrackedParameter("muonRecoCollectionName", std::string("muons")));
100 
101  beamSpotToken = consumes <reco::BeamSpot> (std::string("offlineBeamSpot"));
102  gsfElectronToken = consumes <reco::GsfElectronCollection> (std::string("gsfElectrons"));
103  tauProdToken = consumes <std::vector<reco::PFTau> > (std::string("caloRecoTauProducer"));
104  iC5calojetToken = consumes <reco::CaloJetCollection> (std::string("iterativeCone5CaloJets"));
105  jlipBtagToken = consumes <reco::JetTagCollection> (std::string("jetProbabilityBJetTags"));
106  softMuBtagToken = consumes <reco::JetTagCollection> (std::string("softMuonBJetTags"));
107  METToken = consumes <reco::CaloMETCollection> (std::string("met"));
108  photonToken = consumes <reco::PhotonCollection> (std::string("photons"));
109  pixelTrackToken = consumes <reco::TrackCollection> (std::string("pixelTracks"));
110  hpsPFTauProdToken = consumes <std::vector<reco::PFTau> > (std::string("hpsPFTauProducer"));
111 
112  electronEtaMax_ = iConfig.getUntrackedParameter<double>("electronEtaMax",2.5);
113  electronEtMin_ = iConfig.getUntrackedParameter<double>("electronEtMin",3.0);
114  electronDRMatch_ =iConfig.getUntrackedParameter<double>("electronDRMatch",0.3);
115  electronL1DRMatch_ =iConfig.getUntrackedParameter<double>("electronL1DRMatch",0.3);
116 
117  muonEtaMax_ = iConfig.getUntrackedParameter<double>("muonEtaMax",2.1);
118  muonEtMin_ = iConfig.getUntrackedParameter<double>("muonEtMin",3.0);
119  muonDRMatch_ =iConfig.getUntrackedParameter<double>("muonDRMatch",0.3);
120  muonL1DRMatch_ =iConfig.getUntrackedParameter<double>("muonL1DRMatch",0.3);
121 
122  tauEtaMax_ = iConfig.getUntrackedParameter<double>("tauEtaMax",2.5);
123  tauEtMin_ = iConfig.getUntrackedParameter<double>("tauEtMin",3.0);
124  tauDRMatch_ =iConfig.getUntrackedParameter<double>("tauDRMatch",0.3);
125  tauL1DRMatch_ =iConfig.getUntrackedParameter<double>("tauL1DRMatch",0.5);
126 
127  jetEtaMax_ = iConfig.getUntrackedParameter<double>("jetEtaMax",5.0);
128  jetEtMin_ = iConfig.getUntrackedParameter<double>("jetEtMin",10.0);
129  jetDRMatch_ =iConfig.getUntrackedParameter<double>("jetDRMatch",0.3);
130  jetL1DRMatch_ =iConfig.getUntrackedParameter<double>("jetL1DRMatch",0.5);
131 
132  bjetEtaMax_ = iConfig.getUntrackedParameter<double>("bjetEtaMax",2.5);
133  bjetEtMin_ = iConfig.getUntrackedParameter<double>("bjetEtMin",10.0);
134  bjetDRMatch_ =iConfig.getUntrackedParameter<double>("bjetDRMatch",0.3);
135  bjetL1DRMatch_ =iConfig.getUntrackedParameter<double>("bjetL1DRMatch",0.3);
136 
137  photonEtaMax_ = iConfig.getUntrackedParameter<double>("photonEtaMax",2.5);
138  photonEtMin_ = iConfig.getUntrackedParameter<double>("photonEtMin",3.0);
139  photonDRMatch_ =iConfig.getUntrackedParameter<double>("photonDRMatch",0.3);
140  photonL1DRMatch_ =iConfig.getUntrackedParameter<double>("photonL1DRMatch",0.3);
141 
142  trackEtaMax_ = iConfig.getUntrackedParameter<double>("trackEtaMax",2.5);
143  trackEtMin_ = iConfig.getUntrackedParameter<double>("trackEtMin",3.0);
144  trackDRMatch_ =iConfig.getUntrackedParameter<double>("trackDRMatch",0.3);
145  trackL1DRMatch_ =iConfig.getUntrackedParameter<double>("trackL1DRMatch",0.3);
146 
147  metEtaMax_ = iConfig.getUntrackedParameter<double>("metEtaMax",5);
148  metMin_ = iConfig.getUntrackedParameter<double>("metMin",10.0);
149  metDRMatch_ =iConfig.getUntrackedParameter<double>("metDRMatch",0.5);
150  metL1DRMatch_ =iConfig.getUntrackedParameter<double>("metL1DRMatch",0.5);
151 
152  htEtaMax_ = iConfig.getUntrackedParameter<double>("htEtaMax",5);
153  htMin_ = iConfig.getUntrackedParameter<double>("htMin",10.0);
154  htDRMatch_ =iConfig.getUntrackedParameter<double>("htDRMatch",0.5);
155  htL1DRMatch_ =iConfig.getUntrackedParameter<double>("htL1DRMatch",0.5);
156 
157  sumEtMin_ = iConfig.getUntrackedParameter<double>("sumEtMin",10.0);
158 
159  // Muon quality cuts
161  dxyCut_ = iConfig.getUntrackedParameter<double>("DxyCut", 0.2); // dxy < 0.2 cm
162  normalizedChi2Cut_ = iConfig.getUntrackedParameter<double>("NormalizedChi2Cut", 10.); // chi2/ndof (of global fit) <10.0
163  trackerHitsCut_ = iConfig.getUntrackedParameter<int>("TrackerHitsCut", 11); // Tracker Hits >10
164  pixelHitsCut_ = iConfig.getUntrackedParameter<int>("PixelHitsCut", 1); // Pixel Hits >0
165  muonHitsCut_ = iConfig.getUntrackedParameter<int>("MuonHitsCut", 1); // Valid Muon Hits >0
166  isAlsoTrackerMuon_ = iConfig.getUntrackedParameter<bool>("IsAlsoTrackerMuon", true);
167  nMatchesCut_ = iConfig.getUntrackedParameter<int>("NMatchesCut", 2); // At least 2 Chambers with matches
168 
169  // Electron quality cuts
171  eleMaxOver3x3_ = iConfig.getUntrackedParameter<double>("eleMaxOver3x3", 0.9);
172  // Ecal Barrel
173  dr03TkSumPtEB_ = iConfig.getUntrackedParameter<double>("dr03TkSumPtEB", 3.0);
174  dr04EcalRecHitSumEtEB_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEB", 4.0);
175  dr04HcalTowerSumEtEB_ = iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEB", 5.0);
176  hadronicOverEmEB_ = iConfig.getUntrackedParameter<double>("hadronicOverEmEB", 0.05);
177  deltaPhiSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEB", 0.2);
178  deltaEtaSuperClusterTrackAtVtxEB_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEB", 0.006);
179  sigmaIetaIetaEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEB", 0.01);
180  //spikes
181  sigmaIetaIetaSpikesEB_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEB", 0.002);
182 
183  // Ecal Endcap
184  dr03TkSumPtEC_ = iConfig.getUntrackedParameter<double>("dr03TkSumPtEC", 1.5);
185  dr04EcalRecHitSumEtEC_ = iConfig.getUntrackedParameter<double>("dr04EcalRecHitSumEtEC", 2.5);
186  dr04HcalTowerSumEtEC_ = iConfig.getUntrackedParameter<double>("dr04HcalTowerSumEtEC", 0.7);
187  hadronicOverEmEC_ = iConfig.getUntrackedParameter<double>("hadronicOverEmEC", 0.025);
188  deltaPhiSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaPhiSuperClusterTrackAtVtxEC", 0.2);
189  deltaEtaSuperClusterTrackAtVtxEC_ = iConfig.getUntrackedParameter<double>("deltaEtaSuperClusterTrackAtVtxEC", 0.006);
190  sigmaIetaIetaEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaEC", 0.03);
191  //spikes
192  sigmaIetaIetaSpikesEC_ = iConfig.getUntrackedParameter<double>("sigmaIetaIetaSpikesEC", 0.002);
193 
194  // Jet ID cuts
196  emEnergyFractionJet_ = iConfig.getUntrackedParameter<double>("emEnergyFractionJet",0.01);
197  fHPDJet_ = iConfig.getUntrackedParameter<double>("fHPDJet",0.98);
198  n90Jet_ = iConfig.getUntrackedParameter<int>("n90Jet",2);
199 
200  // Tau discriminators
202  tauDscrmtr1Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel1", std::string("shrinkingConePFTauDiscriminationByLeadingTrackFinding")));
203  tauDscrmtr2Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel2", std::string("shrinkingConePFTauDiscriminationByLeadingTrackPtCut")));
204  tauDscrmtr3Token = consumes <reco::PFTauDiscriminator> (iConfig.getUntrackedParameter("tauDscrmtrLabel3", std::string("shrinkingConePFTauDiscriminationByIsolation")));
205 
206  specialPaths_ = iConfig.getParameter<std::vector<std::string > >("SpecialPaths");
207 
208  pathsSummaryFolder_ = iConfig.getUntrackedParameter ("pathsSummaryFolder",std::string("HLT/FourVector/PathsSummary/"));
209  pathsSummaryHLTCorrelationsFolder_ = iConfig.getUntrackedParameter ("hltCorrelationsFolder",std::string("HLT/FourVector/PathsSummary/HLT Correlations/"));
210  pathsSummaryFilterCountsFolder_ = iConfig.getUntrackedParameter ("filterCountsFolder",std::string("HLT/FourVector/PathsSummary/Filters Counts/"));
211 
212  pathsSummaryHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("pathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/"));
213  // pathsIndividualHLTPathsPerLSFolder_ = iConfig.getUntrackedParameter ("individualPathsPerLSFolder",std::string("HLT/FourVector/PathsSummary/HLT LS/Paths/"));
214  // pathsSummaryHLTPathsPerBXFolder_ = iConfig.getUntrackedParameter ("individualPathsPerBXFolder",std::string("HLT/FourVector/PathsSummary/HLT BX/"));
215 
216  fLumiFlag = true;
217  ME_HLTAll_LS = NULL;
218  ME_HLT_BX = NULL;
219  ME_HLT_CUSTOM_BX = NULL;
220 
221  jetID = new reco::helper::JetIDHelper(iConfig.getParameter<ParameterSet>("JetIDParams"), consumesCollector());
222 
223  recHitsEBTag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEBTag",edm::InputTag("reducedEcalRecHitsEB"));
224  recHitsEETag_ = iConfig.getUntrackedParameter<edm::InputTag>("RecHitsEETag",edm::InputTag("reducedEcalRecHitsEE"));
225  recHitsEBToken = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEBTag_);
226  recHitsEEToken = consumes <edm::SortedCollection<EcalRecHit> > (recHitsEETag_);
227 
228 }
229 
230 
231 FourVectorHLTOffline::~FourVectorHLTOffline()
232 {
233 
234  // do anything here that needs to be done at desctruction time
235  // (e.g. close files, deallocate resources etc.)
236  delete fSelectedMuons;
237  delete fSelectedElectrons;
238  delete fSelectedPhotons;
239  delete fSelectedJets;
240  delete fSelectedMet;
241  delete fSelectedTaus;
242 
243 }
244 
245 
246 //
247 // member functions
248 //
249 
250 // ------------ method called to for each event ------------
251 void
252 FourVectorHLTOffline::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
253 {
254 
255  //if(! fLumiFlag ) return;
256 
257  using namespace edm;
258  using namespace trigger;
259  ++nev_;
260  LogDebug("FourVectorHLTOffline")<< " analyze...." ;
261 
262  edm::Handle<TriggerResults> triggerResults;
263  iEvent.getByToken(triggerResultsToken,triggerResults);
264  if(!triggerResults.isValid()) {
265  iEvent.getByToken(triggerResultsFUToken,triggerResults);
266  if(!triggerResults.isValid()) {
267  edm::LogInfo("FourVectorHLTOffline") << "TriggerResults not found, "
268  "skipping event";
269  return;
270  }
271  }
272  fTriggerResults = triggerResults;
273  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
274  int npath = triggerResults->size();
275 
276  iEvent.getByToken(triggerSummaryToken,fTriggerObj);
277  if(!fTriggerObj.isValid()) {
278 
279  iEvent.getByToken(triggerSummaryFUToken,fTriggerObj);
280 
281  if(!fTriggerObj.isValid()) {
282 
283  edm::LogInfo("FourVectorHLTOffline") << "TriggerEvent not found, " "skipping event";
284  return;
285 
286  }
287 
288  }
289 
290  // Beam spot
291  if (!iEvent.getByToken(beamSpotToken, fBeamSpotHandle)) {
292  edm::LogInfo("") << ">>> No beam spot found !!!";
293  }
294 
295  edm::Handle<reco::MuonCollection> muonHandle;
296  iEvent.getByToken(muonRecoCollectionToken,muonHandle);
297  if(!muonHandle.isValid())
298  edm::LogInfo("FourVectorHLTOffline") << "muonHandle not found, ";
299  selectMuons(muonHandle);
300 
301  edm::Handle<reco::GsfElectronCollection> gsfElectrons;
302  iEvent.getByToken(gsfElectronToken,gsfElectrons);
303  if(!gsfElectrons.isValid())
304  edm::LogInfo("FourVectorHLTOffline") << "gsfElectrons not found, ";
305  selectElectrons(iEvent, iSetup, gsfElectrons);
306 
307  //edm::Handle<reco::CaloTauCollection> tauHandle;
308  edm::Handle<reco::PFTauCollection> tauHandle;
309  iEvent.getByToken(tauProdToken,tauHandle);
310  if(!tauHandle.isValid())
311  edm::LogInfo("FourVectorHLTOffline") << "tauHandle not found, ";
312  //selectTaus(tauHandle);
313  selectTaus(iEvent);
314 
315  edm::Handle<reco::CaloJetCollection> jetHandle;
316  iEvent.getByToken(iC5calojetToken,jetHandle);
317  if(!jetHandle.isValid())
318  edm::LogInfo("FourVectorHLTOffline") << "jetHandle not found, ";
319  selectJets(iEvent,jetHandle);
320 
321  // Get b tag information
322  edm::Handle<reco::JetTagCollection> bTagIPHandle;
323  iEvent.getByToken(jlipBtagToken, bTagIPHandle);
324  if (!bTagIPHandle.isValid())
325  edm::LogInfo("FourVectorHLTOffline") << "mTagIPHandle trackCountingHighEffJetTags not found, ";
326 
327  // Get b tag information
328  edm::Handle<reco::JetTagCollection> bTagMuHandle;
329  iEvent.getByToken(softMuBtagToken, bTagMuHandle);
330  if (!bTagMuHandle.isValid())
331  edm::LogInfo("FourVectorHLTOffline") << "bTagMuHandle not found, ";
332 
333  edm::Handle<reco::CaloMETCollection> metHandle;
334  iEvent.getByToken(METToken,metHandle);
335  if(!metHandle.isValid())
336  edm::LogInfo("FourVectorHLTOffline") << "metHandle not found, ";
337  selectMet(metHandle);
338 
339  edm::Handle<reco::PhotonCollection> photonHandle;
340  iEvent.getByToken(photonToken,photonHandle);
341  if(!photonHandle.isValid())
342  edm::LogInfo("FourVectorHLTOffline") << "photonHandle not found, ";
343  selectPhotons(photonHandle);
344 
345  edm::Handle<reco::TrackCollection> trackHandle;
346  iEvent.getByToken(pixelTrackToken,trackHandle);
347  if(!trackHandle.isValid())
348  edm::LogInfo("FourVectorHLTOffline") << "trackHandle not found, ";
349 
350 
351  // ---------------------
352  // Monitors
353  // ---------------------
354 
355  // electron Monitor
356  objMonData<reco::GsfElectronCollection> eleMon;
357  //eleMon.setReco(gsfElectrons);
358  eleMon.setReco(fSelElectronsHandle);
359  eleMon.setRecoEle(fSelElectronsHandle);
360  eleMon.setLimits(electronEtaMax_, electronEtMin_, electronDRMatch_, electronL1DRMatch_, dRMax_, thresholdFactor_);
361 
362  eleMon.pushTriggerType(TriggerElectron);
363  eleMon.pushTriggerType(TriggerL1NoIsoEG);
364  eleMon.pushTriggerType(TriggerL1IsoEG);
365 
366  eleMon.pushL1TriggerType(TriggerL1NoIsoEG);
367  eleMon.pushL1TriggerType(TriggerL1IsoEG);
368 
369  // muon Monitor
370  objMonData<reco::MuonCollection> muoMon;
371  //muoMon.setReco(muonHandle);
372  muoMon.setReco(fSelMuonsHandle);
373  muoMon.setRecoMu(fSelMuonsHandle);
374  muoMon.setLimits(muonEtaMax_, muonEtMin_, muonDRMatch_, muonL1DRMatch_, dRMax_, thresholdFactor_);
375 
376  muoMon.pushTriggerType(TriggerMuon);
377  muoMon.pushTriggerType(TriggerL1Mu);
378 
379  muoMon.pushL1TriggerType(TriggerL1Mu);
380 
381  // tau Monitor
382  //objMonData<reco::CaloTauCollection> tauMon;
383  objMonData<reco::PFTauCollection> tauMon;
384  //tauMon.setReco(tauHandle);
385  tauMon.setReco(fSelTausHandle);
386  tauMon.setLimits(tauEtaMax_, tauEtMin_, tauDRMatch_, tauL1DRMatch_, dRMax_, thresholdFactor_);
387 
388  tauMon.pushTriggerType(TriggerTau);
389  tauMon.pushTriggerType(TriggerL1TauJet);
390 
391  tauMon.pushL1TriggerType(TriggerL1TauJet);
392  tauMon.pushL1TriggerType(TriggerL1ForJet);
393 
394  // photon Monitor
395  //objMonData<reco::PhotonCollection> phoMon;
396  //phoMon.setReco(photonHandle);
397  //phoMon.setReco(fSelPhotonsHandle);
398  // -----------------------------------------------
399  // Use RECO Electrons instead of RECO Photons
400  // to measure HLT_Photon efficiency
401  // -----------------------------------------------
402  objMonData<reco::GsfElectronCollection> phoMon;
403  phoMon.setReco(fSelElectronsHandle);
404  phoMon.setRecoEle(fSelElectronsHandle);
405 
406 
407  phoMon.setLimits(photonEtaMax_, photonEtMin_, photonDRMatch_, photonL1DRMatch_, dRMax_, thresholdFactor_);
408 
409  phoMon.pushTriggerType(TriggerPhoton);
410 
411  phoMon.pushL1TriggerType(TriggerL1NoIsoEG);
412  phoMon.pushL1TriggerType(TriggerL1IsoEG);
413 
414  // jet Monitor - NOTICE: we use genJets for MC
415  objMonData<reco::CaloJetCollection> jetMon;
416  //jetMon.setReco(jetHandle);
417  jetMon.setReco(fSelJetsHandle);
418  jetMon.setLimits(jetEtaMax_, jetEtMin_, jetDRMatch_, jetL1DRMatch_, dRMax_, thresholdFactor_);
419 
420  jetMon.pushTriggerType(TriggerJet);
421  jetMon.pushTriggerType(TriggerL1CenJet);
422  jetMon.pushTriggerType(TriggerL1ForJet);
423 
424  jetMon.pushL1TriggerType(TriggerL1CenJet);
425  jetMon.pushL1TriggerType(TriggerL1ForJet);
426  jetMon.pushL1TriggerType(TriggerL1TauJet);
427 
428  // bjet Monitor - NOTICE: we use genJets for MC
429  objMonData<reco::CaloJetCollection> btagIPMon; // CaloJet will not be used, this is only place holder
430  //btagIPMon.setReco(jetHandle);
431  btagIPMon.setRecoB(bTagIPHandle);
432  btagIPMon.setBJetsFlag(true);
433  btagIPMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);
434 
435  btagIPMon.pushTriggerType(TriggerBJet);
436  btagIPMon.pushTriggerType(TriggerJet);
437 
438  btagIPMon.pushL1TriggerType(TriggerL1CenJet);
439  btagIPMon.pushL1TriggerType(TriggerL1ForJet);
440  btagIPMon.pushL1TriggerType(TriggerL1TauJet);
441 
442  objMonData<reco::CaloJetCollection> btagMuMon; // CaloJet will not be used, this is only place holder
443  //btagMuMon.setReco(jetHandle);
444  btagMuMon.setRecoB(bTagMuHandle);
445  btagMuMon.setBJetsFlag(true);
446  btagMuMon.setLimits(bjetEtaMax_, bjetEtMin_, bjetDRMatch_, bjetL1DRMatch_, dRMax_, thresholdFactor_);
447 
448  btagMuMon.pushTriggerType(TriggerBJet);
449  btagMuMon.pushTriggerType(TriggerJet);
450 
451  btagMuMon.pushL1TriggerType(TriggerL1CenJet);
452  btagMuMon.pushL1TriggerType(TriggerL1ForJet);
453  btagMuMon.pushL1TriggerType(TriggerL1TauJet);
454 
455 
456  objMonData<reco::CaloJetCollection> btagMon; // Generic btagMon
457 
458  // met Monitor
459  objMonData<reco::CaloMETCollection> metMon;
460  //metMon.setReco(metHandle);
461  metMon.setReco(fSelMetHandle);
462  metMon.setLimits(metEtaMax_, metMin_, metDRMatch_, metL1DRMatch_, dRMax_, thresholdFactor_);
463 
464  metMon.pushTriggerType(TriggerMET);
465 
466  metMon.pushL1TriggerType(TriggerL1ETM);
467 
468  // tet Monitor
469  objMonData<reco::CaloMETCollection> tetMon;
470  //tetMon.setReco(metHandle);
471  tetMon.setReco(fSelMetHandle);
472  //tetMon.setLimits(tetEtaMax_=999., tetEtMin_=10, tetDRMatch_=999);
473  tetMon.setLimits(999., 10., 999., 999., dRMax_, thresholdFactor_);
474 
475  tetMon.pushTriggerType(TriggerTET);
476 
477  tetMon.pushL1TriggerType(TriggerL1ETT);
478 
479  // default Monitor
480  //objMonData<trigger::TriggerEvent> defMon;
481  objMonData<reco::CaloMETCollection> defMon;
482  defMon.setLimits(999., 3., 999., 999., dRMax_, thresholdFactor_);
483 
484  // vector to hold monitors
485  // interface is through virtual class BaseMonitor
486  std::vector<BaseMonitor*> monitors;
487 
488  //monitors.push_back(&jetMon);
489 
490  monitors.push_back(&muoMon);
491  monitors.push_back(&eleMon);
492  monitors.push_back(&tauMon);
493  monitors.push_back(&phoMon);
494  monitors.push_back(&jetMon);
495  monitors.push_back(&btagMon);
496  monitors.push_back(&metMon);
497  monitors.push_back(&tetMon);
498  /*
499  */
500 
501  // int bx = iEvent.bunchCrossing();
502  /*
503  // Fill HLTPassed_Correlation Matrix bin (i,j) = (Any,Any)
504  // --------------------------------------------------------
505  int anyBinNumber = ME_HLTPassPass_->getTH2F()->GetXaxis()->FindBin("HLT_Any");
506  // any triger accepted
507  if(triggerResults->accept()){
508 
509  ME_HLTPassPass_->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
510 
511  }
512  */
513 
514  fillHltMatrix(triggerNames);
515 
516 
517  // Loop over paths
518  // --------------------
519  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
520 
521  LogTrace("FourVectorHLTOffline") << " unique path " << v->getPath() << endl;
522 
523  unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());
524 
525  // path must be in the menu
526  if(pathByIndex >= fTriggerResults->size() ) continue;
527 
528 
529  // Fill HLTPassed Matrix and HLTPassFail Matrix
530  // --------------------------------------------------------
531 
532 // if(triggerResults->accept(pathByIndex)){
533 
534 // int pathBinNumber = ME_HLT_BX->getTH2F()->GetYaxis()->FindBin(v->getPath().c_str());
535 // ME_HLT_BX->Fill(bx,pathBinNumber-1);
536 
537 // //if(hasHLTPassed(fCustomBXPath,triggerNames)) {
538 
539 // //ME_HLT_CUSTOM_BX->Fill(bx,pathBinNumber-1);
540 
541 // //}
542 
543 // } // end if accept
544 
545  // Fill histogram of filter ocupancy for each HLT path
546  // ---------------------------------
547  unsigned int lastModule = triggerResults->index(pathByIndex);
548 
549  //check if hlt passed
550  bool hltPathPassed = triggerResults->accept(pathByIndex);
551 
552  //go through the list of filters
553  for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){
554 
555  int binNumber = v->getFiltersHisto()->getTH1()->GetXaxis()->FindBin(v->filtersAndIndices[filt].first.c_str());
556 
557  // if hlt path passed, then all the modules passed
558  // otherwise the module that issued the decision is the first fail
559  // this means that all modules before it passed
560  if(hltPathPassed) {
561 
562  v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
563  }
564  else if(v->filtersAndIndices[filt].second < lastModule){
565  v->getFiltersHisto()->Fill(binNumber-1);//binNumber1 = 0 = first filter
566  }
567 
568  } // end for filt
569 
570  } // end for diag paths
571 
572  // Main loop over paths
573  // --------------------
574  for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) {
575 
576  LogTrace("FourVectorHLTOffline") << " path " << v->getPath() << endl;
577 
578  if (v->getPath().find("BTagIP") != std::string::npos ) btagMon = btagIPMon;
579  else btagMon = btagMuMon;
580 
581  // set flag for muon monitor if L2-muon or L1-muon type path
582  if (v->getPath().find("L2Mu") != std::string::npos || v->getPath().find("L1Mu") != std::string::npos ) muoMon.setL2MuFlag(true);
583  else muoMon.setL2MuFlag(false);
584 
585  //if (v->getPath().find("HLT_Jet15U") == std::string::npos ) continue;
586  //if(*v != "HLT_L1Jet6U") continue;
587 
588  unsigned int pathByIndex = triggerNames.triggerIndex(v->getPath());
589 
590  if(pathByIndex >= fTriggerResults->size() ) continue;
591 
592  // did we pass the denomPath?
593  bool denompassed = false;
594 
595  for(int i = 0; i < npath; ++i) {
596 
597  if (triggerResults->accept(i) && triggerNames.triggerName(i).find(v->getDenomPath()) != std::string::npos && triggerNames.triggerName(i).find("HLT_Mult") == std::string::npos )
598  {
599  denompassed = true;
600  break;
601  }
602  }
603 
604  if (denompassed)
605  {
606 
607  //LogTrace("FourVectorHLTOffline") << " denominator path " << v->getPath() << endl;
608 
609 
610  // Get the righe monitor for this path
611  // -----------------------------------
612  BaseMonitor* mon = NULL;
613 
614  for(std::vector<BaseMonitor*>::iterator mit = monitors.begin(); mit!= monitors.end(); ++mit ) {
615 
616  if((*mit)->isTriggerType(v->getObjectType())) {
617 
618  mon = *mit;
619  break;
620 
621  }
622 
623  }
624 
625  // if cannot find moniotor for the path, go to next path
626  //if(!mon) continue;
627 
628  // if cannot find moniotor for the path, assign the default
629  if(!mon) mon = &defMon;
630 
631  // attach this path to mon
632  mon->setPath(v);
633 
634  // clear sets of matched objects
635  mon->clearSets();
636 
637  v->getObjectType();
638 
639  // monitor offline (RECO objects)
641  mon->monitorOffline();
642 
643  // monitor L1 (only if L1 passed and can find GTSeed)
645  bool l1accept = false;
646  edm::InputTag l1testTag(v->getl1Path(),"",processname_);
647  const int l1Index = fTriggerObj->filterIndex(l1testTag);
648 
649  if ( l1Index >= fTriggerObj->sizeFilters() ) {
650 
651  LogTrace("FourVectorHLTOffline") << "Cannot find L1GTSeed of the path " << v->getPath() << endl;
652  LogTrace("FourVectorHLTOffline") << "\t L1GTSeed name = " << v->getl1Path() << endl;
653  LogTrace("FourVectorHLTOffline") << "\t tried with tag " << l1testTag << endl;
654  LogTrace("FourVectorHLTOffline") <<"\t module index = "<< l1Index << endl;
655 
656  }
657 
658  // monitor L1 object
659  mon->monitorL1(l1Index, this);
660 
661  // fill matching b/w Offline and L1 objects
662  mon->fillL1Match(this);
663 
664  // monitor Online (only if HLT passed)
666  bool numpassed = false;
667 
668  // did we pass the numerator path, i.e. HLT path?
669  for(int i = 0; i < npath; ++i) {
670 
671  if ( triggerResults->accept(i) && triggerNames.triggerName(i) == v->getPath() ) numpassed = true;
672 
673  }
674 
675  if (!numpassed) continue;
676 
677  if (!l1accept) {
678 
679  LogDebug("FourVectorHLTOffline")
680  << "This should not happen. HLT passed, but L1 Seed not passed for hlt path "<< endl
681  << "HLT path: " << v->getPath() << "\t HLTLevel1GTSeed: " << v->getl1Path();
682 
683  }
684 
685  // fill scaler histograms
686  edm::InputTag filterTag = v->getTag();
687 
688  // loop through indices and see if the filter is
689  // on the list of filters used by this path
690  //----------------------------------------------
691  if (v->getLabel() == "dummy"){
692  const vector<string> filterLabels = hltConfig_.moduleLabels(v->getPath());
693 
694  //loop over labels
695  for (vector<string>::const_iterator labelIter= filterLabels.begin(); labelIter!=filterLabels.end(); labelIter++) {
696 
697  edm::InputTag testTag(*labelIter,"",processname_);
698 
699  int testindex = fTriggerObj->filterIndex(testTag);
700 
701  // last match wins...
702  if ( !(testindex >= fTriggerObj->sizeFilters()) ) {
703 
704  filterTag = testTag;
705  v->setLabel(*labelIter);}
706 
707  }
708 
709  } // end for
710 
711  const int hltIndex = fTriggerObj->filterIndex(filterTag);
712  if ( hltIndex >= fTriggerObj->sizeFilters() ) {
713 
714  LogTrace("FourVectorHLTOffline") << "WTF no index "<< hltIndex << " of that name " << filterTag << endl;
715  continue; // not in this event
716 
717  }
718 
719  mon->monitorOnline(hltIndex, l1Index, this);
720 
721  mon->fillOnlineMatch(l1Index, this);
722 
723  } //denompassed
724 
725 
726  } //pathinfo loop
727 
728 }
729 
730 
731 
732 // -- method called once each job just before starting event loop --------
733 void
734 FourVectorHLTOffline::beginJob()
735 {
736  nev_ = 0;
737  DQMStore *dbe = 0;
738  dbe = Service<DQMStore>().operator->();
739 
740  if (dbe) {
741  dbe->setCurrentFolder(dirname_);
742  dbe->rmdir(dirname_);
743  }
744 
745 
746  if (dbe) {
747  dbe->setCurrentFolder(dirname_);
748  }
749 }
750 
751 // - method called once each job just after ending the event loop ------------
752 void
753 FourVectorHLTOffline::endJob()
754 {
755  LogInfo("FourVectorHLTOffline") << "analyzed " << nev_ << " events";
756  return;
757 }
758 
759 
760 // BeginRun
761 void FourVectorHLTOffline::beginRun(const edm::Run& run, const edm::EventSetup& c)
762 {
763 
764  LogDebug("FourVectorHLTOffline") << "beginRun, run " << run.id();
765 
766  if(fIsSetup) return;
767 
768  // HLT config does not change within runs!
769  bool changed=false;
770 
771  if (!hltConfig_.init(run, c, processname_, changed)) {
772 
773  processname_ = "FU";
774 
775  if (!hltConfig_.init(run, c, processname_, changed)){
776 
777  LogDebug("FourVectorHLTOffline") << "HLTConfigProvider failed to initialize.";
778 
779  }
780 
781  // check if trigger name in (new) config
782  // cout << "Available TriggerNames are: " << endl;
783  // hltConfig_.dump("Triggers");
784  }
785 
786  if (1) {
787 
788  DQMStore *dbe = 0;
789  dbe = Service<DQMStore>().operator->();
790 
791  if (dbe) {
792  dbe->setCurrentFolder(dirname_);
793  }
794 
795  const unsigned int n(hltConfig_.size());
796 
797  if (plotAll_){
798 
799  for (unsigned int j=0; j!=n; ++j) {
800 
801  std::string pathname = hltConfig_.triggerName(j);
802 
803  string l1pathname = getL1ConditionModuleName(pathname);
804 
805  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
806 
807  int objectType = getTriggerTypeParsePathName(pathname);
808 
809  for (unsigned int i=0; i!=n; ++i) {
810 
811  std::string denompathname = hltConfig_.triggerName(i);
812  int denomobjectType = getTriggerTypeParsePathName(denompathname);
813 
814 
815 
816  std::string filtername("dummy");
817  float ptMin = 0.0;
818  float ptMax = 100.0;
819  if (plotAll_ && denomobjectType == objectType && objectType != 0) {
820 
821  int hltThreshold = getHltThresholdFromName(pathname);
822  int l1Threshold = getHltThresholdFromName(l1pathname);
823  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
824 
825  }
826 
827  }
828  }
829 
830  } // end if plotAll
831  else {
832 
833  // plot all diagonal combinations plus any other specified pairs
834  for (unsigned int i=0; i!=n; ++i) {
835 
836  std::string denompathname = "";
837  std::string pathname = hltConfig_.triggerName(i);
838  //parse pathname to guess object type
839  int objectType = getTriggerTypeParsePathName(pathname);
840 
841  string l1pathname = getL1ConditionModuleName(pathname);
842  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
843 
844  std::string filtername("dummy");
845  float ptMin = 0.0;
846  float ptMax = 100.0;
847 
848  if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
849  if (objectType == trigger::TriggerElectron) ptMax = 300.0;
850  if (objectType == trigger::TriggerMuon) ptMax = 300.0;
851  if (objectType == trigger::TriggerTau) ptMax = 300.0;
852  if (objectType == trigger::TriggerJet) ptMax = 700.0;
853  if (objectType == trigger::TriggerBJet) ptMax = 300.0;
854  if (objectType == trigger::TriggerMET) ptMax = 500.0;
855  if (objectType == trigger::TriggerTET) ptMax = 1000.0;
856  if (objectType == trigger::TriggerTrack) ptMax = 100.0;
857 
858  // keep track of all paths, except for FinalPath
859  if (objectType != -1 && pathname.find("FinalPath") == std::string::npos){
860 
861  int hltThreshold = getHltThresholdFromName(pathname);
862  int l1Threshold = getHltThresholdFromName(l1pathname);
863 
864  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
865 
866  hltPathsDiagonal_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
867 
868  }
869 
870  } // end for i
871 
872  // now loop over denom/num path pairs specified in cfg,
873  // recording the off-diagonal ones
874  for (std::vector<std::pair<std::string, std::string> >::iterator custompathnamepair = custompathnamepairs_.begin(); custompathnamepair != custompathnamepairs_.end(); ++custompathnamepair) {
875 
876  std::string numpathname = custompathnamepair->first;
877  std::string denompathname = custompathnamepair->second;
878 
879  if (numpathname != denompathname) {
880 
881  // check that denominator exists
882  bool founddenominator = false;
883  for (unsigned int k=0; k!=n; ++k) {
884 
885  string n_pathname = hltConfig_.triggerName(k);
886 
887  if (n_pathname.find(denompathname) != std::string::npos) {
888 
889  LogDebug("FourVectorHLTOffline") << "denompathname is selected to be = " << n_pathname << endl;;
890  founddenominator = true;
891 
892  break;
893 
894  }
895  }
896 
897  if (!founddenominator) {
898 
899  edm::LogInfo("FourVectorHLTOffline") << "denompathname not found, go to the next pair numearator-denominator" << endl;
900 
901  // go to the next pair
902  continue;
903 
904  }
905 
906  // check that numerator exists
907  for (unsigned int j=0; j!=n; ++j) {
908  bool foundnumerator = false;
909 
910  string pathname = hltConfig_.triggerName(j);
911 
912  LogDebug("FourVectorHLTOffline") << "check if path " << pathname << " is numpathname = " << numpathname << endl;
913  if (hltConfig_.triggerName(j).find(numpathname)!= std::string::npos) {
914 
915  LogDebug("FourVectorHLTOffline") << "pathname is selected to be = " << denompathname << endl;;
916  foundnumerator = true;
917 
918  }
919 
920 
921  if (!foundnumerator) {
922 
923  edm::LogInfo("FourVectorHLTOffline") << "pathname not found, ignoring " << pathname;
924  continue;
925 
926  }
927 
928  string l1pathname = getL1ConditionModuleName(pathname);
929  int l1ModuleIndex = hltConfig_.moduleIndex(pathname, l1pathname);
930  int objectType = getTriggerTypeParsePathName(pathname);
931 
932  std::string filtername("dummy");
933  float ptMin = 0.0;
934  float ptMax = 100.0;
935 
936  if (objectType == trigger::TriggerPhoton) ptMax = 400.0;
937  if (objectType == trigger::TriggerElectron) ptMax = 300.0;
938  if (objectType == trigger::TriggerMuon) ptMax = 300.0;
939  if (objectType == trigger::TriggerTau) ptMax = 300.0;
940  if (objectType == trigger::TriggerJet) ptMax = 700.0;
941  if (objectType == trigger::TriggerBJet) ptMax = 300.0;
942  if (objectType == trigger::TriggerMET) ptMax = 500.0;
943  if (objectType == trigger::TriggerTET) ptMax = 1000.0;
944  if (objectType == trigger::TriggerTrack) ptMax = 100.0;
945 
946  // monitor regardless of the objectType of the path
947  if (objectType != 0) {
948  int hltThreshold = getHltThresholdFromName(pathname);
949  int l1Threshold = getHltThresholdFromName(l1pathname);
950  hltPaths_.push_back(PathInfo(denompathname, pathname, l1pathname, l1ModuleIndex, filtername, processname_, objectType, ptMin, ptMax, hltThreshold, l1Threshold));
951 
952  }
953 
954  } // end for j, loop over paths
955 
956  } // end if not same num and denominator
957 
958  } // end for pair
959 
960  } // end else
961 
962 
963  vector<string> allPaths;
964  // fill vectors of Muon, Egamma, JetMet, Rest, and Special paths
965 
966  int vi = 0;
967 
968  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
969 
970  std::string pathName = removeVersions(v->getPath());
971  //int objectType = v->getObjectType();
972 
973  vector<int> tempCount(5,0);
974 
975  fPathTempCountPair.push_back(make_pair(pathName,0));
976  fPathBxTempCountPair.push_back(make_pair(pathName,tempCount));
977 
978  allPaths.push_back(pathName);
979 
980  }
981 
982  fPathTempCountPair.push_back(make_pair("HLT_Any",0));
983 
984  fGroupName.push_back("All");
985 
986  for(unsigned int g=0; g<fGroupName.size(); g++) {
987 
988  //fGroupTempCountPair.push_back(make_pair(fGroupName[g],0));
989  //fGroupL1TempCountPair.push_back(make_pair(fGroupName[g],0));
990 
991  }
992 
993  dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
994 
995  fGroupNamePathsPair.push_back(make_pair("All",allPaths));
996 
998  vector<string> datasetNames = hltConfig_.datasetNames() ;
999  for (unsigned int i=0;i<datasetNames.size();i++) {
1000 
1001  vector<string> datasetPaths = hltConfig_.datasetContent(datasetNames[i]);
1002  fGroupNamePathsPair.push_back(make_pair(datasetNames[i],datasetPaths));
1003 
1004  }
1005 
1006 
1007  for (unsigned int g=0;g<fGroupNamePathsPair.size();g++) {
1008 
1009  fGroupTempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
1010  fGroupL1TempCountPair.push_back(make_pair(fGroupNamePathsPair[g].first,0));
1011  setupHltMatrix(fGroupNamePathsPair[g].first,fGroupNamePathsPair[g].second);
1012 
1013  }
1014 
1015  // setupHltLsPlots();
1016  // setupHltBxPlots();
1017 
1018  vi = 0;
1019 
1020  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
1021  vi++;
1022 
1023  // -------------------------
1024  //
1025  // Filters for each path
1026  //
1027  // -------------------------
1028 
1029  // get all modules in this HLT path
1030  std::string pathName = removeVersions(v->getPath());
1031  vector<string> moduleNames = hltConfig_.moduleLabels(v->getPath());
1032 
1033  int numModule = 0;
1034  string moduleName, moduleType, moduleEDMType;
1035  unsigned int moduleIndex;
1036 
1037  //print module name
1038  vector<string>::const_iterator iDumpModName;
1039  for (iDumpModName = moduleNames.begin();iDumpModName != moduleNames.end();iDumpModName++) {
1040 
1041  moduleName = *iDumpModName;
1042  moduleType = hltConfig_.moduleType(moduleName);
1043  moduleEDMType = hltConfig_.moduleEDMType(moduleName);
1044  moduleIndex = hltConfig_.moduleIndex(v->getPath(), moduleName);
1045 
1046  LogTrace ("FourVectorHLTOffline") << "Module " << numModule
1047  << " is called " << moduleName
1048  << " , type = " << moduleType
1049  << " , EDMtype = " << moduleEDMType
1050  << " , index = " << moduleIndex
1051  << endl;
1052 
1053  numModule++;
1054 
1055  if((moduleType.find("Filter") != string::npos && moduleType.find("HLTTriggerTypeFilter") == string::npos ) ||
1056  (moduleType.find("Associator") != string::npos) ||
1057  (moduleType.find("HLTLevel1GTSeed") != string::npos) ||
1058  (moduleType.find("HLTGlobalSumsCaloMET") != string::npos) ||
1059  (moduleType.find("HLTPrescaler") != string::npos) ||
1060  (moduleEDMType.find("EDFilter") != string::npos) ) {
1061 
1062  //std::pair<std::string, int> filterIndexPair;
1063  //filterIndexPair.first = moduleName;
1064  //filterIndexPair.second = moduleIndex;
1065  //v->filtersAndIndices.push_back(filterIndexPair);
1066  v->filtersAndIndices.push_back(make_pair(moduleName,moduleIndex));
1067 
1068  }
1069 
1070 
1071  }//end for modulesName
1072 
1073  dbe_->setCurrentFolder(pathsSummaryFilterCountsFolder_.c_str());
1074 
1075  //int nbin_sub = 5;
1076  int nbin_sub = v->filtersAndIndices.size()+2;
1077 
1078 
1079  //TString thisPath = v->getPath();
1080 
1081  // count plots for subfilter
1082  MonitorElement* filters = dbe_->book1D("Filters_" + pathName,
1083  "Filters_" + pathName,
1084  nbin_sub+1, -0.5, 0.5+(double)nbin_sub);
1085 
1086  for(unsigned int filt = 0; filt < v->filtersAndIndices.size(); filt++){
1087 
1088  if (filters)
1089  filters->setBinLabel(filt+1, (v->filtersAndIndices[filt]).first);
1090 
1091  }
1092 
1093  // bjk here
1094 // // book Count vs LS
1095 // dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
1096 // MonitorElement* tempME = dbe_->book1D(v->getPath() + "_count_per_LS",
1097 // pathName + " count per LS",
1098 // nLS_, 0,nLS_);
1099 // tempME->setAxisTitle("Luminosity Section");
1100 
1101  v->setFilterHistos(filters);
1102 
1103  } // end for paths
1104 
1105  // now set up all of the histos for each path-denom
1106  for(PathInfoCollection::iterator v = hltPaths_.begin(); v!= hltPaths_.end(); ++v ) {
1107 
1108  MonitorElement *NOn=0;
1109  MonitorElement *onEtOn=0;
1110  MonitorElement *onOneOverEtOn=0;
1111  MonitorElement *onEtavsonPhiOn=0;
1112  MonitorElement *NOff=0;
1113  MonitorElement *offEtOff=0;
1114  MonitorElement *offEtavsoffPhiOff=0;
1115  MonitorElement *NL1=0;
1116  MonitorElement *l1EtL1=0;
1117  MonitorElement *l1Etavsl1PhiL1=0;
1118  MonitorElement *NL1On=0;
1119  MonitorElement *l1EtL1On=0;
1120  MonitorElement *l1Etavsl1PhiL1On=0;
1121  MonitorElement *NL1Off=0;
1122  MonitorElement *offEtL1Off=0;
1123  MonitorElement *offEtavsoffPhiL1Off=0;
1124  MonitorElement *NOnOff=0;
1125  MonitorElement *offEtOnOff=0;
1126  MonitorElement *offEtavsoffPhiOnOff=0;
1127  MonitorElement *NL1OnUM=0;
1128  MonitorElement *l1EtL1OnUM=0;
1129  MonitorElement *l1Etavsl1PhiL1OnUM=0;
1130  MonitorElement *NL1OffUM=0;
1131  MonitorElement *offEtL1OffUM=0;
1132  MonitorElement *offEtavsoffPhiL1OffUM=0;
1133  MonitorElement *NOnOffUM=0;
1134  MonitorElement *offEtOnOffUM=0;
1135  MonitorElement *offEtavsoffPhiOnOffUM=0;
1136  MonitorElement *offDRL1Off=0;
1137  MonitorElement *offDROnOff=0;
1138  MonitorElement *l1DRL1On=0;
1139 
1140  std::string pathName = removeVersions(v->getPath());
1141  std::string labelname("dummy");
1142  labelname = pathName + "_wrt_" + v->getDenomPath();
1143 
1144  std::string histoname(labelname+"_NOn");
1145  std::string title(labelname+" N online");
1146  double histEtaMax = 2.5;
1147 
1148  if (v->getObjectType() == trigger::TriggerMuon || v->getObjectType() == trigger::TriggerL1Mu) {
1149 
1150  histEtaMax = muonEtaMax_;
1151 
1152  }
1153  else if (v->getObjectType() == trigger::TriggerElectron || v->getObjectType() == trigger::TriggerL1NoIsoEG || v->getObjectType() == trigger::TriggerL1IsoEG )
1154  {
1155  histEtaMax = electronEtaMax_;
1156  }
1157  else if (v->getObjectType() == trigger::TriggerTau || v->getObjectType() == trigger::TriggerL1TauJet )
1158  {
1159  histEtaMax = tauEtaMax_;
1160  }
1161  else if (v->getObjectType() == trigger::TriggerJet || v->getObjectType() == trigger::TriggerL1CenJet || v->getObjectType() == trigger::TriggerL1ForJet )
1162  {
1163  histEtaMax = jetEtaMax_;
1164  }
1165  else if (v->getObjectType() == trigger::TriggerBJet)
1166  {
1167  histEtaMax = bjetEtaMax_;
1168  }
1169  else if (v->getObjectType() == trigger::TriggerMET || v->getObjectType() == trigger::TriggerL1ETM )
1170  {
1171  histEtaMax = metEtaMax_;
1172  }
1173  else if (v->getObjectType() == trigger::TriggerPhoton)
1174  {
1175  histEtaMax = photonEtaMax_;
1176  }
1177  else if (v->getObjectType() == trigger::TriggerTrack)
1178  {
1179  histEtaMax = trackEtaMax_;
1180  }
1181 
1182  TString pathfolder = dirname_ + TString("/") + pathName;
1183  dbe_->setCurrentFolder(pathfolder.Data());
1184 
1185  NOn = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1186 
1187 
1188  histoname = labelname+"_NOff";
1189  title = labelname+" N Off";
1190  NOff = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1191 
1192  histoname = labelname+"_NL1";
1193  title = labelname+" N L1";
1194  NL1 = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1195 
1196  histoname = labelname+"_NL1On";
1197  title = labelname+" N L1On";
1198  NL1On = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1199 
1200  histoname = labelname+"_NL1Off";
1201  title = labelname+" N L1Off";
1202  NL1Off = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1203 
1204  histoname = labelname+"_NOnOff";
1205  title = labelname+" N OnOff";
1206  NOnOff = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1207 
1208  histoname = labelname+"_onEtOn";
1209  title = labelname+" onE_t online";
1210  onEtOn = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1211 
1212  histoname = labelname+"_onOneOverEtOn";
1213  title = labelname+" 1 / onE_t online";
1214  onOneOverEtOn = dbe->book1D(histoname.c_str(), title.c_str(),nBinsOneOverEt_, 0, 0.1);
1215  onOneOverEtOn->setAxisTitle("HLT 1/Et [1/GeV]");
1216 
1217  histoname = labelname+"_offEtOff";
1218  title = labelname+" offE_t offline";
1219  offEtOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1220 
1221  histoname = labelname+"_l1EtL1";
1222  title = labelname+" l1E_t L1";
1223  l1EtL1 = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1224 
1225  histoname = labelname+"_onEtaonPhiOn";
1226  title = labelname+" on#eta vs on#phi online";
1227  onEtavsonPhiOn = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1228 
1229  histoname = labelname+"_offEtaoffPhiOff";
1230  title = labelname+" off#eta vs off#phi offline";
1231  offEtavsoffPhiOff = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1232 
1233  histoname = labelname+"_l1Etal1PhiL1";
1234  title = labelname+" l1#eta vs l1#phi L1";
1235  l1Etavsl1PhiL1 = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1236 
1237  histoname = labelname+"_l1EtL1On";
1238  title = labelname+" l1E_t L1+online";
1239  l1EtL1On = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1240 
1241  histoname = labelname+"_offEtL1Off";
1242  title = labelname+" offE_t L1+offline";
1243  offEtL1Off = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1244 
1245  histoname = labelname+"_offEtOnOff";
1246  title = labelname+" offE_t online+offline";
1247  offEtOnOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1248 
1249  histoname = labelname+"_l1Etal1PhiL1On";
1250  title = labelname+" l1#eta vs l1#phi L1+online";
1251  l1Etavsl1PhiL1On = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1252 
1253  histoname = labelname+"_offEtaoffPhiL1Off";
1254  title = labelname+" off#eta vs off#phi L1+offline";
1255  offEtavsoffPhiL1Off = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1256 
1257  histoname = labelname+"_offEtaoffPhiOnOff";
1258  title = labelname+" off#eta vs off#phi online+offline";
1259  offEtavsoffPhiOnOff = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1260 
1261  if (useUM) {
1262 
1263  histoname = labelname+"_NL1OnUM";
1264  title = labelname+" N L1OnUM";
1265  NL1OnUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1266 
1267  histoname = labelname+"_NL1OffUM";
1268  title = labelname+" N L1OffUM";
1269  NL1OffUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1270 
1271  histoname = labelname+"_NOnOffUM";
1272  title = labelname+" N OnOffUM";
1273  NOnOffUM = dbe->book1D(histoname.c_str(), title.c_str(),10, 0.5, 10.5);
1274 
1275  histoname = labelname+"_l1EtL1OnUM";
1276  title = labelname+" l1E_t L1+onlineUM";
1277  l1EtL1OnUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1278 
1279  histoname = labelname+"_offEtL1OffUM";
1280  title = labelname+" offE_t L1+offlineUM";
1281  offEtL1OffUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1282 
1283  histoname = labelname+"_offEtOnOffUM";
1284  title = labelname+" offE_t online+offlineUM";
1285  offEtOnOffUM = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, v->getPtMin(), v->getPtMax());
1286 
1287  histoname = labelname+"_l1Etal1PhiL1OnUM";
1288  title = labelname+" l1#eta vs l1#phi L1+onlineUM";
1289  l1Etavsl1PhiL1OnUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1290 
1291  histoname = labelname+"_offEtaoffPhiL1OffUM";
1292  title = labelname+" off#eta vs off#phi L1+offlineUM";
1293  offEtavsoffPhiL1OffUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1294 
1295  histoname = labelname+"_offEtaoffPhiOnOffUM";
1296  title = labelname+" off#eta vs off#phi online+offlineUM";
1297  offEtavsoffPhiOnOffUM = dbe->book2D(histoname.c_str(), title.c_str(), nBins2D_,-histEtaMax,histEtaMax, nBins2D_,-TMath::Pi(), TMath::Pi());
1298 
1299  }
1300 
1301  histoname = labelname+"_l1DRL1On";
1302  title = labelname+" l1DR L1+online";
1303  l1DRL1On = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1304 
1305  histoname = labelname+"_offDRL1Off";
1306  title = labelname+" offDR L1+offline";
1307  offDRL1Off = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1308 
1309  histoname = labelname+"_offDROnOff";
1310  title = labelname+" offDR online+offline";
1311  offDROnOff = dbe->book1D(histoname.c_str(), title.c_str(),nBins_, 0, dRMax_);
1312 
1313 
1314  v->setHistos( NOn, onEtOn, onOneOverEtOn, onEtavsonPhiOn, NOff, offEtOff, offEtavsoffPhiOff, NL1, l1EtL1, l1Etavsl1PhiL1, NL1On, l1EtL1On, l1Etavsl1PhiL1On, NL1Off, offEtL1Off, offEtavsoffPhiL1Off, NOnOff, offEtOnOff, offEtavsoffPhiOnOff, NL1OnUM, l1EtL1OnUM, l1Etavsl1PhiL1OnUM, NL1OffUM, offEtL1OffUM, offEtavsoffPhiL1OffUM, NOnOffUM, offEtOnOffUM, offEtavsoffPhiOnOffUM, offDRL1Off, offDROnOff, l1DRL1On
1315 );
1316 
1317  } // end for hltPath
1318 
1319  // bjk here
1320 // // HLT_Any
1321 // // book Count vs LS
1322 // dbe_->setCurrentFolder(pathsIndividualHLTPathsPerLSFolder_.c_str());
1323 // MonitorElement* tempME = dbe_->book1D("HLT_Any_count_per_LS",
1324 // "HLT_Any count per LS",
1325 // nLS_, 0,nLS_);
1326 // tempME->setAxisTitle("Luminosity Section");
1327 
1328  } // end if(1) dummy
1329 
1330  if(!doCombineRuns_) fIsSetup = true;
1331 
1332  return;
1333 
1334 }
1335 
1337 void FourVectorHLTOffline::endRun(const edm::Run& run, const edm::EventSetup& c)
1338 {
1339 
1340  LogDebug("FourVectorHLTOffline") << "endRun, run " << run.id();
1341 
1342 }
1343 
1345 void FourVectorHLTOffline::cleanDRMatchSet(mmset& tempSet)
1346 {
1347 
1348  LogDebug("FourVectorHLTOffline") << "cleanDRMatchSet(mmset& tempSet) " << "size of the set (before CLEANING) = " << tempSet.size() << " maps." << endl;
1349 
1350  if(tempSet.size() < 2) return;
1351 
1352  if(tempSet.size() > 10) {
1353 
1354  LogDebug("FourVectorHLTOffline") << "size of the set is too large. It will be truncated to 10." << endl;
1355  mmset::iterator it = tempSet.begin();
1356  for (int i=0;i<10;i++) { it++; }
1357  tempSet.erase( it, tempSet.end());
1358  LogDebug("FourVectorHLTOffline") << "size of the set is now = " << tempSet.size() << " maps." << endl;
1359 
1360  }
1361 
1362  bool cleanedOneMap = false;
1363 
1364  // cleaning needed if the set has at least two maps
1365 
1366  while(! cleanedOneMap && tempSet.size() > 1) {
1367 
1368  cleanedOneMap=false;
1369 
1370  //LogTrace("FourVectorHLTOffline") << "cleaning: size of the set = " << tempSet.size() << " maps." << endl;
1371 
1372  int imap = 0;
1373  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {
1374 
1375  fimmap tempMap_j = *setIter_i;
1376 
1377  //LogTrace("FourVectorHLTOffline") << " map " << imap << endl;
1378  //LogTrace("FourVectorHLTOffline") << " --------" << endl;
1379 
1380  for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {
1381 
1382  //LogTrace("FourVectorHLTOffline") << " " << (*it).first << " : " << (*it).second << endl;
1383 
1384  }
1385 
1386  imap++;
1387 
1388  }
1389 
1390  // loop i
1391  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ ) {
1392 
1393  fimmap tempMap_i = *setIter_i;
1394  fimmap::iterator it = tempMap_i.begin();
1395  int topValue = (*it).second;
1396  //LogTrace("FourVectorHLTOffline") << " topValue = " << topValue << endl;
1397 
1398 
1399  mmset::iterator tempIter_i = setIter_i;
1400 
1401  // from all the other maps, clean entries that have mapped value "topValue"
1402  // loop j
1403  mmset::iterator setIter_j = ++tempIter_i;
1404  while ( setIter_j != tempSet.end( ) ) {
1405 
1406  fimmap tempMap_j = *setIter_j;
1407  //LogTrace("FourVectorHLTOffline") << " size of the map = " << tempMap_j.size() << endl;
1408 
1409  fimmap::iterator it = tempMap_j.begin();
1410  while ( it != tempMap_j.end() ) {
1411 
1412  if(topValue == (*it).second) {
1413 
1414  //LogTrace("FourVectorHLTOffline") << " Ridding map of a doubly-matched object." << endl;
1415  fimmap::iterator tempIt = it;
1416  ++it; //no longer points to item that is going away
1417  tempMap_j.erase(tempIt);
1418  cleanedOneMap = true;
1419 
1420  } else {
1421  ++it;
1422  } // end if
1423 
1424  } //end while
1425 
1426  if(cleanedOneMap) {
1427 
1428  //remove the old map from the set
1429  mmset::iterator tempIt = setIter_j;
1430  ++setIter_j; //no longer points to item that is going away
1431  tempSet.erase(tempIt);
1432 
1433  // insert in the set the new map if it is not an empty map
1434  if(! tempMap_j.empty()) tempSet.insert(tempMap_j);
1435 
1436  break; // break from loop j
1437 
1438  } else {
1439  ++setIter_j;
1440  } // end if
1441 
1442 
1443  }// end while j
1444 
1445  if(cleanedOneMap) break; // break from loop i
1446 
1447  } // end loop i
1448 
1449  if(cleanedOneMap) {
1450 
1451  // continue cleaning (in while loop)
1452  // but reset flag first
1453  cleanedOneMap=false;
1454  continue;
1455 
1456  }
1457  else {
1458 
1459  // finished cleaing (break from while loop)
1460  break;
1461 
1462  }
1463 
1464  } // end while
1465 
1466  //LogTrace("FourVectorHLTOffline") << "cleaned: size of the set = " << tempSet.size() << " maps." << endl;
1467  int jmap = 0;
1468 
1469  for ( mmset::iterator setIter_i = tempSet.begin( ); setIter_i != tempSet.end( ); setIter_i++ )
1470  {
1471 
1472  fimmap tempMap_j = *setIter_i;
1473 
1474  //LogTrace("FourVectorHLTOffline") << " map " << jmap << endl;
1475  //LogTrace("FourVectorHLTOffline") << " --------" << endl;
1476 
1477  for (fimmap::iterator it = tempMap_j.begin(); it != tempMap_j.end(); ++it) {
1478 
1479  //LogTrace("FourVectorHLTOffline") << " " << (*it).first << " : " << (*it).second << endl;
1480 
1481  }
1482 
1483  jmap++;
1484 
1485  } // end for
1486 
1487  return;
1488 
1489 }
1490 
1491 void FourVectorHLTOffline::setupHltMatrix(const std::string& label, vector<std::string>& paths) {
1492 
1493  //string groupLabelAny = "HLT_"+label+"_Any";
1494  //paths.push_back(groupLabelAny.c_str());
1495  paths.push_back("HLT_"+label+"_L1_Any");
1496  paths.push_back("HLT_"+label+"_Any");
1497  paths.push_back("HLT_Any");
1498 
1499  string h_name;
1500  string h_title;
1501 
1502  dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
1503 
1504  MonitorElement* ME = 0;
1505  MonitorElement* ME_Any = 0;
1506  MonitorElement* ME_Normalized = 0;
1507  MonitorElement* ME_Normalized_Any = 0;
1508 
1509  if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
1510  h_name= "HLT_"+label+"_PassPass";
1511  h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass)";
1512  ME = dbe_->book2D(h_name.c_str(), h_title.c_str(),
1513  paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);
1514 
1515  h_name= "HLT_"+label+"_Pass_Any";
1516  h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
1517  ME_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
1518  paths.size(), -0.5, paths.size()-0.5);
1519 
1520  dbe_->setCurrentFolder(pathsSummaryHLTCorrelationsFolder_.c_str());
1521  h_name= "HLT_"+label+"_PassPass_Normalized";
1522  h_title = "HLT_"+label+"_PassPass (x=Pass, y=Pass) normalized to xBin=Pass";
1523  ME_Normalized = dbe_->book2D(h_name.c_str(), h_title.c_str(),
1524  paths.size(), -0.5, paths.size()-0.5, paths.size(), -0.5, paths.size()-0.5);
1525  h_name= "HLT_"+label+"_Pass_Normalized_Any";
1526  h_title = "HLT_"+label+"_Pass (x=Pass, Any=Pass) normalized to HLT_Any Pass";
1527  ME_Normalized_Any = dbe_->book1D(h_name.c_str(), h_title.c_str(),
1528  paths.size(), -0.5, paths.size()-0.5);
1529  }
1530 
1531  if (label != "All" && label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor")
1532  {
1533  dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_ + label);
1534  h_name= "HLT_"+label+"_Total_LS";
1535  h_title = label+" HLT paths total count combined per LS ";
1536  MonitorElement* ME_Total_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
1537  ME_Total_LS->setAxisTitle("LS");
1538 
1539 // for(std::vector<std::string>::iterator i = paths.begin(), e=paths.end(); i!=e; ++i)
1540 // {
1541 // h_name= "HLT_"+removeVersions(*i)+"_LS";
1542 // h_title = removeVersions(*i) + " inside " + label + " HLT paths count per LS ";
1543 // MonitorElement* ME_Group_LS = dbe_->book1D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_);
1544 // ME_Group_LS->setAxisTitle("LS");
1545 // /// add this path to the vector of 2D LS paths
1546 // v_ME_HLTAll_LS.push_back(ME_Group_LS);
1547 // }
1548 
1549  }
1550 
1551 
1552 // dbe_->setCurrentFolder(pathsSummaryHLTPathsPerBXFolder_.c_str());
1553 // h_name= "HLT_"+label+"_BX_LS";
1554 // h_title = label+" HLT paths total count combined per BX ";
1555 // MonitorElement* ME_Total_BX = dbe_->book2D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_, 5, -2.5, 2.5);
1556 // ME_Total_BX->setAxisTitle("LS",1);
1557 // v_ME_Total_BX.push_back(ME_Total_BX);
1558 
1559 // h_name= "HLT_"+label+"_BX_LS_Norm";
1560 // h_title = label+" HLT paths total count combined per BX Normalized to LS";
1561 // MonitorElement* ME_Total_BX_Norm = dbe_->book2D(h_name.c_str(), h_title.c_str(), nLS_, 0, nLS_, 5, -2.5, 2.5);
1562 // ME_Total_BX_Norm->setAxisTitle("LS",1);
1563 // v_ME_Total_BX_Norm.push_back(ME_Total_BX_Norm);
1564 
1565 // bjk: These are OK
1566  if (label != "OfflineMonitor" && label != "OnlineHltMonitor" && label != "OnlineMonitor") {
1567  for(unsigned int i = 0; i < paths.size(); i++){
1568 
1569  if (ME) {
1570  ME->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1571  ME->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1572  }
1573  // ME_Group_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1574  if (ME_Normalized){
1575  ME_Normalized->getTH2F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1576  ME_Normalized->getTH2F()->GetYaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1577  }
1578  if (ME_Normalized_Any)
1579  ME_Normalized_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1580 
1581  if (ME_Any)
1582  ME_Any->getTH1F()->GetXaxis()->SetBinLabel(i+1, (paths[i]).c_str());
1583  }
1584  }
1585 
1586 }
1587 
1588 void FourVectorHLTOffline::fillHltMatrix(const edm::TriggerNames & triggerNames) {
1589 
1590 
1591  string fullPathToME;
1592 
1593  //for (unsigned int mi=0;mi<fGroupName.size();mi++) {
1594  for (unsigned int mi=0;mi<fGroupNamePathsPair.size();mi++) {
1595 
1596 
1597  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_PassPass";
1598  MonitorElement* ME_2d = dbe_->get(fullPathToME);
1599  fullPathToME = "HLT/FourVector/PathsSummary/HLT_"+fGroupNamePathsPair[mi].first+"_Pass_Any";
1600  MonitorElement* ME_1d = dbe_->get(fullPathToME);
1601  if(!ME_2d || !ME_1d) {
1602 
1603  LogTrace("FourVectorHLTOffline") << " ME not valid although I gave full path" << endl;
1604  continue;
1605 
1606  }
1607 
1608  TH2F * hist_2d = ME_2d->getTH2F();
1609  TH1F * hist_1d = ME_1d->getTH1F();
1610 
1611  // Fill HLTPassed Matrix bin (i,j) = (Any,Any)
1612  // --------------------------------------------------------
1613  int anyBinNumber = hist_2d->GetXaxis()->FindBin("HLT_Any");
1614 
1615  string groupBinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_Any";
1616  int groupBinNumber = hist_2d->GetXaxis()->FindBin(groupBinLabel.c_str());
1617 
1618  // any trigger accepted
1619  if(fTriggerResults->accept()){
1620 
1621  hist_2d->Fill(anyBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
1622  hist_1d->Fill(anyBinNumber-1);//binNumber1 = 0 = first filter
1623 
1624  }
1625 
1626  bool groupPassed = false;
1627  //bool groupL1Passed = false;
1628 
1629  // Main loop over paths
1630  // --------------------
1631 
1632  //for (int i=1; i< hist_2d->GetNbinsX();i++)
1633  for (unsigned int i=0; i< fGroupNamePathsPair[mi].second.size(); i++)
1634  {
1635 
1636  //string hltPathName = hist_2d->GetXaxis()->GetBinLabel(i);
1637  string hltPathName = fGroupNamePathsPair[mi].second[i];
1638 
1639  // check if this is hlt path name
1640  //unsigned int pathByIndex = triggerNames.triggerIndex(hltPathName);
1641  unsigned int pathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[i]);
1642  if(pathByIndex >= fTriggerResults->size() ) continue;
1643 
1644  // check if its L1 passed
1645  // comment out below but set groupL1Passed to true always
1646  //if(hasL1Passed(hltPathName,triggerNames)) groupL1Passed = true;
1647  //groupL1Passed = true;
1648 
1649  // Fill HLTPassed Matrix and HLTPassFail Matrix
1650  // --------------------------------------------------------
1651 
1652  if(fTriggerResults->accept(pathByIndex)){
1653 
1654  groupPassed = true;
1655  //groupL1Passed = true;
1656 
1657  hist_2d->Fill(i,anyBinNumber-1);//binNumber1 = 0 = first filter
1658  hist_2d->Fill(anyBinNumber-1,i);//binNumber1 = 0 = first filter
1659 
1660  hist_2d->Fill(i,groupBinNumber-1);//binNumber1 = 0 = first filter
1661  hist_2d->Fill(groupBinNumber-1,i);//binNumber1 = 0 = first filter
1662 
1663  hist_1d->Fill(i);//binNumber1 = 0 = first filter
1664 
1665 
1666  //for (int j=1; j< hist_2d->GetNbinsY();j++)
1667  for (unsigned int j=0; j< fGroupNamePathsPair[mi].second.size(); j++)
1668  {
1669 
1670  string crossHltPathName = fGroupNamePathsPair[mi].second[j];
1671 
1672  //unsigned int crosspathByIndex = triggerNames.triggerIndex(hist_2d->GetXaxis()->GetBinLabel(j));
1673  //unsigned int crosspathByIndex = triggerNames.triggerIndex(crossHltPathName);
1674  unsigned int crosspathByIndex = triggerNames.triggerIndex(fGroupNamePathsPair[mi].second[j]);
1675 
1676  if(crosspathByIndex >= fTriggerResults->size() ) continue;
1677 
1678  if(fTriggerResults->accept(crosspathByIndex)){
1679 
1680  hist_2d->Fill(i,j);//binNumber1 = 0 = first filter
1681 
1682  } // end if j path passed
1683 
1684  } // end for j
1685 
1686  } // end if i passed
1687 
1688 
1689  } // end for i
1690 
1691  if(groupPassed) {
1692 
1693  hist_1d->Fill(groupBinNumber-1);//binNumber1 = 0 = first filter
1694  hist_1d->Fill(groupBinNumber-2);//binNumber1 = 0 = first filter -> Fill L1group as well
1695  hist_2d->Fill(groupBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
1696  hist_2d->Fill(anyBinNumber-1,groupBinNumber-1);//binNumber1 = 0 = first filter
1697  hist_2d->Fill(groupBinNumber-1,anyBinNumber-1);//binNumber1 = 0 = first filter
1698 
1699  }
1700 
1701  /*
1702  string groupL1BinLabel = "HLT_"+fGroupNamePathsPair[mi].first+"_L1_Any";
1703  int groupL1BinNumber = hist_2d->GetXaxis()->FindBin(groupL1BinLabel.c_str());
1704 
1705  if(groupL1Passed) hist_1d->Fill(groupL1BinNumber-1);//binNumber1 = 0 = first filter
1706  */
1707  } // end for mi
1708 
1709 }
1710 
1711 void FourVectorHLTOffline::setupHltBxPlots()
1712 {
1713 
1714  //pathsSummaryFolder_ = TString("HLT/FourVector/PathsSummary/");
1715  //dbe_->setCurrentFolder(pathsSummaryFolder_.c_str());
1716  dbe_->setCurrentFolder(pathsSummaryFolder_);
1717 
1718  // setup HLT bx plot
1719  unsigned int npaths = hltPathsDiagonal_.size();
1720 
1721  ME_HLT_BX = dbe_->book2D("HLT_bx",
1722  "HLT counts vs Event bx",
1723  Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
1724  /*
1725  ME_HLT_CUSTOM_BX = dbe_->book2D("HLT_Custom_bx",
1726  "HLT counts vs Event bx",
1727  Nbx_+1, -0.5, Nbx_+1-0.5, npaths, -0.5, npaths-0.5);
1728  */
1729  ME_HLT_BX->setAxisTitle("Bunch Crossing");
1730  //ME_HLT_CUSTOM_BX->setAxisTitle("Bunch Crossing");
1731 
1732 
1733  // Set up bin labels on Y axis continuing to cover all npaths
1734  for(unsigned int i = 0; i < npaths; i++){
1735 
1736  if (ME_HLT_BX)
1737  ME_HLT_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1738  //ME_HLT_CUSTOM_BX->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1739 
1740  }
1741 
1742 
1743 }
1744 
1745 void FourVectorHLTOffline::setupHltLsPlots()
1746 {
1747 
1748  unsigned int npaths = hltPathsDiagonal_.size();
1749 
1750  //pathsSummaryHLTPathsPerLSFolder_ = TString("HLT/FourVector/PathsSummary/HLT LS/");
1751  //dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_.c_str());
1752  dbe_->setCurrentFolder(pathsSummaryHLTPathsPerLSFolder_);
1753 
1754  ME_HLTAll_LS = dbe_->book2D("All_count_LS",
1755  "All paths per LS ",
1756  nLS_, 0, nLS_, npaths+1, -0.5, npaths+1-0.5);
1757  ME_HLTAll_LS->setAxisTitle("Luminosity Section");
1758 
1759  // Set up bin labels on Y axis continuing to cover all npaths
1760  for(unsigned int i = 0; i < npaths; i++){
1761  if (ME_HLTAll_LS)
1762  ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, (hltPathsDiagonal_[i]).getPath().c_str());
1763 
1764  }
1765 
1766  unsigned int i = npaths;
1767 
1768  if (ME_HLTAll_LS)
1769  ME_HLTAll_LS->getTH2F()->GetYaxis()->SetBinLabel(i+1, "HLT_Any");
1770 
1771 
1772 }
1773 
1774 
1775 void FourVectorHLTOffline::beginLuminosityBlock(const edm::LuminosityBlock& lumiSeg, const edm::EventSetup& c){
1776 
1777  //int lumi = int(lumiSeg.id().luminosityBlock());
1778  //if(lumi < 74 || lumi > 77) fLumiFlag = false;
1779  //else fLumiFlag = true;
1780 
1781 }
1782 
1783 void FourVectorHLTOffline::endLuminosityBlock(const edm::LuminosityBlock& lumiSeg, const edm::EventSetup& c)
1784 {
1785 
1786  int lumi = int(lumiSeg.id().luminosityBlock());
1787  LogTrace("FourVectorHLTOffline") << " end lumiSection number " << lumi << endl;
1788 
1789  // countHLTPathHitsEndLumiBlock(lumi);
1790  countHLTGroupHitsEndLumiBlock(lumi);
1791  countHLTGroupL1HitsEndLumiBlock(lumi);
1792 
1793  // countHLTGroupBXHitsEndLumiBlock(lumi);
1794 
1795 }
1796 
1797 // bjk: we have commented this out
1798 void FourVectorHLTOffline::countHLTGroupBXHitsEndLumiBlock(const int& lumi)
1799 {
1800 
1801  LogTrace("FourVectorHLTOffline") << " countHLTGroupBXHitsEndLumiBlock() lumiSection number " << lumi << endl;
1802 
1803  TH2F * hist_2d_bx = ME_HLT_BX->getTH2F();
1804 
1805  for (std::vector<std::pair<std::string, vector<int> > >::iterator ip = fPathBxTempCountPair.begin(); ip != fPathBxTempCountPair.end(); ++ip) {
1806 
1807  // get the path and its previous count
1808  std::string pathname = ip->first;
1809  vector<int> prevCount = ip->second;
1810 
1811  // vector of 5 zeros
1812  vector<int> currCount (5,0);
1813  vector<int> diffCount (5,0);
1814 
1815  // get the current count of path up to now
1816  int pathBin = hist_2d_bx->GetYaxis()->FindBin(pathname.c_str());
1817 
1818  if(pathBin > hist_2d_bx->GetNbinsY()) {
1819 
1820  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
1821  continue;
1822 
1823  }
1824 
1825  for (unsigned int b =0;b<currCount.size();b++) {
1826 
1827  int bxOffset = b-2;
1828  int bunch = referenceBX_+bxOffset;
1829  if(bunch < 1) bunch += Nbx_ ;
1830  int bxBin = bunch +1; // add one to get the right bin
1831 
1832 
1833  currCount[b] = int(hist_2d_bx->GetBinContent(bxBin, pathBin)); // add one to get the right bin
1834 
1835  LogTrace("FourVectorHLTOffline") << "currCount = " << currCount[b] << endl;
1836 
1837  // count due to prev lumi sec is a difference bw current and previous
1838  diffCount[b] = currCount[b] - prevCount[b];
1839 
1840  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << "bxOffset = " << bxOffset << " count = " << diffCount[b] << endl;
1841 
1842  } // end for bx b
1843 
1844  // set the counter in the pair to current count
1845  ip->second = currCount;
1846 
1848  // fill the 2D Group paths' BX count per LS, using currCount
1850  LogTrace("FourVectorHLTOffline") << "Find " << pathname << endl;
1851 
1852  //check if the path is in this group
1853  for (unsigned int j=0;j<fGroupNamePathsPair.size();j++) {
1854 
1855  bool isMember = false;
1856 
1857  LogTrace("FourVectorHLTOffline") << " ---- Group " << fGroupNamePathsPair[j].first << endl;
1858 
1859  // decide if pathname is member of this group
1860  for (unsigned int k = 0; k<(fGroupNamePathsPair[j].second).size();k++) {
1861 
1862  LogTrace("FourVectorHLTOffline") << " comparing to " << fGroupNamePathsPair[j].second[k] << endl;
1863 
1864  if(fGroupNamePathsPair[j].second[k] == pathname) {
1865 
1866  isMember = true;
1867  break;
1868 
1869  }
1870 
1871  } // end for k
1872 
1873  if(!isMember) {
1874 
1875  LogTrace("FourVectorHLTOffline") << "Could not find a group to which the path belongs, path = " << pathname << " group = " << fGroupNamePathsPair[j].first << endl;
1876  continue;
1877 
1878  }
1879 
1880  MonitorElement* ME_2d = v_ME_Total_BX[j];
1881 
1882  if (! ME_2d) {
1883 
1884  LogDebug("FourVectorHLTOffline") << " cannot find ME_2d for group " << fGroupNamePathsPair[j].first << endl;
1885  continue;
1886 
1887  }
1888 
1889  vector<int> updatedLumiCount(5,0);
1890 
1891  float entireBXWindowUpdatedLumiCount = 0;
1892 
1893  TH2F* hist_All = ME_2d->getTH2F();
1894 
1895  for (unsigned int b = 0; b<diffCount.size();b++) {
1896 
1897  // find the bin
1898  int binNumber = b+1; // add one to get right bin
1899 
1900  // update the bin content (must do that since events don't ncessarily come in the order
1901  int currentLumiCount = int(hist_All->GetBinContent(lumi+1,binNumber));
1902  updatedLumiCount[b] = currentLumiCount + diffCount[b];
1903  hist_All->SetBinContent(lumi+1,binNumber,updatedLumiCount[b]);
1904 
1905  entireBXWindowUpdatedLumiCount += updatedLumiCount[b];
1906 
1907  } // end for bx b
1908 
1909  MonitorElement* ME_2d_Norm = v_ME_Total_BX_Norm[j];
1910 
1911  if (! ME_2d_Norm) {
1912 
1913  LogDebug("FourVectorHLTOffline") << " cannot find ME_2d_Norm for group " << fGroupNamePathsPair[j].first << endl;
1914  continue;
1915 
1916  }
1917 
1918  TH2F* hist_All_Norm = ME_2d_Norm->getTH2F();
1919 
1920  for (unsigned int b = 0; b<diffCount.size();b++) {
1921 
1922  // find the bin
1923  int binNumber = b+1; // add one to get right bin
1924 
1925  // update the bin content but normalized to the whole columb (BX windw +/- 2)
1926  if(entireBXWindowUpdatedLumiCount != 0)
1927  hist_All_Norm->SetBinContent(lumi+1,binNumber,float(updatedLumiCount[b])/entireBXWindowUpdatedLumiCount);
1928 
1929  } // end for bx b
1930 
1931  } // end for group j
1932 
1933  } // end for ip
1934 
1935 }
1936 
1937 void FourVectorHLTOffline::countHLTGroupL1HitsEndLumiBlock(const int& lumi)
1938 {
1939 
1940  LogTrace("FourVectorHLTOffline") << " countHLTGroupL1HitsEndLumiBlock() lumiSection number " << lumi << endl;
1941 
1942  for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){
1943 
1944  // get the count of path up to now
1945  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first+ "_Pass_Any";
1946  MonitorElement* ME_1d = dbe_->get(fullPathToME);
1947 
1948  if(! ME_1d) {
1949 
1950  LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;
1951 
1952  continue;
1953 
1954  }
1955 
1956  LogTrace("FourVectorHLTOffline") << " Looking in histogram " << fullPathToME << endl;
1957 
1958  TH1F * hist_1d = ME_1d->getTH1F();
1959 
1960  for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupL1TempCountPair.begin(); ip != fGroupL1TempCountPair.end(); ++ip) {
1961 
1962  // get the path and its previous count
1963  string pathname = ip->first;
1964  float prevCount = ip->second;
1965 
1966  string binLabel = "HLT_"+pathname+"_L1_Any";
1967 
1968  LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel << endl;
1969  // get the current count of path up to now
1970  int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());
1971 
1972  LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin << " out of histogram total number of bins " << hist_1d->GetNbinsX() << endl;
1973  if(pathBin == -1) {
1974 
1975  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
1976  continue;
1977 
1978  }
1979 
1980  float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;
1981 
1982  // count due to prev lumi sec is a difference bw current and previous
1983  float diffCount = currCount - prevCount;
1984 
1985  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
1986 
1987  // set the counter in the pair to current count
1988  ip->second = currCount;
1989 
1990 
1992  // fill the 1D individual path count per LS
1994  string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_L1_Total_LS";
1995  MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
1996  if ( ME_1d) {
1997 
1998  // update the bin content (must do that since events don't ncessarily come in the order
1999  float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2000  float updatedLumiCount = currentLumiCount + diffCount;
2001  ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2002  }
2003  else {
2004 
2005  LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2006 
2007  }
2008 
2009  } // end for ip
2010 
2011  } // end for i
2012 
2013 }
2014 
2015 
2016 void FourVectorHLTOffline::countHLTGroupHitsEndLumiBlock(const int& lumi)
2017 {
2018 
2019  LogTrace("FourVectorHLTOffline") << " countHLTGroupHitsEndLumiBlock() lumiSection number " << lumi << endl;
2020  for(unsigned int i=0; i<fGroupNamePathsPair.size(); i++){
2021 
2022  // get the count of path up to now
2023  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_" + fGroupNamePathsPair[i].first + "_Pass_Any";
2024  MonitorElement* ME_1d = dbe_->get(fullPathToME);
2025 
2026  if(! ME_1d) {
2027 
2028  LogTrace("FourVectorHLTOffline") << " could not find 1d matrix " << fullPathToME << endl;
2029 
2030  continue;
2031 
2032  }
2033 
2034  LogTrace("FourVectorHLTOffline") << " Looking in histogram " << fullPathToME << endl;
2035 
2036  TH1F * hist_1d = ME_1d->getTH1F();
2037 
2038  for (std::vector<std::pair<std::string, float> >::iterator ip = fGroupTempCountPair.begin(); ip != fGroupTempCountPair.end(); ++ip) {
2039 
2040  // get the path and its previous count
2041  string pathname = ip->first;
2042  float prevCount = ip->second;
2043 
2044  string binLabel = "HLT_"+pathname+"_Any";
2045 
2046  LogTrace("FourVectorHLTOffline") << " Looking for binLabel = " << binLabel << endl;
2047  // get the current count of path up to now
2048  int pathBin = hist_1d->GetXaxis()->FindBin(binLabel.c_str());
2049 
2050  LogTrace("FourVectorHLTOffline") << " pathBin = " << pathBin << " out of histogram total number of bins " << hist_1d->GetNbinsX() << endl;
2051  if(pathBin == -1) {
2052 
2053  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
2054  continue;
2055 
2056  }
2057 
2058  float currCount = hist_1d->GetBinContent(pathBin)/LSsize_;
2059 
2060  // count due to prev lumi sec is a difference bw current and previous
2061  float diffCount = currCount - prevCount;
2062 
2063  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
2064 
2065  // set the counter in the pair to current count
2066  ip->second = currCount;
2067 
2068 
2070  // fill the 1D individual path count per LS
2072  string fullPathToME_count = pathsSummaryHLTPathsPerLSFolder_ +"HLT_" + pathname + "_Total_LS";
2073  MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
2074  if ( ME_1d) {
2075 
2076  // update the bin content (must do that since events don't ncessarily come in the order
2077  float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2078  float updatedLumiCount = currentLumiCount + diffCount;
2079  ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2080 
2081  }
2082  else {
2083 
2084  LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2085 
2086  }
2087 
2088  } // end for ip
2089 
2090  } // end for i
2091 
2092 }
2093 
2094 
2095 void FourVectorHLTOffline::countHLTPathHitsEndLumiBlock(const int& lumi)
2096 {
2097 
2098  LogTrace("FourVectorHLTOffline") << " countHLTPathHitsEndLumiBlock() lumiSection number " << lumi << endl;
2099  // get the count of path up to now
2100  string fullPathToME = "HLT/FourVector/PathsSummary/HLT_All_PassPass";
2101  MonitorElement* ME_2d = dbe_->get(fullPathToME);
2102 
2103  if(! ME_2d) {
2104 
2105  LogTrace("FourVectorHLTOffline") << " could not fine 2d matrix " << fullPathToME << endl;
2106 
2107  return;
2108 
2109  }
2110 
2111  TH2F * hist_2d = ME_2d->getTH2F();
2112 
2113  for (std::vector<std::pair<std::string, float> >::iterator ip = fPathTempCountPair.begin(); ip != fPathTempCountPair.end(); ++ip) {
2114 
2115  // get the path and its previous count
2116  std::string pathname = ip->first;
2117  float prevCount = ip->second;
2118 
2119  // get the current count of path up to now
2120  float pathBin = hist_2d->GetXaxis()->FindBin(pathname.c_str());
2121 
2122  if(pathBin > hist_2d->GetNbinsX()) {
2123 
2124  LogTrace("FourVectorHLTOffline") << " Cannot find the bin for path " << pathname << endl;
2125  continue;
2126 
2127  }
2128 
2129  float currCount = hist_2d->GetBinContent(pathBin, pathBin)/LSsize_;
2130 
2131  // count due to prev lumi sec is a difference bw current and previous
2132  float diffCount = currCount - prevCount;
2133 
2134  LogTrace("FourVectorHLTOffline") << " lumi = " << lumi << " path " << pathname << " count " << diffCount << endl;
2135 
2136  // set the counter in the pair to current count
2137  ip->second = currCount;
2138 
2140  // fill the 2D All paths' count per LS
2142  if ( ME_HLTAll_LS) {
2143 
2144  TH2F* hist_All = ME_HLTAll_LS->getTH2F();
2145 
2146  // find the bin
2147  int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
2148 
2149  // update the bin content (must do that since events don't ncessarily come in the order
2150  float currentLumiCount = hist_All->GetBinContent(lumi+1,pathBinNumber);
2151  float updatedLumiCount = currentLumiCount + diffCount;
2152  hist_All->SetBinContent(lumi+1,pathBinNumber,updatedLumiCount);
2153 
2154  }
2155  else {
2156 
2157  LogDebug("FourVectorHLTOffline") << " cannot find ME_HLTAll_LS" << endl;
2158 
2159  }
2160 
2161 // for (unsigned int i=0 ; i< v_ME_HLTAll_LS.size(); i++) {
2162 
2163 // MonitorElement* tempME = v_ME_HLTAll_LS[i];
2164 
2165 // if (tempME && tempME->getName().find(pathname) != std::string::npos) {
2166 
2167 // TH1F* hist_All = tempME->getTH1F();
2168 
2169 // // // find the bin
2170 // // int pathBinNumber = hist_All->GetYaxis()->FindBin(pathname.c_str());
2171 // // // update the bin content (must do that since events don't ncessarily come in the order
2172 // float currentLumiCount = hist_All->GetBinContent(lumi+1);
2173 // float updatedLumiCount = currentLumiCount + diffCount;
2174 // hist_All->SetBinContent(lumi+1,updatedLumiCount);
2175 
2176 // }
2177 // else {
2178 
2179 // LogDebug("FourVectorHLTOffline") << " cannot find tempME " << endl;
2180 
2181 // }
2182 
2183 // }
2184 
2185 
2186  // bjk here
2187 // ///////////////////////////////////////////
2188 // // fill the 1D individual path count per LS
2189 // ///////////////////////////////////////////
2190 // string fullPathToME_count = pathsIndividualHLTPathsPerLSFolder_ + pathname + "_count_per_LS";
2191 // MonitorElement* ME_1d = dbe_->get(fullPathToME_count);
2192 // if ( ME_1d) {
2193 
2194 // // update the bin content (must do that since events don't ncessarily come in the order
2195 // float currentLumiCount = ME_1d->getTH1()->GetBinContent(lumi+1);
2196 // float updatedLumiCount = currentLumiCount + diffCount;
2197 // ME_1d->getTH1()->SetBinContent(lumi+1,updatedLumiCount);
2198 
2199 // }
2200 // else {
2201 
2202 // LogDebug("FourVectorHLTOffline") << " cannot find ME " << fullPathToME_count << endl;
2203 
2204 // }
2205 
2206  } // end for ip
2207 
2208 }
2209 
2210 int FourVectorHLTOffline::getTriggerTypeParsePathName(const string& pathname)
2211 {
2212 
2213  int objectType = 0;
2214 
2215  if (pathname.find("MET") != std::string::npos)
2216  objectType = trigger::TriggerMET;
2217  if (pathname.find("SumET") != std::string::npos || pathname.find("SumEt") != std::string::npos || pathname.find("ETT") != std::string::npos)
2218  objectType = trigger::TriggerTET;
2219  if (pathname.find("HT") != std::string::npos)
2220  objectType = trigger::TriggerTET;
2221  if (pathname.find("Jet") != std::string::npos)
2222  objectType = trigger::TriggerJet;
2223  if (pathname.find("Mu") != std::string::npos)
2224  objectType = trigger::TriggerMuon;
2225  if (pathname.find("Ele") != std::string::npos)
2226  objectType = trigger::TriggerElectron;
2227  if (pathname.find("Photon") != std::string::npos)
2228  objectType = trigger::TriggerPhoton;
2229  if (pathname.find("EG") != std::string::npos)
2230  objectType = trigger::TriggerPhoton;
2231  if (pathname.find("Tau") != std::string::npos)
2232  objectType = trigger::TriggerTau;
2233  if (pathname.find("IsoTrack") != std::string::npos)
2234  objectType = trigger::TriggerTrack;
2235  if (pathname.find("BTag") != std::string::npos)
2236  objectType = trigger::TriggerBJet;
2237 
2238  return objectType;
2239 }
2240 
2241 const string FourVectorHLTOffline::getL1ConditionModuleName(const string& pathname)
2242 {
2243 
2244  // find L1 condition for numpath with numpath objecttype
2245  // find PSet for L1 global seed for numpath,
2246  // list module labels for numpath
2247  string l1pathname = "dummy";
2248 
2249  vector<string> numpathmodules = hltConfig_.moduleLabels(pathname);
2250 
2251  for(vector<string>::iterator numpathmodule = numpathmodules.begin();
2252  numpathmodule!= numpathmodules.end(); ++numpathmodule ) {
2253 
2254  if (hltConfig_.moduleType(*numpathmodule) == "HLTLevel1GTSeed") {
2255 
2256  l1pathname = *numpathmodule;
2257  break;
2258 
2259  }
2260 
2261  } // end for
2262 
2263  return l1pathname;
2264 
2265 }
2266 
2267 
2268 bool FourVectorHLTOffline::hasL1Passed(const string& pathname, const edm::TriggerNames & triggerNames)
2269 {
2270 
2271  bool rc = false;
2272  int l1ModuleIndex = 999;
2273  // --------------------
2274  for(PathInfoCollection::iterator v = hltPathsDiagonal_.begin(); v!= hltPathsDiagonal_.end(); ++v ) {
2275 
2276  if(v->getPath() == pathname ) l1ModuleIndex = v->getL1ModuleIndex();
2277 
2278  }
2279 
2280  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
2281  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu
2282 
2283  // get index of the last module that issued the decision
2284  int lastModule = fTriggerResults->index(pathByIndex);
2285 
2286  // if L1 passed, then it must not be the module that
2287  // issued the last decision
2288  rc = (l1ModuleIndex < lastModule);
2289 
2290  return rc;
2291 
2292 }
2293 
2294 bool FourVectorHLTOffline::hasHLTPassed(const string& pathname, const edm::TriggerNames & triggerNames)
2295 {
2296 
2297  bool rc = false;
2298 
2299  unsigned int pathByIndex = triggerNames.triggerIndex(pathname);
2300  if(pathByIndex >= fTriggerResults->size() ) return rc; // path is not in the menu
2301 
2302  rc = fTriggerResults->accept(pathByIndex);
2303 
2304  return rc;
2305 
2306 }
2307 
2308 void FourVectorHLTOffline::selectMuons(const edm::Handle<reco::MuonCollection> & muonHandle)
2309 {
2310  // for every event, first clear vector of selected objects
2311  fSelectedMuons->clear();
2312 
2313  if(muonHandle.isValid()) {
2314 
2315  for( reco::MuonCollection::const_iterator iter = muonHandle->begin(), iend = muonHandle->end(); iter != iend; ++iter )
2316  {
2317 
2318  if(isGoodMuon(*iter, muon::GlobalMuonPromptTight) &&
2319  isGoodMuon(*iter, muon::TrackerMuonArbitrated))
2320  {
2321  if(isVBTFMuon(*iter)) fSelectedMuons->push_back(*iter);
2322  }
2323  } // end for
2324 
2325  edm::Handle<reco::MuonCollection> localSelMuonsHandle(fSelectedMuons,muonHandle.provenance());
2326  fSelMuonsHandle = localSelMuonsHandle;
2327 
2328  } // end if
2329 
2330 
2331 }
2332 
2333 void FourVectorHLTOffline::selectElectrons(const edm::Event& iEvent, const edm::EventSetup& iSetup, const edm::Handle<reco::GsfElectronCollection> & eleHandle)
2334 {
2335 
2336  // for every event, first clear vector of selected objects
2337  fSelectedElectrons->clear();
2338 
2339 
2340 
2341 
2342  if(eleHandle.isValid()) {
2343 
2344  for( reco::GsfElectronCollection::const_iterator iter = eleHandle->begin(), iend = eleHandle->end(); iter != iend; ++iter )
2345  {
2346 
2347  edm::Handle< EcalRecHitCollection > pEBRecHits;
2348  iEvent.getByToken( recHitsEBToken, pEBRecHits );
2349 
2350  edm::Handle< EcalRecHitCollection > pEERecHits;
2351  iEvent.getByToken( recHitsEEToken, pEERecHits );
2352 
2353  if(pEBRecHits.isValid() && pEERecHits.isValid()) {
2354 
2355  EcalClusterLazyTools lazyTool(iEvent, iSetup, recHitsEBToken, recHitsEEToken);
2356  const reco::CaloCluster* bc = iter->superCluster()->seed().get(); // get the basic cluster
2357 
2358  float eleMaxOver3x3 = ( lazyTool.eMax(*bc) / lazyTool.e3x3(*bc) );
2359 
2360  if(eleMaxOver3x3 > eleMaxOver3x3_) continue;
2361 
2362  }
2363 
2364  // Only ecalDriven electrons
2365  if(! iter->ecalDriven() ) continue;
2366 
2367 
2368  // Barrel
2369  if(iter->isEB()) {
2370 
2371  if (
2372  iter->dr03TkSumPt() < dr03TkSumPtEB_ &&
2373  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEB_ &&
2374  iter->dr04HcalTowerSumEt() < dr04HcalTowerSumEtEB_ &&
2375  iter->hadronicOverEm() < hadronicOverEmEB_ &&
2376  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEB_ &&
2377  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEB_ &&
2378  iter->sigmaIetaIeta() < sigmaIetaIetaEB_ &&
2379  //spikes
2380  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEB_
2381  ) {
2382 
2383  fSelectedElectrons->push_back(*iter);
2384 
2385  }
2386 
2387  } // end if
2388 
2389  // EndCap
2390  else if(iter->isEE()) {
2391  if (
2392  iter->dr03TkSumPt() < dr03TkSumPtEC_ &&
2393  iter->dr04EcalRecHitSumEt() < dr04EcalRecHitSumEtEC_ &&
2394  iter->dr04HcalTowerSumEt() < dr04HcalTowerSumEtEC_ &&
2395  iter->hadronicOverEm() < hadronicOverEmEC_ &&
2396  fabs(iter->deltaPhiSuperClusterTrackAtVtx()) < deltaPhiSuperClusterTrackAtVtxEC_ &&
2397  fabs(iter->deltaEtaSuperClusterTrackAtVtx()) < deltaEtaSuperClusterTrackAtVtxEC_ &&
2398  iter->sigmaIetaIeta() < sigmaIetaIetaEC_ &&
2399  //spikes
2400  iter->sigmaIetaIeta() > sigmaIetaIetaSpikesEC_
2401  ) {
2402 
2403  fSelectedElectrons->push_back(*iter);
2404 
2405  }
2406 
2407  } // end else if
2408 
2409 
2410  } // end for
2411 
2412  edm::Handle<reco::GsfElectronCollection> localSelElectronsHandle(fSelectedElectrons,eleHandle.provenance());
2413  fSelElectronsHandle = localSelElectronsHandle;
2414 
2415  } // end if
2416 
2417 
2418 }
2419 
2420 void FourVectorHLTOffline::selectPhotons(const edm::Handle<reco::PhotonCollection> & phoHandle)
2421 {
2422  // for every event, first clear vector of selected objects
2423  fSelectedPhotons->clear();
2424 
2425  if(phoHandle.isValid()) {
2426 
2427  for( reco::PhotonCollection::const_iterator iter = phoHandle->begin(), iend = phoHandle->end(); iter != iend; ++iter )
2428  {
2429 
2430  if(
2431 
2432  //spikes
2433  iter->sigmaIetaIeta() > 0.002 &&
2434  iter->maxEnergyXtal() / iter->e3x3() < 0.9
2435 
2436  ) {
2437 
2438  fSelectedPhotons->push_back(*iter);
2439 
2440  } // end if
2441 
2442  } // end for
2443 
2444  edm::Handle<reco::PhotonCollection> localSelPhotonsHandle(fSelectedPhotons,phoHandle.provenance());
2445  fSelPhotonsHandle = localSelPhotonsHandle;
2446 
2447  } // end if
2448 
2449 
2450 }
2451 
2452 void FourVectorHLTOffline::selectJets(const edm::Event& iEvent, const edm::Handle<reco::CaloJetCollection> & jetHandle)
2453 {
2454  // for every event, first clear vector of selected objects
2455  fSelectedJets->clear();
2456 
2457  if(jetHandle.isValid()) {
2458 
2459  for( reco::CaloJetCollection::const_iterator iter = jetHandle->begin(), iend = jetHandle->end(); iter != iend; ++iter )
2460  {
2461 
2462  jetID->calculate(iEvent, *iter);
2463  if (iter->emEnergyFraction() > emEnergyFractionJet_ &&
2464  jetID->fHPD() < fHPDJet_ &&
2465  iter->n90() >= n90Jet_
2466  ){
2467 
2468  fSelectedJets->push_back(*iter);
2469 
2470  }
2471 
2472  } // end for
2473 
2474  edm::Handle<reco::CaloJetCollection> localSelJetsHandle(fSelectedJets,jetHandle.provenance());
2475  fSelJetsHandle = localSelJetsHandle;
2476 
2477  } // end if
2478 
2479 
2480 }
2481 
2482 void FourVectorHLTOffline::selectMet(const edm::Handle<reco::CaloMETCollection> & metHandle)
2483 {
2484  // for every event, first clear vector of selected objects
2485  fSelectedMet->clear();
2486 
2487  if(metHandle.isValid()) {
2488 
2489  for( reco::CaloMETCollection::const_iterator iter = metHandle->begin(), iend = metHandle->end(); iter != iend; ++iter )
2490  {
2491 
2492  fSelectedMet->push_back(*iter);
2493 
2494  } // end for
2495 
2496  edm::Handle<reco::CaloMETCollection> localSelMetHandle(fSelectedMet,metHandle.provenance());
2497  fSelMetHandle = localSelMetHandle;
2498 
2499  } // end if
2500 
2501 
2502 }
2503 
2504 
2505 void FourVectorHLTOffline::selectTaus(const edm::Event& iEvent)
2506 {
2507  // for every event, first clear vector of selected objects
2508  fSelectedTaus->clear();
2509 
2510  //first read the tau collection
2511  edm::Handle<reco::PFTauCollection> tauHandle;
2512  iEvent.getByToken(hpsPFTauProdToken,tauHandle);
2513 
2514  //Now access a discriminator and see if it passed the tag
2515  edm::Handle<reco::PFTauDiscriminator> dscrmt1H;
2516  iEvent.getByToken(tauDscrmtr1Token,dscrmt1H);
2517  edm::Handle<reco::PFTauDiscriminator> dscrmt2H;
2518  iEvent.getByToken(tauDscrmtr2Token,dscrmt2H);
2519  edm::Handle<reco::PFTauDiscriminator> dscrmt3H;
2520  iEvent.getByToken(tauDscrmtr3Token,dscrmt3H);
2521 
2522  if(tauHandle.isValid() && dscrmt1H.isValid() && dscrmt2H.isValid() && dscrmt3H.isValid()) {
2523 
2524  for(unsigned int i=0;i<tauHandle->size();++i) {
2525 
2526  //create a ref to the PF Tau
2527  reco::PFTauRef pfTauRef(tauHandle,i);
2528 
2529  float outputDiscmnt1 = (*dscrmt1H)[pfTauRef]; // this should be >0.5 to pass
2530  float outputDiscmnt2 = (*dscrmt2H)[pfTauRef]; // this should be >0.5 to pass
2531  float outputDiscmnt3 = (*dscrmt3H)[pfTauRef]; // this should be >0.5 to pass
2532 
2533  if(outputDiscmnt1>0.5 && outputDiscmnt2>0.5 && outputDiscmnt3 >0.5) {
2534 
2535  fSelectedTaus->push_back((*tauHandle)[i]);
2536 
2537  }
2538 
2539  } // end for
2540 
2541 
2542  edm::Handle<reco::PFTauCollection> localSelTauHandle(fSelectedTaus,tauHandle.provenance());
2543  fSelTausHandle = localSelTauHandle;
2544 
2545  } // end if
2546 
2547 }
2548 
2549 
2550 int FourVectorHLTOffline::getHltThresholdFromName(const string & name)
2551 {
2552 
2553  std::string pathname = name;
2554  //cout << "----------------------------------------------" << endl;
2555  //cout << pathname << endl;
2556 
2557  //remove "L1" substr
2558  if(pathname.find("L1") != std::string::npos) pathname.replace(pathname.find("L1"),2,"");
2559  //remove "L2" substr
2560  if(pathname.find("L2") != std::string::npos) pathname.replace(pathname.find("L2"),2,"");
2561  //remove "8E29" substr
2562  if(pathname.find("8E29") != std::string::npos) pathname.replace(pathname.find("8E29"),4,"");
2563 
2564  int digitLocation=0;
2565  for (unsigned int i=0; i < pathname.length(); i++)
2566  {
2567  if (isdigit(pathname.at(i))) {
2568 
2569  digitLocation = i;
2570  break;
2571 
2572  }
2573  }
2574 
2575  // get the string from the location of the first digit to the end
2576  string hltThresholdString = pathname.substr(digitLocation);
2577 
2578  int hltThreshold = 0;
2579 
2580  // get intiger at the begining of the string
2581  sscanf (hltThresholdString.c_str(),"%d%*s",&hltThreshold);
2582  //printf ("%s -> %s -> %d\n",pathname.c_str(), hltThresholdString.c_str(), hltThreshold);
2583 
2584  return hltThreshold;
2585 
2586 }
2587 
2588 bool FourVectorHLTOffline::isVBTFMuon(const reco::Muon& muon)
2589 {
2590 
2591  reco::TrackRef gm = muon.globalTrack();
2592  reco::TrackRef tk = muon.innerTrack();
2593 
2594  // Quality cuts
2595  // ------------
2596 
2597  // Must have BeamSpot for the 1st qualityCut
2598  if(!fBeamSpotHandle.isValid()) return 0;
2599 
2600  double dxy = gm->dxy(fBeamSpotHandle->position());
2601  double normalizedChi2 = gm->normalizedChi2();
2602  int trackerHits = tk->hitPattern().numberOfValidTrackerHits();
2603  int pixelHits = tk->hitPattern().numberOfValidPixelHits();
2604  int muonHits = gm->hitPattern().numberOfValidMuonHits();
2605  int nMatches = muon.numberOfMatches();
2606 
2607  if (fabs(dxy)>dxyCut_) {return 0;}
2608  // if(plotHistograms_){ h1_["hNormChi2"]->Fill(normalizedChi2);}
2609  if (normalizedChi2>normalizedChi2Cut_) {return 0;}
2610  // if(plotHistograms_){ h1_["hNHits"]->Fill(trackerHits);}
2611  if (trackerHits<trackerHitsCut_) {return 0;}
2612  // if(plotHistograms_){ h1_["hNMuonHits"]->Fill(muonHits);}
2613  if (pixelHits<pixelHitsCut_) {return 0;}
2614  // if(plotHistograms_){ h1_["hNPixelHits"]->Fill(pixelHits);}
2615  if (muonHits<muonHitsCut_) {return 0;}
2616  // if(plotHistograms_){ h1_["hTracker"]->Fill(mu.isTrackerMuon());}
2617  if (!muon.isTrackerMuon()) {return 0;}
2618  // if(plotHistograms_){ h1_["hNMatches"]->Fill(nMatches);}
2619  if (nMatches<nMatchesCut_) {return 0;}
2620 
2621  return true;
2622 
2623 }
2624 
2625  string FourVectorHLTOffline::removeVersions(std::string histVersion) {
2626  for (int ii = 100; ii >= 0; ii--) {
2627  string ver = "_v";
2628  string version ="";
2629  stringstream ss;
2630  ss << ver << ii;
2631  ss >> version;
2632 
2633  size_t pos = histVersion.find(version);
2634  if (pos != std::string::npos)
2635  histVersion.erase(pos,version.size());
2636 
2637  }
2638 
2639  return histVersion;
2640  }
2641 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
HLTConfigProvider::size
unsigned int size() const
number of trigger paths in trigger table
Definition: HLTConfigProvider.h:88
FourVectorHLTOffline::setupHltMatrix
void setupHltMatrix(const std::string &label, std::vector< std::string > &paths)
Definition: FourVectorHLTOffline.cc:1491
FourVectorHLTOffline::jetID
reco::helper::JetIDHelper * jetID
Definition: FourVectorHLTOffline.h:171
edm::LuminosityBlockBase::id
LuminosityBlockID id() const
Definition: LuminosityBlockBase.h:53
Pi
const double Pi
Definition: CosmicMuonParameters.h:18
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
FourVectorHLTOffline::hasL1Passed
bool hasL1Passed(const std::string &pathname, const edm::TriggerNames &triggerNames)
Definition: FourVectorHLTOffline.cc:2268
BaseMonitor::fillL1Match
virtual void fillL1Match(FourVectorHLTOffline *fv)=0
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:204
FourVectorHLTOffline::selectPhotons
void selectPhotons(const edm::Handle< reco::PhotonCollection > &phoHandle)
Definition: FourVectorHLTOffline.cc:2420
reco::PFTauCollection
std::vector< PFTau > PFTauCollection
collection of PFTau objects
Definition: PFTauFwd.h:9
edm::RunBase::id
RunID const & id() const
Definition: RunBase.h:41
HLTConfigProvider::moduleType
const std::string moduleType(const std::string &module) const
C++ class name of module.
Definition: HLTConfigProvider.h:141
FourVectorHLTOffline::countHLTPathHitsEndLumiBlock
void countHLTPathHitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:2095
BaseMonitor::monitorOnline
virtual void monitorOnline(const int hltIndex, const int l1Index, FourVectorHLTOnline *fv)=0
FourVectorHLTOffline::countHLTGroupBXHitsEndLumiBlock
void countHLTGroupBXHitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:1798
FourVectorHLTOffline::fSelElectronsHandle
edm::Handle< reco::GsfElectronCollection > fSelElectronsHandle
Definition: FourVectorHLTOffline.h:200
FourVectorHLTOffline::fSelMetHandle
edm::Handle< reco::CaloMETCollection > fSelMetHandle
Definition: FourVectorHLTOffline.h:209
HLTConfigProvider::triggerName
const std::string & triggerName(unsigned int triggerIndex) const
Definition: HLTConfigProvider.h:103
BaseMonitor::fillOnlineMatch
virtual void fillOnlineMatch(const int l1Index, FourVectorHLTOnline *fv)=0
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:954
DQMStore::rmdir
void rmdir(const std::string &fullpath)
Definition: DQMStore.cc:3101
FourVectorHLTOffline::fSelectedMet
reco::CaloMETCollection * fSelectedMet
Definition: FourVectorHLTOffline.h:208
FourVectorHLTOffline::hltPaths_
PathInfoCollection hltPaths_
Definition: FourVectorHLTOffline.h:720
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:48
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
trigger::TriggerL1Mu
enum start value shifted to 81 so as to avoid clashes with PDG codes
Definition: TriggerTypeDefs.h:31
FourVectorHLTOffline::fSelectedTaus
reco::PFTauCollection * fSelectedTaus
Definition: FourVectorHLTOffline.h:213
FourVectorHLTOffline::tauDscrmtr1Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr1Token
Definition: FourVectorHLTOffline.h:346
FourVectorHLTOffline::endRun
void endRun(const edm::Run &run, const edm::EventSetup &c)
EndRun.
Definition: FourVectorHLTOffline.cc:1337
fjr2json.lumi
tuple lumi
Definition: fjr2json.py:35
FourVectorHLTOffline::pathsSummaryHLTPathsPerLSFolder_
std::string pathsSummaryHLTPathsPerLSFolder_
Definition: FourVectorHLTOffline.h:189
reco::Muon::isTrackerMuon
bool isTrackerMuon() const
Definition: Muon.h:219
FourVectorHLTOffline::getTriggerTypeParsePathName
int getTriggerTypeParsePathName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2210
FourVectorHLTOffline::fillHltMatrix
void fillHltMatrix(const edm::TriggerNames &triggerNames)
Definition: FourVectorHLTOffline.cc:1588
FourVectorHLTOffline::fPathBxTempCountPair
std::vector< std::pair< std::string, std::vector< int > > > fPathBxTempCountPair
Definition: FourVectorHLTOffline.h:317
FourVectorHLTOffline::recHitsEBToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEBToken
Definition: FourVectorHLTOffline.h:343
FourVectorHLTOffline::specialPaths_
std::vector< std::string > specialPaths_
Definition: FourVectorHLTOffline.h:322
reco::helper::JetIDHelper::fHPD
double fHPD() const
Definition: JetIDHelper.h:40
FourVectorHLTOffline::FourVectorHLTOffline
FourVectorHLTOffline(const edm::ParameterSet &)
Definition: FourVectorHLTOffline.cc:14
FourVectorHLTOffline::cleanDRMatchSet
void cleanDRMatchSet(mmset &tempSet)
Clean DR Match Set.
Definition: FourVectorHLTOffline.cc:1345
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:942
fimmap
std::multimap< float, int > fimmap
Definition: FourVectorHLTOnline.h:72
HLTConfigProvider::moduleEDMType
const std::string moduleEDMType(const std::string &module) const
C++ base class name of module.
Definition: HLTConfigProvider.h:146
FourVectorHLTOffline::fSelMuonsHandle
edm::Handle< reco::MuonCollection > fSelMuonsHandle
Definition: FourVectorHLTOffline.h:197
NULL
#define NULL
Definition: scimark2.h:8
FourVectorHLTOffline::gsfElectronToken
edm::EDGetTokenT< reco::GsfElectronCollection > gsfElectronToken
Definition: FourVectorHLTOffline.h:335
FourVectorHLTOffline::triggerResultsToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsToken
Definition: FourVectorHLTOffline.h:329
FourVectorHLTOffline::fBeamSpotHandle
edm::Handle< reco::BeamSpot > fBeamSpotHandle
Definition: FourVectorHLTOffline.h:123
cuy.ii
int ii
Definition: cuy.py:588
BaseMonitor::monitorOffline
virtual void monitorOffline(void)=0
FourVectorHLTOffline::fSelTausHandle
edm::Handle< reco::PFTauCollection > fSelTausHandle
Definition: FourVectorHLTOffline.h:214
FourVectorHLTOffline::tauDscrmtr2Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr2Token
Definition: FourVectorHLTOffline.h:347
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
filters
std::vector< TPRegexp > filters
Definition: eve_filter.cc:25
FourVectorHLTOffline::triggerSummaryLabel_
edm::InputTag triggerSummaryLabel_
Definition: FourVectorHLTOffline.h:350
FourVectorHLTOffline::countHLTGroupL1HitsEndLumiBlock
void countHLTGroupL1HitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:1937
g
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e g
Definition: Activities.doc:4
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
objMonData::setRecoB
void setRecoB(edm::Handle< reco::JetTagCollection > offCollB)
Definition: FourVectorHLTOffline.h:767
FourVectorHLTOffline::hltPathsDiagonal_
PathInfoCollection hltPathsDiagonal_
Definition: FourVectorHLTOffline.h:722
FourVectorHLTOffline::custompathnamepairs_
std::vector< std::pair< std::string, std::string > > custompathnamepairs_
Definition: FourVectorHLTOffline.h:312
reco::MuonCollection
std::vector< Muon > MuonCollection
collection of Muon objects
Definition: MuonFwd.h:9
mmset
std::set< fimmap, std::less< fimmap > > mmset
Definition: FourVectorHLTOnline.h:73
FourVectorHLTOffline::fSelPhotonsHandle
edm::Handle< reco::PhotonCollection > fSelPhotonsHandle
Definition: FourVectorHLTOffline.h:203
FourVectorHLTOffline::fSelectedElectrons
reco::GsfElectronCollection * fSelectedElectrons
Definition: FourVectorHLTOffline.h:199
FourVectorHLTOffline::triggerSummaryFUToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryFUToken
Definition: FourVectorHLTOffline.h:332
edm::second
U second(std::pair< T, U > const &p)
Definition: ParameterSet.cc:250
ME
Definition: ME.h:11
FourVectorHLTOffline::pixelTrackToken
edm::EDGetTokenT< reco::TrackCollection > pixelTrackToken
Definition: FourVectorHLTOffline.h:342
FourVectorHLTOffline::getL1ConditionModuleName
const std::string getL1ConditionModuleName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2241
iEvent
int iEvent
Definition: GenABIO.cc:230
edm::moduleName
std::string moduleName(Provenance const &provenance)
Definition: Provenance.cc:27
EgammaValidation_cff.pathName
tuple pathName
Definition: EgammaValidation_cff.py:269
HLTConfigProvider::moduleIndex
unsigned int moduleIndex(unsigned int trigger, const std::string &module) const
slot position of module on trigger path (0 to size-1)
Definition: HLTConfigProvider.h:133
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
FourVectorHLTOffline::photonToken
edm::EDGetTokenT< reco::PhotonCollection > photonToken
Definition: FourVectorHLTOffline.h:341
objMonData::setLimits
void setLimits(float etaMax, float etMin, float drMatch)
Definition: FourVectorHLTOnline.h:607
FourVectorHLTOffline::fTriggerResults
edm::Handle< edm::TriggerResults > fTriggerResults
Definition: FourVectorHLTOffline.h:122
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:67
FourVectorHLTOffline::tauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > tauProdToken
Definition: FourVectorHLTOffline.h:336
FourVectorHLTOffline::beamSpotToken
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken
Definition: FourVectorHLTOffline.h:333
FourVectorHLTOffline::selectJets
void selectJets(const edm::Event &iEvent, const edm::Handle< reco::CaloJetCollection > &jetHandle)
Definition: FourVectorHLTOffline.cc:2452
FourVectorHLTOffline::v_ME_Total_BX
std::vector< MonitorElement * > v_ME_Total_BX
Definition: FourVectorHLTOffline.h:182
FourVectorHLTOffline::fPathTempCountPair
std::vector< std::pair< std::string, float > > fPathTempCountPair
Definition: FourVectorHLTOffline.h:316
j
int j
Definition: DBlmapReader.cc:9
MonitorElement::getTH1
TH1 * getTH1(void) const
Definition: MonitorElement.cc:1532
FourVectorHLTOffline::triggerSummaryToken
edm::EDGetTokenT< trigger::TriggerEvent > triggerSummaryToken
Definition: FourVectorHLTOffline.h:331
FourVectorHLTOffline::endLuminosityBlock
void endLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: FourVectorHLTOffline.cc:1783
FourVectorHLTOffline::hltConfig_
HLTConfigProvider hltConfig_
Definition: FourVectorHLTOffline.h:355
FourVectorHLTOffline::iC5calojetToken
edm::EDGetTokenT< reco::CaloJetCollection > iC5calojetToken
Definition: FourVectorHLTOffline.h:337
FourVectorHLTOffline::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: FourVectorHLTOffline.cc:252
DQMStore::setVerbose
void setVerbose(unsigned level)
Definition: DQMStore.cc:631
FourVectorHLTOffline::fSelectedPhotons
reco::PhotonCollection * fSelectedPhotons
Definition: FourVectorHLTOffline.h:202
triggerResults
static std::string const triggerResults
Definition: EdmProvDump.cc:41
FourVectorHLTOffline::v_ME_Total_BX_Norm
std::vector< MonitorElement * > v_ME_Total_BX_Norm
Definition: FourVectorHLTOffline.h:183
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1708
FourVectorHLTOffline::selectTaus
void selectTaus(const edm::Event &iEvent)
Definition: FourVectorHLTOffline.cc:2505
first
bool first
Definition: L1TdeRCT.cc:75
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
FourVectorHLTOffline::isVBTFMuon
bool isVBTFMuon(const reco::Muon &muon)
Definition: FourVectorHLTOffline.cc:2588
FourVectorHLTOffline::ME_HLT_BX
MonitorElement * ME_HLT_BX
Definition: FourVectorHLTOffline.h:179
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:567
FourVectorHLTOffline::selectElectrons
void selectElectrons(const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::Handle< reco::GsfElectronCollection > &eleHandle)
Definition: FourVectorHLTOffline.cc:2333
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
Definition: Muon.cc:60
PtMinSelector_cfg.ptMin
tuple ptMin
Definition: PtMinSelector_cfg.py:44
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:79
FourVectorHLTOffline::muonRecoCollectionToken
edm::EDGetTokenT< reco::MuonCollection > muonRecoCollectionToken
Definition: FourVectorHLTOffline.h:334
FourVectorHLTOffline::fSelectedMuons
reco::MuonCollection * fSelectedMuons
Definition: FourVectorHLTOffline.h:196
HLTConfigProvider::moduleLabels
const std::vector< std::string > & moduleLabels(unsigned int trigger) const
label(s) of module(s) on a trigger path
Definition: HLTConfigProvider.h:113
FourVectorHLTOffline::triggerResultsLabel_
edm::InputTag triggerResultsLabel_
Definition: FourVectorHLTOffline.h:351
FourVectorHLTOffline::tauDscrmtr3Token
edm::EDGetTokenT< reco::PFTauDiscriminator > tauDscrmtr3Token
Definition: FourVectorHLTOffline.h:348
HLTConfigProvider::datasetContent
const std::vector< std::string > & datasetContent(unsigned int dataset) const
names of trigger paths in dataset with index i
Definition: HLTConfigProvider.h:225
BeamSplash_cfg.version
tuple version
Definition: BeamSplash_cfg.py:45
BaseMonitor::clearSets
virtual void clearSets(void)=0
FourVectorHLTOffline::METToken
edm::EDGetTokenT< reco::CaloMETCollection > METToken
Definition: FourVectorHLTOffline.h:340
FourVectorHLTOffline::beginRun
void beginRun(const edm::Run &run, const edm::EventSetup &c)
Definition: FourVectorHLTOffline.cc:761
reco::CaloMETCollection
std::vector< reco::CaloMET > CaloMETCollection
collection of CaloMET objects
Definition: CaloMETCollection.h:21
FourVectorHLTOffline::hpsPFTauProdToken
edm::EDGetTokenT< std::vector< reco::PFTau > > hpsPFTauProdToken
Definition: FourVectorHLTOffline.h:345
FourVectorHLTOffline::ME_HLT_CUSTOM_BX
MonitorElement * ME_HLT_CUSTOM_BX
Definition: FourVectorHLTOffline.h:180
HLTConfigProvider::init
bool init(const edm::Run &iRun, const edm::EventSetup &iSetup, const std::string &processName, bool &changed)
d&#39;tor
Definition: HLTConfigProvider.cc:65
FourVectorHLTOffline::fSelJetsHandle
edm::Handle< reco::CaloJetCollection > fSelJetsHandle
Definition: FourVectorHLTOffline.h:206
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1539
b
double b
Definition: hdecay.h:120
edm::LuminosityBlockID::luminosityBlock
LuminosityBlockNumber_t luminosityBlock() const
Definition: LuminosityBlockID.h:43
reco::PhotonCollection
std::vector< Photon > PhotonCollection
collectin of Photon objects
Definition: PhotonFwd.h:9
FourVectorHLTOffline::fGroupTempCountPair
std::vector< std::pair< std::string, float > > fGroupTempCountPair
Definition: FourVectorHLTOffline.h:318
FourVectorHLTOffline::fGroupNamePathsPair
std::vector< std::pair< std::string, std::vector< std::string > > > fGroupNamePathsPair
Definition: FourVectorHLTOffline.h:320
FourVectorHLTOffline::removeVersions
std::string removeVersions(std::string histVersion)
Definition: FourVectorHLTOffline.cc:2625
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:42
BaseMonitor::setPath
virtual void setPath(FourVectorHLTOnline::PathInfoCollection::iterator v)=0
FourVectorHLTOffline::beginLuminosityBlock
void beginLuminosityBlock(const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)
Definition: FourVectorHLTOffline.cc:1775
FourVectorHLTOffline::jlipBtagToken
edm::EDGetTokenT< reco::JetTagCollection > jlipBtagToken
Definition: FourVectorHLTOffline.h:338
FourVectorHLTOffline::pathsSummaryHLTCorrelationsFolder_
std::string pathsSummaryHLTCorrelationsFolder_
Definition: FourVectorHLTOffline.h:186
FourVectorHLTOffline::pathsSummaryFilterCountsFolder_
std::string pathsSummaryFilterCountsFolder_
Definition: FourVectorHLTOffline.h:188
LaserDQM_cfi.mon
tuple mon
Definition: LaserDQM_cfi.py:3
FourVectorHLTOffline::selectMet
void selectMet(const edm::Handle< reco::CaloMETCollection > &metHandle)
Definition: FourVectorHLTOffline.cc:2482
FourVectorHLTOffline::softMuBtagToken
edm::EDGetTokenT< reco::JetTagCollection > softMuBtagToken
Definition: FourVectorHLTOffline.h:339
FourVectorHLTOffline::ME_HLTAll_LS
MonitorElement * ME_HLTAll_LS
Definition: FourVectorHLTOffline.h:178
FourVectorHLTOffline::fGroupName
std::vector< std::string > fGroupName
Definition: FourVectorHLTOffline.h:194
FourVectorHLTOffline::countHLTGroupHitsEndLumiBlock
void countHLTGroupHitsEndLumiBlock(const int &lumi)
Definition: FourVectorHLTOffline.cc:2016
BaseMonitor::monitorL1
virtual void monitorL1(const int l1Index, FourVectorHLTOnline *fv)=0
FourVectorHLTOffline::fGroupL1TempCountPair
std::vector< std::pair< std::string, float > > fGroupL1TempCountPair
Definition: FourVectorHLTOffline.h:319
FourVectorHLTOffline::recHitsEEToken
edm::EDGetTokenT< edm::SortedCollection< EcalRecHit > > recHitsEEToken
Definition: FourVectorHLTOffline.h:344
FourVectorHLTOffline::triggerResultsFUToken
edm::EDGetTokenT< edm::TriggerResults > triggerResultsFUToken
Definition: FourVectorHLTOffline.h:330
FourVectorHLTOffline::fSelectedJets
reco::CaloJetCollection * fSelectedJets
Definition: FourVectorHLTOffline.h:205
MonitorElement::getTH2F
TH2F * getTH2F(void) const
Definition: MonitorElement.cc:1563
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:1082
FourVectorHLTOffline::getHltThresholdFromName
int getHltThresholdFromName(const std::string &pathname)
Definition: FourVectorHLTOffline.cc:2550
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:969
FourVectorHLTOffline::fTriggerObj
edm::Handle< trigger::TriggerEvent > fTriggerObj
Definition: FourVectorHLTOffline.h:121
objMonData::setReco
void setReco(edm::Handle< T > offColl)
Definition: FourVectorHLTOnline.h:618
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:43
FourVectorHLTOffline::scalersSelect
MonitorElement * scalersSelect
Definition: FourVectorHLTOffline.h:357
findQualityFiles.size
tuple size
Write out results.
Definition: findQualityFiles.py:442
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:667
reco::helper::JetIDHelper::calculate
void calculate(const edm::Event &event, const reco::CaloJet &jet, const int iDbg=0)
Definition: JetIDHelper.cc:98
edm::Run
Definition: Run.h:41
HLTConfigProvider::datasetNames
const std::vector< std::string > & datasetNames() const
Definition: HLTConfigProvider.h:209
reco::CaloJetCollection
std::vector< CaloJet > CaloJetCollection
collection of CaloJet objects
Definition: CaloJetCollection.h:15
edm::HandleBase::provenance
Provenance const * provenance() const
Definition: HandleBase.h:85
FourVectorHLTOffline::selectMuons
void selectMuons(const edm::Handle< reco::MuonCollection > &muonHandle)
Definition: FourVectorHLTOffline.cc:2308
FourVectorHLTOffline::hasHLTPassed
bool hasHLTPassed(const std::string &pathname, const edm::TriggerNames &triggerNames)
Definition: FourVectorHLTOffline.cc:2294
reco::Muon::globalTrack
virtual TrackRef globalTrack() const
reference to Track reconstructed in both tracked and muon detector
Definition: Muon.h:54
gsfElectrons_cfi.gsfElectrons
tuple gsfElectrons
Definition: gsfElectrons_cfi.py:171
Generated for CMSSW Reference Manual by doxygen 1.8.5