CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TcMETAnalyzer.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * $Date: 2010/03/10 13:25:31 $
5  * $Revision: 1.6 $
6  * \author A.Apresyan - Caltech
7  */
8 
9 #include "DQMOffline/JetMET/interface/TcMETAnalyzer.h"
10 #include "DataFormats/Common/interface/Handle.h"
11 #include "FWCore/Common/interface/TriggerNames.h"
12 
13 #include "DataFormats/Math/interface/LorentzVector.h"
14 
15 #include "FWCore/MessageLogger/interface/MessageLogger.h"
16 
17 #include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
18 #include "DataFormats/CaloTowers/interface/CaloTowerDetId.h"
19 #include "DataFormats/EcalDetId/interface/EcalSubdetector.h"
20 #include "DataFormats/HcalDetId/interface/HcalDetId.h"
21 
22 #include "DataFormats/Math/interface/LorentzVector.h"
23 
24 #include <string>
25 using namespace edm;
26 using namespace reco;
27 using namespace math;
28 
29 // ***********************************************************
30 TcMETAnalyzer::TcMETAnalyzer(const edm::ParameterSet& pSet) {
31 
32  parameters = pSet;
33 
34 }
35 
36 // ***********************************************************
37 TcMETAnalyzer::~TcMETAnalyzer() { }
38 
39 void TcMETAnalyzer::beginJob(DQMStore * dbe) {
40 
41  evtCounter = 0;
42  metname = "tcMETAnalyzer";
43 
44  // trigger information
45  HLTPathsJetMBByName_ = parameters.getParameter<std::vector<std::string > >("HLTPathsJetMB");
46 
47  _hlt_HighPtJet = parameters.getParameter<std::string>("HLT_HighPtJet");
48  _hlt_LowPtJet = parameters.getParameter<std::string>("HLT_LowPtJet");
49  _hlt_HighMET = parameters.getParameter<std::string>("HLT_HighMET");
50  _hlt_LowMET = parameters.getParameter<std::string>("HLT_LowMET");
51  _hlt_Ele = parameters.getParameter<std::string>("HLT_Ele");
52  _hlt_Muon = parameters.getParameter<std::string>("HLT_Muon");
53 
54  // TcMET information
55  theTcMETCollectionLabel = parameters.getParameter<edm::InputTag>("TcMETCollectionLabel");
56  _source = parameters.getParameter<std::string>("Source");
57 
58  // Other data collections
59  HcalNoiseRBXCollectionTag = parameters.getParameter<edm::InputTag>("HcalNoiseRBXCollection");
60  HcalNoiseSummaryTag = parameters.getParameter<edm::InputTag>("HcalNoiseSummary");
61  theJetCollectionLabel = parameters.getParameter<edm::InputTag>("JetCollectionLabel");
62 
63  // misc
64  _verbose = parameters.getParameter<int>("verbose");
65  _etThreshold = parameters.getParameter<double>("etThreshold"); // MET threshold
66  _allhist = parameters.getParameter<bool>("allHist"); // Full set of monitoring histograms
67  _allSelection= parameters.getParameter<bool>("allSelection"); // Plot with all sets of event selection
68 
69  _highPtTcJetThreshold = parameters.getParameter<double>("HighPtTcJetThreshold"); // High Pt Jet threshold
70  _lowPtTcJetThreshold = parameters.getParameter<double>("LowPtTcJetThreshold"); // Low Pt Jet threshold
71  _highTcMETThreshold = parameters.getParameter<double>("HighTcMETThreshold"); // High MET threshold
72  _lowTcMETThreshold = parameters.getParameter<double>("LowTcMETThreshold"); // Low MET threshold
73 
74  //
75  jetID = new reco::helper::JetIDHelper(parameters.getParameter<ParameterSet>("JetIDParams"));
76 
77  // DQStore stuff
78  LogTrace(metname)<<"[TcMETAnalyzer] Parameters initialization";
79  std::string DirName = "JetMET/MET/"+_source;
80  dbe->setCurrentFolder(DirName);
81 
82  metME = dbe->book1D("metReco", "metReco", 4, 1, 5);
83  metME->setBinLabel(2,"TcMET",1);
84 
85  _dbe = dbe;
86 
87  _FolderNames.push_back("All");
88  _FolderNames.push_back("Cleanup");
89  _FolderNames.push_back("HcalNoiseFilter");
90  _FolderNames.push_back("HcalNoiseFilterTight");
91  _FolderNames.push_back("JetID");
92  _FolderNames.push_back("JetIDTight");
93 
94  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
95  ic != _FolderNames.end(); ic++){
96  if (*ic=="All") bookMESet(DirName+"/"+*ic);
97  if (*ic=="Cleanup") bookMESet(DirName+"/"+*ic);
98  if (_allSelection){
99  if (*ic=="HcalNoiseFilter") bookMESet(DirName+"/"+*ic);
100  if (*ic=="HcalNoiseFilterTight") bookMESet(DirName+"/"+*ic);
101  if (*ic=="JetID") bookMESet(DirName+"/"+*ic);
102  if (*ic=="JetIDTight") bookMESet(DirName+"/"+*ic);
103  }
104  }
105 }
106 
107 // ***********************************************************
108 void TcMETAnalyzer::endJob() {
109 
110  delete jetID;
111 
112 }
113 
114 // ***********************************************************
115 void TcMETAnalyzer::bookMESet(std::string DirName)
116 {
117 
118  bool bLumiSecPlot=false;
119  if (DirName.find("All")!=std::string::npos) bLumiSecPlot=true;
120 
121  bookMonitorElement(DirName,bLumiSecPlot);
122 
123  if (_hlt_HighPtJet.size()){
124  bookMonitorElement(DirName+"/"+"HighPtJet",false);
125  meTriggerName_HighPtJet = _dbe->bookString("triggerName_HighPtJet", _hlt_HighPtJet);
126  }
127 
128  if (_hlt_LowPtJet.size()){
129  bookMonitorElement(DirName+"/"+"LowPtJet",false);
130  meTriggerName_LowPtJet = _dbe->bookString("triggerName_LowPtJet", _hlt_LowPtJet);
131  }
132 
133  if (_hlt_HighMET.size()){
134  bookMonitorElement(DirName+"/"+"HighMET",false);
135  meTriggerName_HighMET = _dbe->bookString("triggerName_HighMET", _hlt_HighMET);
136  }
137 
138  if (_hlt_LowMET.size()){
139  bookMonitorElement(DirName+"/"+"LowMET",false);
140  meTriggerName_LowMET = _dbe->bookString("triggerName_LowMET", _hlt_LowMET);
141  }
142 
143  if (_hlt_Ele.size()){
144  bookMonitorElement(DirName+"/"+"Ele",false);
145  meTriggerName_Ele = _dbe->bookString("triggerName_Ele", _hlt_Ele);
146  }
147 
148  if (_hlt_Muon.size()){
149  bookMonitorElement(DirName+"/"+"Muon",false);
150  meTriggerName_Muon = _dbe->bookString("triggerName_Muon", _hlt_Muon);
151  }
152 
153 }
154 
155 // ***********************************************************
156 void TcMETAnalyzer::bookMonitorElement(std::string DirName, bool bLumiSecPlot=false)
157 {
158 
159  if (_verbose) std::cout << "booMonitorElement " << DirName << std::endl;
160  _dbe->setCurrentFolder(DirName);
161 
162  meNevents = _dbe->book1D("METTask_Nevents", "METTask_Nevents" ,1,0,1);
163  meTcMEx = _dbe->book1D("METTask_TcMEx", "METTask_TcMEx" ,500,-500,500);
164  meTcMEy = _dbe->book1D("METTask_TcMEy", "METTask_TcMEy" ,500,-500,500);
165  meTcEz = _dbe->book1D("METTask_TcEz", "METTask_TcEz" ,500,-500,500);
166  meTcMETSig = _dbe->book1D("METTask_TcMETSig","METTask_TcMETSig",51,0,51);
167  meTcMET = _dbe->book1D("METTask_TcMET", "METTask_TcMET" ,500,0,1000);
168  meTcMETPhi = _dbe->book1D("METTask_TcMETPhi","METTask_TcMETPhi",80,-TMath::Pi(),TMath::Pi());
169  meTcSumET = _dbe->book1D("METTask_TcSumET", "METTask_TcSumET" ,500,0,2000);
170 
171  meTcNeutralEMFraction = _dbe->book1D("METTask_TcNeutralEMFraction", "METTask_TcNeutralEMFraction" ,50,0.,1.);
172  meTcNeutralHadFraction = _dbe->book1D("METTask_TcNeutralHadFraction","METTask_TcNeutralHadFraction",50,0.,1.);
173  meTcChargedEMFraction = _dbe->book1D("METTask_TcChargedEMFraction", "METTask_TcChargedEMFraction" ,50,0.,1.);
174  meTcChargedHadFraction = _dbe->book1D("METTask_TcChargedHadFraction","METTask_TcChargedHadFraction",50,0.,1.);
175  meTcMuonFraction = _dbe->book1D("METTask_TcMuonFraction", "METTask_TcMuonFraction" ,50,0.,1.);
176 
177  meTcMETIonFeedbck = _dbe->book1D("METTask_TcMETIonFeedbck", "METTask_TcMETIonFeedbck" ,500,0,1000);
178  meTcMETHPDNoise = _dbe->book1D("METTask_TcMETHPDNoise", "METTask_TcMETHPDNoise" ,500,0,1000);
179  meTcMETRBXNoise = _dbe->book1D("METTask_TcMETRBXNoise", "METTask_TcMETRBXNoise" ,500,0,1000);
180 
181  if (_allhist){
182  if (bLumiSecPlot){
183  meTcMExLS = _dbe->book2D("METTask_TcMEx_LS","METTask_TcMEx_LS",200,-200,200,50,0.,500.);
184  meTcMEyLS = _dbe->book2D("METTask_TcMEy_LS","METTask_TcMEy_LS",200,-200,200,50,0.,500.);
185  }
186  }
187 }
188 
189 // ***********************************************************
190 void TcMETAnalyzer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
191 {
192 
193 }
194 
195 // ***********************************************************
196 void TcMETAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup, DQMStore * dbe)
197 {
198 
199  //
200  //--- Check the time length of the Run from the lumi section plots
201 
202  std::string dirName = "JetMET/MET/"+_source+"/";
203  _dbe->setCurrentFolder(dirName);
204 
205  TH1F* tlumisec;
206 
207  MonitorElement *meLumiSec = _dbe->get("aaa");
208  meLumiSec = _dbe->get("JetMET/lumisec");
209 
210  int totlsec=0;
211  double totltime=0.;
212  if ( meLumiSec->getRootObject() ) {
213  tlumisec = meLumiSec->getTH1F();
214  for (int i=0; i<500; i++){
215  if (tlumisec->GetBinContent(i+1)) totlsec++;
216  }
217  totltime = double(totlsec*90); // one lumi sec ~ 90 (sec)
218  }
219 
220  if (totltime==0.) totltime=1.;
221 
222  //
223  //--- Make the integrated plots with rate (Hz)
224 
225  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); ic != _FolderNames.end(); ic++)
226  {
227 
228  std::string DirName;
229  DirName = dirName+*ic;
230 
231  makeRatePlot(DirName,totltime);
232  if (_hlt_HighPtJet.size()) makeRatePlot(DirName+"/"+_hlt_HighPtJet,totltime);
233  if (_hlt_LowPtJet.size()) makeRatePlot(DirName+"/"+_hlt_LowPtJet,totltime);
234  if (_hlt_HighMET.size()) makeRatePlot(DirName+"/"+_hlt_HighMET,totltime);
235  if (_hlt_LowMET.size()) makeRatePlot(DirName+"/"+_hlt_LowMET,totltime);
236  if (_hlt_Ele.size()) makeRatePlot(DirName+"/"+_hlt_Ele,totltime);
237  if (_hlt_Muon.size()) makeRatePlot(DirName+"/"+_hlt_Muon,totltime);
238 
239  }
240 }
241 
242 // ***********************************************************
243 void TcMETAnalyzer::makeRatePlot(std::string DirName, double totltime)
244 {
245 
246  _dbe->setCurrentFolder(DirName);
247  MonitorElement *meTcMET = _dbe->get(DirName+"/"+"METTask_TcMET");
248 
249  TH1F* tTcMET;
250  TH1F* tTcMETRate;
251 
252  if ( meTcMET )
253  if ( meTcMET->getRootObject() ) {
254  tTcMET = meTcMET->getTH1F();
255 
256  // Integral plot & convert number of events to rate (hz)
257  tTcMETRate = (TH1F*) tTcMET->Clone("METTask_TcMETRate");
258  for (int i = tTcMETRate->GetNbinsX()-1; i>=0; i--){
259  tTcMETRate->SetBinContent(i+1,tTcMETRate->GetBinContent(i+2)+tTcMET->GetBinContent(i+1));
260  }
261  for (int i = 0; i<tTcMETRate->GetNbinsX(); i++){
262  tTcMETRate->SetBinContent(i+1,tTcMETRate->GetBinContent(i+1)/double(totltime));
263  }
264 
265  meTcMETRate = _dbe->book1D("METTask_TcMETRate",tTcMETRate);
266 
267  }
268 
269 }
270 
271 // ***********************************************************
272 void TcMETAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup,
273  const edm::TriggerResults& triggerResults) {
274 
275  if (_verbose) std::cout << "TcMETAnalyzer analyze" << std::endl;
276 
277  LogTrace(metname)<<"[TcMETAnalyzer] Analyze TcMET";
278 
279  metME->Fill(2);
280 
281  // ==========================================================
282  // Trigger information
283  //
284  _trig_JetMB=0;
285  _trig_HighPtJet=0;
286  _trig_LowPtJet=0;
287  _trig_HighMET=0;
288  _trig_LowMET=0;
289  if(&triggerResults) {
290 
292 
293  //
294  //
295  // Check how many HLT triggers are in triggerResults
296  int ntrigs = triggerResults.size();
297  if (_verbose) std::cout << "ntrigs=" << ntrigs << std::endl;
298 
299  //
300  //
301  // If index=ntrigs, this HLT trigger doesn't exist in the HLT table for this data.
302  const edm::TriggerNames & triggerNames = iEvent.triggerNames(triggerResults);
303 
304  //
305  //
306  // count number of requested Jet or MB HLT paths which have fired
307  for (unsigned int i=0; i!=HLTPathsJetMBByName_.size(); i++) {
308  unsigned int triggerIndex = triggerNames.triggerIndex(HLTPathsJetMBByName_[i]);
309  if (triggerIndex<triggerResults.size()) {
310  if (triggerResults.accept(triggerIndex)) {
311  _trig_JetMB++;
312  }
313  }
314  }
315  // for empty input vectors (n==0), take all HLT triggers!
316  if (HLTPathsJetMBByName_.size()==0) _trig_JetMB=triggerResults.size()-1;
317 
318  //
319  if (_verbose) std::cout << "triggerNames size" << " " << triggerNames.size() << std::endl;
320  if (_verbose) std::cout << _hlt_HighPtJet << " " << triggerNames.triggerIndex(_hlt_HighPtJet) << std::endl;
321  if (_verbose) std::cout << _hlt_LowPtJet << " " << triggerNames.triggerIndex(_hlt_LowPtJet) << std::endl;
322  if (_verbose) std::cout << _hlt_HighMET << " " << triggerNames.triggerIndex(_hlt_HighMET) << std::endl;
323  if (_verbose) std::cout << _hlt_LowMET << " " << triggerNames.triggerIndex(_hlt_LowMET) << std::endl;
324  if (_verbose) std::cout << _hlt_Ele << " " << triggerNames.triggerIndex(_hlt_Ele) << std::endl;
325  if (_verbose) std::cout << _hlt_Muon << " " << triggerNames.triggerIndex(_hlt_Muon) << std::endl;
326 
327  if (triggerNames.triggerIndex(_hlt_HighPtJet) != triggerNames.size() &&
328  triggerResults.accept(triggerNames.triggerIndex(_hlt_HighPtJet))) _trig_HighPtJet=1;
329 
330  if (triggerNames.triggerIndex(_hlt_LowPtJet) != triggerNames.size() &&
331  triggerResults.accept(triggerNames.triggerIndex(_hlt_LowPtJet))) _trig_LowPtJet=1;
332 
333  if (triggerNames.triggerIndex(_hlt_HighMET) != triggerNames.size() &&
334  triggerResults.accept(triggerNames.triggerIndex(_hlt_HighMET))) _trig_HighMET=1;
335 
336  if (triggerNames.triggerIndex(_hlt_LowMET) != triggerNames.size() &&
337  triggerResults.accept(triggerNames.triggerIndex(_hlt_LowMET))) _trig_LowMET=1;
338 
339  if (triggerNames.triggerIndex(_hlt_Ele) != triggerNames.size() &&
340  triggerResults.accept(triggerNames.triggerIndex(_hlt_Ele))) _trig_Ele=1;
341 
342  if (triggerNames.triggerIndex(_hlt_Muon) != triggerNames.size() &&
343  triggerResults.accept(triggerNames.triggerIndex(_hlt_Muon))) _trig_Muon=1;
344 
345  } else {
346 
347  edm::LogInfo("TcMetAnalyzer") << "TriggerResults::HLT not found, "
348  "automatically select events";
349 
350  // TriggerResults object not found. Look at all events.
351  _trig_JetMB=1;
352  }
353 
354  // ==========================================================
355  // TcMET information
356 
357  // **** Get the MET container
358  edm::Handle<reco::METCollection> tcmetcoll;
359  iEvent.getByLabel(theTcMETCollectionLabel, tcmetcoll);
360 
361  if(!tcmetcoll.isValid()) return;
362 
363  const METCollection *tcmetcol = tcmetcoll.product();
364  const MET *tcmet;
365  tcmet = &(tcmetcol->front());
366 
367  LogTrace(metname)<<"[TcMETAnalyzer] Call to the TcMET analyzer";
368 
369  // ==========================================================
370  //
371  edm::Handle<HcalNoiseRBXCollection> HRBXCollection;
372  iEvent.getByLabel(HcalNoiseRBXCollectionTag,HRBXCollection);
373  if (!HRBXCollection.isValid()) {
374  LogDebug("") << "TcMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
375  if (_verbose) std::cout << "TcMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
376  }
377 
378  edm::Handle<HcalNoiseSummary> HNoiseSummary;
379  iEvent.getByLabel(HcalNoiseSummaryTag,HNoiseSummary);
380  if (!HNoiseSummary.isValid()) {
381  LogDebug("") << "TcMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
382  if (_verbose) std::cout << "TcMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
383  }
384 
385  edm::Handle<reco::CaloJetCollection> caloJets;
386  iEvent.getByLabel(theJetCollectionLabel, caloJets);
387  if (!caloJets.isValid()) {
388  LogDebug("") << "TcMETAnalyzer: Could not find jet product" << std::endl;
389  if (_verbose) std::cout << "TcMETAnalyzer: Could not find jet product" << std::endl;
390  }
391 
392  // ==========================================================
393  // TcMET sanity check
394 
395  // if (_source=="TcMET") validateMET(*tcmet, tcCandidates);
396 
397  // ==========================================================
398  // JetID
399 
400  if (_verbose) std::cout << "JetID starts" << std::endl;
401 
402  //
403  // --- Loose cuts, not Tc specific for now!
404  //
405  bool bJetID=true;
406  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
407  cal!=caloJets->end(); ++cal){
408  jetID->calculate(iEvent, *cal);
409  if (_verbose) std::cout << jetID->n90Hits() << " "
410  << jetID->restrictedEMF() << " "
411  << cal->pt() << std::endl;
412  if (cal->pt()>10.){
413  //
414  // for all regions
415  if (jetID->n90Hits()<2) bJetID=false;
416  if (jetID->fHPD()>=0.98) bJetID=false;
417  //if (jetID->restrictedEMF()<0.01) bJetID=false;
418  //
419  // for non-forward
420  if (fabs(cal->eta())<2.55){
421  if (cal->emEnergyFraction()<=0.01) bJetID=false;
422  }
423  // for forward
424  else {
425  if (cal->emEnergyFraction()<=-0.9) bJetID=false;
426  if (cal->pt()>80.){
427  if (cal->emEnergyFraction()>= 1.0) bJetID=false;
428  }
429  } // forward vs non-forward
430  } // pt>10 GeV/c
431  } // calor-jets loop
432 
433  //
434  // --- Tight cuts
435  //
436  bool bJetIDTight=true;
437  bJetIDTight=bJetID;
438  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
439  cal!=caloJets->end(); ++cal){
440  jetID->calculate(iEvent, *cal);
441  if (cal->pt()>25.){
442  //
443  // for all regions
444  if (jetID->fHPD()>=0.95) bJetIDTight=false;
445  //
446  // for 1.0<|eta|<1.75
447  if (fabs(cal->eta())>=1.00 && fabs(cal->eta())<1.75){
448  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
449  }
450  //
451  // for 1.75<|eta|<2.55
452  else if (fabs(cal->eta())>=1.75 && fabs(cal->eta())<2.55){
453  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
454  }
455  //
456  // for 2.55<|eta|<3.25
457  else if (fabs(cal->eta())>=2.55 && fabs(cal->eta())<3.25){
458  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3) bJetIDTight=false;
459  if (cal->pt()>=50. && cal->pt()< 80. && cal->emEnergyFraction()<=-0.2) bJetIDTight=false;
460  if (cal->pt()>=80. && cal->pt()<340. && cal->emEnergyFraction()<=-0.1) bJetIDTight=false;
461  if (cal->pt()>=340. && cal->emEnergyFraction()<=-0.1
462  && cal->emEnergyFraction()>=0.95) bJetIDTight=false;
463  }
464  //
465  // for 3.25<|eta|
466  else if (fabs(cal->eta())>=3.25){
467  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3
468  && cal->emEnergyFraction()>=0.90) bJetIDTight=false;
469  if (cal->pt()>=50. && cal->pt()<130. && cal->emEnergyFraction()<=-0.2
470  && cal->emEnergyFraction()>=0.80) bJetIDTight=false;
471  if (cal->pt()>=130. && cal->emEnergyFraction()<=-0.1
472  && cal->emEnergyFraction()>=0.70) bJetIDTight=false;
473  }
474  } // pt>10 GeV/c
475  } // calor-jets loop
476 
477  if (_verbose) std::cout << "JetID ends" << std::endl;
478 
479 
480  // ==========================================================
481  // HCAL Noise filter
482 
483  bool bHcalNoiseFilter = HNoiseSummary->passLooseNoiseFilter();
484  bool bHcalNoiseFilterTight = HNoiseSummary->passTightNoiseFilter();
485 
486  // ==========================================================
487  // Reconstructed MET Information - fill MonitorElements
488 
489  std::string DirName = "JetMET/MET/"+_source;
490 
491  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
492  ic != _FolderNames.end(); ic++){
493  if (*ic=="All") fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
494  if (*ic=="Cleanup" && bHcalNoiseFilter && bJetID) fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
495  if (_allSelection) {
496  if (*ic=="HcalNoiseFilter" && bHcalNoiseFilter ) fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
497  if (*ic=="HcalNoiseFilterTight" && bHcalNoiseFilterTight ) fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
498  if (*ic=="JetID" && bJetID) fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
499  if (*ic=="JetIDTight" && bJetIDTight) fillMESet(iEvent, DirName+"/"+*ic, *tcmet);
500  }
501  }
502 }
503 
504 // ***********************************************************
505 void TcMETAnalyzer::fillMESet(const edm::Event& iEvent, std::string DirName,
506  const reco::MET& tcmet)
507 {
508 
509  _dbe->setCurrentFolder(DirName);
510 
511  bool bLumiSecPlot=false;
512  if (DirName.find("All")) bLumiSecPlot=true;
513 
514  if (_trig_JetMB) fillMonitorElement(iEvent,DirName,"",tcmet, bLumiSecPlot);
515  if (_hlt_HighPtJet.size() && _trig_HighPtJet) fillMonitorElement(iEvent,DirName,"HighPtJet",tcmet,false);
516  if (_hlt_LowPtJet.size() && _trig_LowPtJet) fillMonitorElement(iEvent,DirName,"LowPtJet",tcmet,false);
517  if (_hlt_HighMET.size() && _trig_HighMET) fillMonitorElement(iEvent,DirName,"HighMET",tcmet,false);
518  if (_hlt_LowMET.size() && _trig_LowMET) fillMonitorElement(iEvent,DirName,"LowMET",tcmet,false);
519  if (_hlt_Ele.size() && _trig_Ele) fillMonitorElement(iEvent,DirName,"Ele",tcmet,false);
520  if (_hlt_Muon.size() && _trig_Muon) fillMonitorElement(iEvent,DirName,"Muon",tcmet,false);
521 }
522 
523 // ***********************************************************
524 void TcMETAnalyzer::fillMonitorElement(const edm::Event& iEvent, std::string DirName,
525  std::string TriggerTypeName,
526  const reco::MET& tcmet, bool bLumiSecPlot)
527 {
528 
529  if (TriggerTypeName=="HighPtJet") {
530  if (!selectHighPtJetEvent(iEvent)) return;
531  }
532  else if (TriggerTypeName=="LowPtJet") {
533  if (!selectLowPtJetEvent(iEvent)) return;
534  }
535  else if (TriggerTypeName=="HighMET") {
536  if (tcmet.pt()<_highTcMETThreshold) return;
537  }
538  else if (TriggerTypeName=="LowMET") {
539  if (tcmet.pt()<_lowTcMETThreshold) return;
540  }
541  else if (TriggerTypeName=="Ele") {
542  if (!selectWElectronEvent(iEvent)) return;
543  }
544  else if (TriggerTypeName=="Muon") {
545  if (!selectWMuonEvent(iEvent)) return;
546  }
547 
548 // Reconstructed MET Information
549  double tcSumET = tcmet.sumEt();
550  double tcMETSig = tcmet.mEtSig();
551  double tcEz = tcmet.e_longitudinal();
552  double tcMET = tcmet.pt();
553  double tcMEx = tcmet.px();
554  double tcMEy = tcmet.py();
555  double tcMETPhi = tcmet.phi();
556 
557  //
558  int myLuminosityBlock;
559  // myLuminosityBlock = (evtCounter++)/1000;
560  myLuminosityBlock = iEvent.luminosityBlock();
561  //
562 
563  if (TriggerTypeName!="") DirName = DirName +"/"+TriggerTypeName;
564 
565  if (_verbose) std::cout << "_etThreshold = " << _etThreshold << std::endl;
566  if (tcMET>_etThreshold){
567 
568  meTcMEx = _dbe->get(DirName+"/"+"METTask_TcMEx"); if (meTcMEx && meTcMEx->getRootObject()) meTcMEx->Fill(tcMEx);
569  meTcMEy = _dbe->get(DirName+"/"+"METTask_TcMEy"); if (meTcMEy && meTcMEy->getRootObject()) meTcMEy->Fill(tcMEy);
570  meTcMET = _dbe->get(DirName+"/"+"METTask_TcMET"); if (meTcMET && meTcMET->getRootObject()) meTcMET->Fill(tcMET);
571  meTcMETPhi = _dbe->get(DirName+"/"+"METTask_TcMETPhi"); if (meTcMETPhi && meTcMETPhi->getRootObject()) meTcMETPhi->Fill(tcMETPhi);
572  meTcSumET = _dbe->get(DirName+"/"+"METTask_TcSumET"); if (meTcSumET && meTcSumET->getRootObject()) meTcSumET->Fill(tcSumET);
573  meTcMETSig = _dbe->get(DirName+"/"+"METTask_TcMETSig"); if (meTcMETSig && meTcMETSig->getRootObject()) meTcMETSig->Fill(tcMETSig);
574  meTcEz = _dbe->get(DirName+"/"+"METTask_TcEz"); if (meTcEz && meTcEz->getRootObject()) meTcEz->Fill(tcEz);
575 
576  meTcMETIonFeedbck = _dbe->get(DirName+"/"+"METTask_TcMETIonFeedbck"); if (meTcMETIonFeedbck && meTcMETIonFeedbck->getRootObject()) meTcMETIonFeedbck->Fill(tcMET);
577  meTcMETHPDNoise = _dbe->get(DirName+"/"+"METTask_TcMETHPDNoise"); if (meTcMETHPDNoise && meTcMETHPDNoise->getRootObject()) meTcMETHPDNoise->Fill(tcMET);
578  meTcMETRBXNoise = _dbe->get(DirName+"/"+"METTask_TcMETRBXNoise"); if (meTcMETRBXNoise && meTcMETRBXNoise->getRootObject()) meTcMETRBXNoise->Fill(tcMET);
579 
580  if (_allhist){
581  if (bLumiSecPlot){
582  meTcMExLS = _dbe->get(DirName+"/"+"METTask_TcMExLS"); if (meTcMExLS && meTcMExLS->getRootObject()) meTcMExLS->Fill(tcMEx,myLuminosityBlock);
583  meTcMEyLS = _dbe->get(DirName+"/"+"METTask_TcMEyLS"); if (meTcMEyLS && meTcMEyLS->getRootObject()) meTcMEyLS->Fill(tcMEy,myLuminosityBlock);
584  }
585  } // _allhist
586  } // et threshold cut
587 }
588 
589 // ***********************************************************
590 bool TcMETAnalyzer::selectHighPtJetEvent(const edm::Event& iEvent){
591 
592  bool return_value=false;
593 
594  edm::Handle<reco::CaloJetCollection> caloJets;
595  iEvent.getByLabel(theJetCollectionLabel, caloJets);
596  if (!caloJets.isValid()) {
597  LogDebug("") << "TcMETAnalyzer: Could not find jet product" << std::endl;
598  if (_verbose) std::cout << "TcMETAnalyzer: Could not find jet product" << std::endl;
599  }
600 
601  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
602  cal!=caloJets->end(); ++cal){
603  if (cal->pt()>_highPtTcJetThreshold){
604  return_value=true;
605  }
606  }
607 
608  return return_value;
609 }
610 
611 // // ***********************************************************
612 bool TcMETAnalyzer::selectLowPtJetEvent(const edm::Event& iEvent){
613 
614  bool return_value=false;
615 
616  edm::Handle<reco::CaloJetCollection> caloJets;
617  iEvent.getByLabel(theJetCollectionLabel, caloJets);
618  if (!caloJets.isValid()) {
619  LogDebug("") << "TcMETAnalyzer: Could not find jet product" << std::endl;
620  if (_verbose) std::cout << "TcMETAnalyzer: Could not find jet product" << std::endl;
621  }
622 
623  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
624  cal!=caloJets->end(); ++cal){
625  if (cal->pt()>_lowPtTcJetThreshold){
626  return_value=true;
627  }
628  }
629 
630  return return_value;
631 
632 }
633 
634 // ***********************************************************
635 bool TcMETAnalyzer::selectWElectronEvent(const edm::Event& iEvent){
636 
637  bool return_value=false;
638 
639  /*
640  W-electron event selection comes here
641  */
642 
643  return return_value;
644 
645 }
646 
647 // ***********************************************************
648 bool TcMETAnalyzer::selectWMuonEvent(const edm::Event& iEvent){
649 
650  bool return_value=false;
651 
652  /*
653  W-muon event selection comes here
654  */
655 
656  return return_value;
657 
658 }
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:510
Pi
const double Pi
Definition: CosmicMuonParameters.h:18
reco::MET::e_longitudinal
double e_longitudinal() const
Definition: MET.h:55
i
int i
Definition: DBlmapReader.cc:9
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:208
TcMETAnalyzer::beginJob
void beginJob(DQMStore *dbe)
Inizialize parameters for histo binning.
Definition: TcMETAnalyzer.cc:39
TcMETAnalyzer::selectWElectronEvent
bool selectWElectronEvent(const edm::Event &)
Definition: TcMETAnalyzer.cc:635
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:519
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:47
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:54
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:876
edm::EventBase::luminosityBlock
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:59
edm::TriggerNames::size
Strings::size_type size() const
Definition: TriggerNames.cc:39
TcMETAnalyzer::bookMESet
void bookMESet(std::string)
Definition: TcMETAnalyzer.cc:115
TcMETAnalyzer::bookMonitorElement
void bookMonitorElement(std::string, bool)
Definition: TcMETAnalyzer.cc:156
reco::MET::mEtSig
double mEtSig() const
Definition: MET.h:50
iEvent
int iEvent
Definition: GenABIO.cc:243
reco::MET::sumEt
double sumEt() const
Definition: MET.h:48
TcMETAnalyzer::fillMonitorElement
void fillMonitorElement(const edm::Event &, std::string, std::string, const reco::MET &, bool)
Definition: TcMETAnalyzer.cc:524
TcMETAnalyzer::analyze
void analyze(const edm::Event &, const edm::EventSetup &, const edm::TriggerResults &)
Get the analysis.
Definition: TcMETAnalyzer.cc:272
TcMETAnalyzer::fillMESet
void fillMESet(const edm::Event &, std::string, const reco::MET &)
Definition: TcMETAnalyzer.cc:505
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
TcMETAnalyzer::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Initialize run-based parameters.
Definition: TcMETAnalyzer.cc:190
dt_offlineAnalysis_common_cff.reco
tuple reco
Definition: dt_offlineAnalysis_common_cff.py:54
reco::MET
Definition: MET.h:32
TrackerOfflineValidation_Dqm_cff.dirName
tuple dirName
Definition: TrackerOfflineValidation_Dqm_cff.py:56
edm::HLTGlobalStatus::size
unsigned int size() const
Get number of paths stored.
Definition: HLTGlobalStatus.h:41
ExpressReco_HICollisions_FallBack.DirName
tuple DirName
Definition: ExpressReco_HICollisions_FallBack.py:17111
METCollection
Collection of MET.
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
TcMETAnalyzer::selectLowPtJetEvent
bool selectLowPtJetEvent(const edm::Event &)
Definition: TcMETAnalyzer.cc:612
edm::Event::getByLabel
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:359
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:511
TcMETAnalyzer::~TcMETAnalyzer
virtual ~TcMETAnalyzer()
Destructor.
Definition: TcMETAnalyzer.cc:37
MonitorElement::getRootObject
TObject * getRootObject(void) const
Definition: MonitorElement.cc:1459
reco::LeafCandidate::px
virtual double px() const
x coordinate of momentum vector
Definition: LeafCandidate.h:131
TcMETAnalyzer::TcMETAnalyzer
TcMETAnalyzer(const edm::ParameterSet &)
Constructor.
Definition: TcMETAnalyzer.cc:30
reco::LeafCandidate::pt
virtual double pt() const
transverse momentum
Definition: LeafCandidate.cc:127
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1473
edm::Handle::product
T const * product() const
Definition: Handle.h:74
ExpressReco_HICollisions_FallBack.parameters
tuple parameters
Definition: ExpressReco_HICollisions_FallBack.py:22416
TcMETAnalyzer::selectHighPtJetEvent
bool selectHighPtJetEvent(const edm::Event &)
Definition: TcMETAnalyzer.cc:590
TcMETAnalyzer::endJob
void endJob()
Finish up a job.
Definition: TcMETAnalyzer.cc:108
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
TcMETAnalyzer::selectWMuonEvent
bool selectWMuonEvent(const edm::Event &)
Definition: TcMETAnalyzer.cc:648
TcMETAnalyzer::makeRatePlot
void makeRatePlot(std::string, double)
Definition: TcMETAnalyzer.cc:243
reco::LeafCandidate::phi
virtual double phi() const
momentum azimuthal angle
Definition: LeafCandidate.h:139
reco::LeafCandidate::py
virtual double py() const
y coordinate of momentum vector
Definition: LeafCandidate.h:133
TcMETAnalyzer::endRun
void endRun(const edm::Run &iRun, const edm::EventSetup &iSetup, DQMStore *dbe)
Finish up a run.
Definition: TcMETAnalyzer.cc:196
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:237
edm::Run
Definition: Run.h:31
Generated for CMSSW Reference Manual by doxygen 1.8.5