CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
METAnalyzer.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * $Date: 2011/04/02 13:52:48 $
5  * $Revision: 1.38.6.1 $
6  * \author A.Apresyan - Caltech
7  * K.Hatakeyama - Baylor
8  */
9 
13 
15 
17 
22 
24 
28 
29 #include <string>
30 using namespace edm;
31 using namespace reco;
32 using namespace math;
33 
34 // ***********************************************************
36 
37  parameters = pSet;
38 
39  edm::ParameterSet highptjetparms = parameters.getParameter<edm::ParameterSet>("highPtJetTrigger");
40  edm::ParameterSet lowptjetparms = parameters.getParameter<edm::ParameterSet>("lowPtJetTrigger" );
41  edm::ParameterSet minbiasparms = parameters.getParameter<edm::ParameterSet>("minBiasTrigger" );
42  edm::ParameterSet highmetparms = parameters.getParameter<edm::ParameterSet>("highMETTrigger" );
43  edm::ParameterSet lowmetparms = parameters.getParameter<edm::ParameterSet>("lowMETTrigger" );
44  edm::ParameterSet eleparms = parameters.getParameter<edm::ParameterSet>("eleTrigger" );
45  edm::ParameterSet muonparms = parameters.getParameter<edm::ParameterSet>("muonTrigger" );
46 
47  _hlt_HighPtJet = highptjetparms.getParameter<std::string>("hltDBKey");
48  _hlt_LowPtJet = lowptjetparms .getParameter<std::string>("hltDBKey");
49  _hlt_MinBias = minbiasparms .getParameter<std::string>("hltDBKey");
50  _hlt_HighMET = highmetparms .getParameter<std::string>("hltDBKey");
51  _hlt_LowMET = lowmetparms .getParameter<std::string>("hltDBKey");
52  _hlt_Ele = eleparms .getParameter<std::string>("hltDBKey");
53  _hlt_Muon = muonparms .getParameter<std::string>("hltDBKey");
54 
55  //genericTriggerEventFlag_( new GenericTriggerEventFlag( conf_ ) );
56  _HighPtJetEventFlag = new GenericTriggerEventFlag( highptjetparms );
57  _LowPtJetEventFlag = new GenericTriggerEventFlag( lowptjetparms );
58  _MinBiasEventFlag = new GenericTriggerEventFlag( minbiasparms );
59  _HighMETEventFlag = new GenericTriggerEventFlag( highmetparms );
60  _LowMETEventFlag = new GenericTriggerEventFlag( lowmetparms );
61  _EleEventFlag = new GenericTriggerEventFlag( eleparms );
62  _MuonEventFlag = new GenericTriggerEventFlag( muonparms );
63 
64 }
65 
66 // ***********************************************************
68 
69  delete _HighPtJetEventFlag;
70  delete _LowPtJetEventFlag;
71  delete _MinBiasEventFlag;
72  delete _HighMETEventFlag;
73  delete _LowMETEventFlag;
74  delete _EleEventFlag;
75  delete _MuonEventFlag;
76 
77 }
78 
80 
81  evtCounter = 0;
82  metname = "METAnalyzer";
83 
84  // trigger information
85  HLTPathsJetMBByName_ = parameters.getParameter<std::vector<std::string > >("HLTPathsJetMB");
86 
87  theCleaningParameters = parameters.getParameter<ParameterSet>("CleaningParameters"),
88 
89  //Trigger parameters
90  gtTag = theCleaningParameters.getParameter<edm::InputTag>("gtLabel");
91  _techTrigsAND = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsAND");
92  _techTrigsOR = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsOR");
93  _techTrigsNOT = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsNOT");
94 
95  _doHLTPhysicsOn = theCleaningParameters.getParameter<bool>("doHLTPhysicsOn");
96  _hlt_PhysDec = theCleaningParameters.getParameter<std::string>("HLT_PhysDec");
97 
98  _tightBHFiltering = theCleaningParameters.getParameter<bool>("tightBHFiltering");
99  _tightJetIDFiltering = theCleaningParameters.getParameter<int>("tightJetIDFiltering");
100  _tightHcalFiltering = theCleaningParameters.getParameter<bool>("tightHcalFiltering");
101 
102  // ==========================================================
103  //DCS information
104  // ==========================================================
105  DCSFilter = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilter"));
106 
107  //Vertex requirements
108  _doPVCheck = theCleaningParameters.getParameter<bool>("doPrimaryVertexCheck");
109  vertexTag = theCleaningParameters.getParameter<edm::InputTag>("vertexLabel");
110 
111  if (_doPVCheck) {
112  _nvtx_min = theCleaningParameters.getParameter<int>("nvtx_min");
113  _nvtxtrks_min = theCleaningParameters.getParameter<int>("nvtxtrks_min");
114  _vtxndof_min = theCleaningParameters.getParameter<int>("vtxndof_min");
115  _vtxchi2_max = theCleaningParameters.getParameter<double>("vtxchi2_max");
116  _vtxz_max = theCleaningParameters.getParameter<double>("vtxz_max");
117  }
118 
119  // MET information
120  theMETCollectionLabel = parameters.getParameter<edm::InputTag>("METCollectionLabel");
121  _source = parameters.getParameter<std::string>("Source");
122 
123  if (theMETCollectionLabel.label() == "tcMet" ) {
124  inputTrackLabel = parameters.getParameter<edm::InputTag>("InputTrackLabel");
125  inputMuonLabel = parameters.getParameter<edm::InputTag>("InputMuonLabel");
126  inputElectronLabel = parameters.getParameter<edm::InputTag>("InputElectronLabel");
127  inputBeamSpotLabel = parameters.getParameter<edm::InputTag>("InputBeamSpotLabel");
128  }
129 
130  // Other data collections
131  theJetCollectionLabel = parameters.getParameter<edm::InputTag>("JetCollectionLabel");
132  HcalNoiseRBXCollectionTag = parameters.getParameter<edm::InputTag>("HcalNoiseRBXCollection");
133  HcalNoiseSummaryTag = parameters.getParameter<edm::InputTag>("HcalNoiseSummary");
134  BeamHaloSummaryTag = parameters.getParameter<edm::InputTag>("BeamHaloSummaryLabel");
135 
136  // misc
137  _verbose = parameters.getParameter<int>("verbose");
138  _etThreshold = parameters.getParameter<double>("etThreshold"); // MET threshold
139  _allhist = parameters.getParameter<bool>("allHist"); // Full set of monitoring histograms
140  _allSelection = parameters.getParameter<bool>("allSelection"); // Plot with all sets of event selection
141  _cleanupSelection = parameters.getParameter<bool>("cleanupSelection"); // Plot with all sets of event selection
142 
143  _FolderName = parameters.getUntrackedParameter<std::string>("FolderName");
144 
145  _highPtJetThreshold = parameters.getParameter<double>("HighPtJetThreshold"); // High Pt Jet threshold
146  _lowPtJetThreshold = parameters.getParameter<double>("LowPtJetThreshold"); // Low Pt Jet threshold
147  _highMETThreshold = parameters.getParameter<double>("HighMETThreshold"); // High MET threshold
148  _lowMETThreshold = parameters.getParameter<double>("LowMETThreshold"); // Low MET threshold
149 
150  //
151  jetID = new reco::helper::JetIDHelper(parameters.getParameter<ParameterSet>("JetIDParams"));
152 
153  // DQStore stuff
154  LogTrace(metname)<<"[METAnalyzer] Parameters initialization";
155  std::string DirName = _FolderName+_source;
156  dbe->setCurrentFolder(DirName);
157 
158  hmetME = dbe->book1D("metReco", "metReco", 4, 1, 5);
159  hmetME->setBinLabel(2,"MET",1);
160 
161  _dbe = dbe;
162 
163  _FolderNames.push_back("All");
164  _FolderNames.push_back("BasicCleanup");
165  _FolderNames.push_back("ExtraCleanup");
166  _FolderNames.push_back("HcalNoiseFilter");
167  _FolderNames.push_back("HcalNoiseFilterTight");
168  _FolderNames.push_back("JetIDMinimal");
169  _FolderNames.push_back("JetIDLoose");
170  _FolderNames.push_back("JetIDTight");
171  _FolderNames.push_back("BeamHaloIDTightPass");
172  _FolderNames.push_back("BeamHaloIDLoosePass");
173  _FolderNames.push_back("Triggers");
174  _FolderNames.push_back("PV");
175 
176  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
177  ic != _FolderNames.end(); ic++){
178  if (*ic=="All") bookMESet(DirName+"/"+*ic);
179  if (_cleanupSelection){
180  if (*ic=="BasicCleanup") bookMESet(DirName+"/"+*ic);
181  if (*ic=="ExtraCleanup") bookMESet(DirName+"/"+*ic);
182  }
183  if (_allSelection){
184  if (*ic=="HcalNoiseFilter") bookMESet(DirName+"/"+*ic);
185  if (*ic=="HcalNoiseFilterTight") bookMESet(DirName+"/"+*ic);
186  if (*ic=="JetIDMinimal") bookMESet(DirName+"/"+*ic);
187  if (*ic=="JetIDLoose") bookMESet(DirName+"/"+*ic);
188  if (*ic=="JetIDTight") bookMESet(DirName+"/"+*ic);
189  if (*ic=="BeamHaloIDTightPass") bookMESet(DirName+"/"+*ic);
190  if (*ic=="BeamHaloIDLoosePass") bookMESet(DirName+"/"+*ic);
191  if (*ic=="Triggers") bookMESet(DirName+"/"+*ic);
192  if (*ic=="PV") bookMESet(DirName+"/"+*ic);
193  }
194  }
195 }
196 
197 // ***********************************************************
199 
200  delete jetID;
201  delete DCSFilter;
202 
203 }
204 
205 // ***********************************************************
207 {
208 
209  bool bLumiSecPlot=false;
210  if (DirName.find("All")!=std::string::npos) bLumiSecPlot=true;
211 
212  bookMonitorElement(DirName,bLumiSecPlot);
213 
214  if ( _HighPtJetEventFlag->on() ) {
215  bookMonitorElement(DirName+"/"+"HighPtJet",false);
216  hTriggerName_HighPtJet = _dbe->bookString("triggerName_HighPtJet", _hlt_HighPtJet);
217  }
218 
219  if ( _LowPtJetEventFlag->on() ) {
220  bookMonitorElement(DirName+"/"+"LowPtJet",false);
221  hTriggerName_LowPtJet = _dbe->bookString("triggerName_LowPtJet", _hlt_LowPtJet);
222  }
223 
224  if ( _MinBiasEventFlag->on() ) {
225  bookMonitorElement(DirName+"/"+"MinBias",false);
226  hTriggerName_MinBias = _dbe->bookString("triggerName_MinBias", _hlt_MinBias);
227  }
228 
229  if ( _HighMETEventFlag->on() ) {
230  bookMonitorElement(DirName+"/"+"HighMET",false);
231  hTriggerName_HighMET = _dbe->bookString("triggerName_HighMET", _hlt_HighMET);
232  }
233 
234  if ( _LowMETEventFlag->on() ) {
235  bookMonitorElement(DirName+"/"+"LowMET",false);
236  hTriggerName_LowMET = _dbe->bookString("triggerName_LowMET", _hlt_LowMET);
237  }
238 
239  if ( _EleEventFlag->on() ) {
240  bookMonitorElement(DirName+"/"+"Ele",false);
241  hTriggerName_Ele = _dbe->bookString("triggerName_Ele", _hlt_Ele);
242  }
243 
244  if ( _MuonEventFlag->on() ) {
245  bookMonitorElement(DirName+"/"+"Muon",false);
246  hTriggerName_Muon = _dbe->bookString("triggerName_Muon", _hlt_Muon);
247  }
248 }
249 
250 // ***********************************************************
251 void METAnalyzer::bookMonitorElement(std::string DirName, bool bLumiSecPlot=false)
252 {
253 
254  if (_verbose) std::cout << "bookMonitorElement " << DirName << std::endl;
255  _dbe->setCurrentFolder(DirName);
256 
257  hNevents = _dbe->book1D("METTask_Nevents", "METTask_Nevents" ,1,0,1);
258  hMEx = _dbe->book1D("METTask_MEx", "METTask_MEx" ,500,-500,500);
259  hMEx->setAxisTitle("MEx [GeV]",1);
260  hMEy = _dbe->book1D("METTask_MEy", "METTask_MEy" ,500,-500,500);
261  hMEy->setAxisTitle("MEy [GeV]",1);
262  hEz = _dbe->book1D("METTask_Ez", "METTask_Ez" ,500,-500,500);
263  hEz->setAxisTitle("MEz [GeV]",1);
264  hMETSig = _dbe->book1D("METTask_METSig","METTask_METSig",51,0,51);
265  hMETSig->setAxisTitle("CaloMETSig",1);
266  hMET = _dbe->book1D("METTask_MET", "METTask_MET" ,500,0,1000);
267  hMET->setAxisTitle("MET [GeV]",1);
268  hMETPhi = _dbe->book1D("METTask_METPhi","METTask_METPhi",80,-TMath::Pi(),TMath::Pi());
269  hMETPhi->setAxisTitle("METPhi [rad]",1);
270  hSumET = _dbe->book1D("METTask_SumET", "METTask_SumET" ,500,0,2000);
271  hSumET->setAxisTitle("SumET [GeV]",1);
272 
273  hMET_logx = _dbe->book1D("METTask_MET_logx", "METTask_MET_logx" ,40,-1.,7.);
274  hMET_logx->setAxisTitle("log(MET) [GeV]",1);
275  hSumET_logx = _dbe->book1D("METTask_SumET_logx", "METTask_SumET_logx" ,40,-1.,7.);
276  hSumET_logx->setAxisTitle("log(SumET) [GeV]",1);
277 
278  hMETIonFeedbck = _dbe->book1D("METTask_METIonFeedbck", "METTask_METIonFeedbck" ,500,0,1000);
279  hMETIonFeedbck->setAxisTitle("MET [GeV]",1);
280  hMETHPDNoise = _dbe->book1D("METTask_METHPDNoise", "METTask_METHPDNoise" ,500,0,1000);
281  hMETHPDNoise->setAxisTitle("MET [GeV]",1);
282  hMETRBXNoise = _dbe->book1D("METTask_METRBXNoise", "METTask_METRBXNoise" ,500,0,1000);
283  hMETRBXNoise->setAxisTitle("MET [GeV]",1);
284 
285  if (_allhist){
286  if (bLumiSecPlot){
287  hMExLS = _dbe->book2D("METTask_MEx_LS","METTask_MEx_LS",200,-200,200,50,0.,500.);
288  hMExLS->setAxisTitle("MEx [GeV]",1);
289  hMExLS->setAxisTitle("Lumi Section",2);
290  hMEyLS = _dbe->book2D("METTask_MEy_LS","METTask_MEy_LS",200,-200,200,50,0.,500.);
291  hMEyLS->setAxisTitle("MEy [GeV]",1);
292  hMEyLS->setAxisTitle("Lumi Section",2);
293  }
294  }
295 
296  if (theMETCollectionLabel.label() == "tcMet" ) {
297  htrkPt = _dbe->book1D("METTask_trackPt", "METTask_trackPt", 50, 0, 500);
298  htrkEta = _dbe->book1D("METTask_trackEta", "METTask_trackEta", 60, -3.0, 3.0);
299  htrkNhits = _dbe->book1D("METTask_trackNhits", "METTask_trackNhits", 50, 0, 50);
300  htrkChi2 = _dbe->book1D("METTask_trackNormalizedChi2", "METTask_trackNormalizedChi2", 20, 0, 20);
301  htrkD0 = _dbe->book1D("METTask_trackD0", "METTask_trackd0", 50, -1, 1);
302  helePt = _dbe->book1D("METTask_electronPt", "METTask_electronPt", 50, 0, 500);
303  heleEta = _dbe->book1D("METTask_electronEta", "METTask_electronEta", 60, -3.0, 3.0);
304  heleHoE = _dbe->book1D("METTask_electronHoverE", "METTask_electronHoverE", 25, 0, 0.5);
305  hmuPt = _dbe->book1D("METTask_muonPt", "METTask_muonPt", 50, 0, 500);
306  hmuEta = _dbe->book1D("METTask_muonEta", "METTask_muonEta", 60, -3.0, 3.0);
307  hmuNhits = _dbe->book1D("METTask_muonNhits", "METTask_muonNhits", 50, 0, 50);
308  hmuChi2 = _dbe->book1D("METTask_muonNormalizedChi2", "METTask_muonNormalizedChi2", 20, 0, 20);
309  hmuD0 = _dbe->book1D("METTask_muonD0", "METTask_muonD0", 50, -1, 1);
310  }
311 
312  hMExCorrection = _dbe->book1D("METTask_MExCorrection", "METTask_MExCorrection", 100, -500.0,500.0);
313  hMEyCorrection = _dbe->book1D("METTask_MEyCorrection", "METTask_MEyCorrection", 100, -500.0,500.0);
314  hMuonCorrectionFlag = _dbe->book1D("METTask_CorrectionFlag","METTask_CorrectionFlag", 5, -0.5, 4.5);
315 
316 }
317 
318 // ***********************************************************
319 void METAnalyzer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
320 {
321  if ( _HighPtJetEventFlag->on() ) _HighPtJetEventFlag->initRun( iRun, iSetup );
322  if ( _LowPtJetEventFlag ->on() ) _LowPtJetEventFlag ->initRun( iRun, iSetup );
323  if ( _MinBiasEventFlag ->on() ) _MinBiasEventFlag ->initRun( iRun, iSetup );
324  if ( _HighMETEventFlag ->on() ) _HighMETEventFlag ->initRun( iRun, iSetup );
325  if ( _LowMETEventFlag ->on() ) _LowMETEventFlag ->initRun( iRun, iSetup );
326  if ( _EleEventFlag ->on() ) _EleEventFlag ->initRun( iRun, iSetup );
327  if ( _MuonEventFlag ->on() ) _MuonEventFlag ->initRun( iRun, iSetup );
328 
329 }
330 
331 // ***********************************************************
332 void METAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup, DQMStore * dbe)
333 {
334 
335  //
336  //--- Check the time length of the Run from the lumi section plots
337 
338  std::string dirName = _FolderName+_source+"/";
339  _dbe->setCurrentFolder(dirName);
340 
341  TH1F* tlumisec;
342 
343  MonitorElement *meLumiSec = _dbe->get("aaa");
344  meLumiSec = _dbe->get("JetMET/lumisec");
345 
346  int totlsec=0;
347  double totltime=0.;
348  if ( meLumiSec->getRootObject() ) {
349  tlumisec = meLumiSec->getTH1F();
350  for (int i=0; i<500; i++){
351  if (tlumisec->GetBinContent(i+1)) totlsec++;
352  }
353  totltime = double(totlsec*90); // one lumi sec ~ 90 (sec)
354  }
355 
356  if (totltime==0.) totltime=1.;
357 
358  //
359  //--- Make the integrated plots with rate (Hz)
360 
361  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); ic != _FolderNames.end(); ic++)
362  {
363 
364  std::string DirName;
365  DirName = dirName+*ic;
366 
367  makeRatePlot(DirName,totltime);
368  if ( _HighPtJetEventFlag->on() )
369  makeRatePlot(DirName+"/"+"triggerName_HighJetPt",totltime);
370  if ( _LowPtJetEventFlag->on() )
371  makeRatePlot(DirName+"/"+"triggerName_LowJetPt",totltime);
372  if ( _MinBiasEventFlag->on() )
373  makeRatePlot(DirName+"/"+"triggerName_MinBias",totltime);
374  if ( _HighMETEventFlag->on() )
375  makeRatePlot(DirName+"/"+"triggerName_HighMET",totltime);
376  if ( _LowMETEventFlag->on() )
377  makeRatePlot(DirName+"/"+"triggerName_LowMET",totltime);
378  if ( _EleEventFlag->on() )
379  makeRatePlot(DirName+"/"+"triggerName_Ele",totltime);
380  if ( _MuonEventFlag->on() )
381  makeRatePlot(DirName+"/"+"triggerName_Muon",totltime);
382  }
383 }
384 
385 // ***********************************************************
386 void METAnalyzer::makeRatePlot(std::string DirName, double totltime)
387 {
388 
389  _dbe->setCurrentFolder(DirName);
390  MonitorElement *meMET = _dbe->get(DirName+"/"+"METTask_MET");
391 
392  TH1F* tMET;
393  TH1F* tMETRate;
394 
395  if ( meMET )
396  if ( meMET->getRootObject() ) {
397  tMET = meMET->getTH1F();
398 
399  // Integral plot & convert number of events to rate (hz)
400  tMETRate = (TH1F*) tMET->Clone("METTask_METRate");
401  for (int i = tMETRate->GetNbinsX()-1; i>=0; i--){
402  tMETRate->SetBinContent(i+1,tMETRate->GetBinContent(i+2)+tMET->GetBinContent(i+1));
403  }
404  for (int i = 0; i<tMETRate->GetNbinsX(); i++){
405  tMETRate->SetBinContent(i+1,tMETRate->GetBinContent(i+1)/double(totltime));
406  }
407 
408  tMETRate->SetName("METTask_METRate");
409  tMETRate->SetTitle("METTask_METRate");
410  hMETRate = _dbe->book1D("METTask_METRate",tMETRate);
411  }
412 }
413 
414 // ***********************************************************
416  const edm::TriggerResults& triggerResults) {
417 
418  if (_verbose) std::cout << "METAnalyzer analyze" << std::endl;
419 
420  std::string DirName = _FolderName+_source;
421 
422  LogTrace(metname)<<"[METAnalyzer] Analyze MET";
423 
424  hmetME->Fill(2);
425 
426  // ==========================================================
427  // Trigger information
428  //
429  _trig_JetMB=0;
430  _trig_HighPtJet=0;
431  _trig_LowPtJet=0;
432  _trig_MinBias=0;
433  _trig_HighMET=0;
434  _trig_LowMET=0;
435  _trig_Ele=0;
436  _trig_Muon=0;
437  _trig_PhysDec=0;
438  if(&triggerResults) {
439 
441 
442  //
443  //
444  // Check how many HLT triggers are in triggerResults
445  int ntrigs = triggerResults.size();
446  if (_verbose) std::cout << "ntrigs=" << ntrigs << std::endl;
447 
448  //
449  //
450  // If index=ntrigs, this HLT trigger doesn't exist in the HLT table for this data.
451  const edm::TriggerNames & triggerNames = iEvent.triggerNames(triggerResults);
452 
453  //
454  //
455  // count number of requested Jet or MB HLT paths which have fired
456  for (unsigned int i=0; i!=HLTPathsJetMBByName_.size(); i++) {
457  unsigned int triggerIndex = triggerNames.triggerIndex(HLTPathsJetMBByName_[i]);
458  if (triggerIndex<triggerResults.size()) {
459  if (triggerResults.accept(triggerIndex)) {
460  _trig_JetMB++;
461  }
462  }
463  }
464  // for empty input vectors (n==0), take all HLT triggers!
465  if (HLTPathsJetMBByName_.size()==0) _trig_JetMB=triggerResults.size()-1;
466 
467  //
468  //if (_verbose) std::cout << "triggerNames size" << " " << triggerNames.size() << std::endl;
469  //if (_verbose) std::cout << _hlt_HighPtJet << " " << triggerNames.triggerIndex(_hlt_HighPtJet) << std::endl;
470  //if (_verbose) std::cout << _hlt_LowPtJet << " " << triggerNames.triggerIndex(_hlt_LowPtJet) << std::endl;
471  //if (_verbose) std::cout << _hlt_MinBias << " " << triggerNames.triggerIndex(_hlt_MinBias) << std::endl;
472  //if (_verbose) std::cout << _hlt_HighMET << " " << triggerNames.triggerIndex(_hlt_HighMET) << std::endl;
473  //if (_verbose) std::cout << _hlt_LowMET << " " << triggerNames.triggerIndex(_hlt_LowMET) << std::endl;
474  //if (_verbose) std::cout << _hlt_Ele << " " << triggerNames.triggerIndex(_hlt_Ele) << std::endl;
475  //if (_verbose) std::cout << _hlt_Muon << " " << triggerNames.triggerIndex(_hlt_Muon) << std::endl;
476  //if (_verbose) std::cout << _hlt_PhysDec << " " << triggerNames.triggerIndex(_hlt_PhysDec) << std::endl;
477 
478  if ( _HighPtJetEventFlag->on() && _HighPtJetEventFlag->accept( iEvent, iSetup ) )
479  _trig_HighPtJet=1;
480 
481  if ( _LowPtJetEventFlag->on() && _LowPtJetEventFlag->accept( iEvent, iSetup ) )
482  _trig_LowPtJet=1;
483 
484  if ( _MinBiasEventFlag->on() && _MinBiasEventFlag->accept( iEvent, iSetup ) )
485  _trig_MinBias=1;
486 
487  if ( _HighMETEventFlag->on() && _HighMETEventFlag->accept( iEvent, iSetup ) )
488  _trig_HighMET=1;
489 
490  if ( _LowMETEventFlag->on() && _LowMETEventFlag->accept( iEvent, iSetup ) )
491  _trig_LowMET=1;
492 
493  if ( _EleEventFlag->on() && _EleEventFlag->accept( iEvent, iSetup ) )
494  _trig_Ele=1;
495 
496  if ( _MuonEventFlag->on() && _MuonEventFlag->accept( iEvent, iSetup ) )
497  _trig_Muon=1;
498 
499  if (triggerNames.triggerIndex(_hlt_PhysDec) != triggerNames.size() &&
500  triggerResults.accept(triggerNames.triggerIndex(_hlt_PhysDec))) _trig_PhysDec=1;
501 
502  } else {
503 
504  edm::LogInfo("MetAnalyzer") << "TriggerResults::HLT not found, "
505  "automatically select events";
506 
507  // TriggerResults object not found. Look at all events.
508  _trig_JetMB=1;
509  }
510 
511  // ==========================================================
512  // MET information
513 
514  // **** Get the MET container
516  iEvent.getByLabel(theMETCollectionLabel, metcoll);
517 
518  if(!metcoll.isValid()) {
519  std::cout<<"Unable to find MET results for MET collection "<<theMETCollectionLabel<<std::endl;
520  return;
521  }
522 
523  const METCollection *metcol = metcoll.product();
524  const MET *met;
525  met = &(metcol->front());
526 
527  LogTrace(metname)<<"[METAnalyzer] Call to the MET analyzer";
528 
529  // ==========================================================
530  // TCMET
531 
532  if (theMETCollectionLabel.label() == "tcMet" ) {
533 
534  iEvent.getByLabel(inputMuonLabel, muon_h);
535  iEvent.getByLabel(inputTrackLabel, track_h);
536  iEvent.getByLabel(inputElectronLabel, electron_h);
537  iEvent.getByLabel(inputBeamSpotLabel, beamSpot_h);
538  iEvent.getByLabel("muonTCMETValueMapProducer" , "muCorrData", tcMet_ValueMap_Handle);
539 
540  if(!muon_h.isValid()) edm::LogInfo("OutputInfo") << "falied to retrieve muon data require by MET Task";
541  if(!track_h.isValid()) edm::LogInfo("OutputInfo") << "falied to retrieve track data require by MET Task";
542  if(!electron_h.isValid()) edm::LogInfo("OutputInfo") << "falied to retrieve electron data require by MET Task";
543  if(!beamSpot_h.isValid()) edm::LogInfo("OutputInfo") << "falied to retrieve beam spot data require by MET Task";
544 
545  bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
546 
547  }
548 
549  // ==========================================================
550  // HcalNoiseSummary
551  //
552 
554  iEvent.getByLabel(HcalNoiseRBXCollectionTag,HRBXCollection);
555  if (!HRBXCollection.isValid()) {
556  LogDebug("") << "METAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
557  if (_verbose) std::cout << "METAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
558  }
559 
560  edm::Handle<HcalNoiseSummary> HNoiseSummary;
561  iEvent.getByLabel(HcalNoiseSummaryTag,HNoiseSummary);
562  if (!HNoiseSummary.isValid()) {
563  LogDebug("") << "METAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
564  if (_verbose) std::cout << "METAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
565  }
566 
568  iEvent.getByLabel(theJetCollectionLabel, caloJets);
569  if (!caloJets.isValid()) {
570  LogDebug("") << "METAnalyzer: Could not find jet product" << std::endl;
571  if (_verbose) std::cout << "METAnalyzer: Could not find jet product" << std::endl;
572  }
573 
574  // ==========================================================
575  // MET sanity check
576 
577  // if (_source=="MET") validateMET(*met, tcCandidates);
578 
579  // ==========================================================
580  // JetID
581 
582  if (_verbose) std::cout << "JetID starts" << std::endl;
583 
584  //
585  // --- Minimal cuts
586  //
587  bool bJetIDMinimal=true;
588  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
589  cal!=caloJets->end(); ++cal){
590  jetID->calculate(iEvent, *cal);
591  if (cal->pt()>10.){
592  if (fabs(cal->eta())<=2.6 &&
593  cal->emEnergyFraction()<=0.01) bJetIDMinimal=false;
594  }
595  }
596 
597  //
598  // --- Loose cuts, not specific for now!
599  //
600  bool bJetIDLoose=true;
601  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
602  cal!=caloJets->end(); ++cal){
603  jetID->calculate(iEvent, *cal);
604  if (_verbose) std::cout << jetID->n90Hits() << " "
605  << jetID->restrictedEMF() << " "
606  << cal->pt() << std::endl;
607  if (cal->pt()>10.){
608  //
609  // for all regions
610  if (jetID->n90Hits()<2) bJetIDLoose=false;
611  if (jetID->fHPD()>=0.98) bJetIDLoose=false;
612  //if (jetID->restrictedEMF()<0.01) bJetIDLoose=false;
613  //
614  // for non-forward
615  if (fabs(cal->eta())<2.55){
616  if (cal->emEnergyFraction()<=0.01) bJetIDLoose=false;
617  }
618  // for forward
619  else {
620  if (cal->emEnergyFraction()<=-0.9) bJetIDLoose=false;
621  if (cal->pt()>80.){
622  if (cal->emEnergyFraction()>= 1.0) bJetIDLoose=false;
623  }
624  } // forward vs non-forward
625  } // pt>10 GeV/c
626  } // calor-jets loop
627 
628  //
629  // --- Tight cuts
630  //
631  bool bJetIDTight=true;
632  bJetIDTight=bJetIDLoose;
633  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
634  cal!=caloJets->end(); ++cal){
635  jetID->calculate(iEvent, *cal);
636  if (cal->pt()>25.){
637  //
638  // for all regions
639  if (jetID->fHPD()>=0.95) bJetIDTight=false;
640  //
641  // for 1.0<|eta|<1.75
642  if (fabs(cal->eta())>=1.00 && fabs(cal->eta())<1.75){
643  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
644  }
645  //
646  // for 1.75<|eta|<2.55
647  else if (fabs(cal->eta())>=1.75 && fabs(cal->eta())<2.55){
648  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
649  }
650  //
651  // for 2.55<|eta|<3.25
652  else if (fabs(cal->eta())>=2.55 && fabs(cal->eta())<3.25){
653  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3) bJetIDTight=false;
654  if (cal->pt()>=50. && cal->pt()< 80. && cal->emEnergyFraction()<=-0.2) bJetIDTight=false;
655  if (cal->pt()>=80. && cal->pt()<340. && cal->emEnergyFraction()<=-0.1) bJetIDTight=false;
656  if (cal->pt()>=340. && cal->emEnergyFraction()<=-0.1
657  && cal->emEnergyFraction()>=0.95) bJetIDTight=false;
658  }
659  //
660  // for 3.25<|eta|
661  else if (fabs(cal->eta())>=3.25){
662  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3
663  && cal->emEnergyFraction()>=0.90) bJetIDTight=false;
664  if (cal->pt()>=50. && cal->pt()<130. && cal->emEnergyFraction()<=-0.2
665  && cal->emEnergyFraction()>=0.80) bJetIDTight=false;
666  if (cal->pt()>=130. && cal->emEnergyFraction()<=-0.1
667  && cal->emEnergyFraction()>=0.70) bJetIDTight=false;
668  }
669  } // pt>10 GeV/c
670  } // calor-jets loop
671 
672  if (_verbose) std::cout << "JetID ends" << std::endl;
673 
674 
675  // ==========================================================
676  // HCAL Noise filter
677 
678  bool bHcalNoiseFilter = HNoiseSummary->passLooseNoiseFilter();
679  bool bHcalNoiseFilterTight = HNoiseSummary->passTightNoiseFilter();
680 
681  // ==========================================================
682  // Get BeamHaloSummary
683  edm::Handle<BeamHaloSummary> TheBeamHaloSummary ;
684  iEvent.getByLabel(BeamHaloSummaryTag, TheBeamHaloSummary) ;
685 
686  if (!TheBeamHaloSummary.isValid()) {
687  std::cout << "BeamHaloSummary doesn't exist" << std::endl;
688  }
689 
690  bool bBeamHaloIDTightPass = true;
691  bool bBeamHaloIDLoosePass = true;
692 
693  if(!TheBeamHaloSummary.isValid()) {
694 
695  const BeamHaloSummary TheSummary = (*TheBeamHaloSummary.product() );
696 
697  if( !TheSummary.EcalLooseHaloId() && !TheSummary.HcalLooseHaloId() &&
698  !TheSummary.CSCLooseHaloId() && !TheSummary.GlobalLooseHaloId() )
699  bBeamHaloIDLoosePass = false;
700 
701  if( !TheSummary.EcalTightHaloId() && !TheSummary.HcalTightHaloId() &&
702  !TheSummary.CSCTightHaloId() && !TheSummary.GlobalTightHaloId() )
703  bBeamHaloIDTightPass = false;
704 
705  }
706 
707  // ==========================================================
708  //Vertex information
709 
710  bool bPrimaryVertex = true;
711  if(_doPVCheck){
712  bPrimaryVertex = false;
713  Handle<VertexCollection> vertexHandle;
714 
715  iEvent.getByLabel(vertexTag, vertexHandle);
716 
717  if (!vertexHandle.isValid()) {
718  LogDebug("") << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
719  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
720  }
721 
722  if ( vertexHandle.isValid() ){
723  VertexCollection vertexCollection = *(vertexHandle.product());
724  int vertex_number = vertexCollection.size();
725  VertexCollection::const_iterator v = vertexCollection.begin();
726  double vertex_chi2 = v->normalizedChi2();
727  double vertex_ndof = v->ndof();
728  bool fakeVtx = v->isFake();
729  double vertex_Z = v->z();
730 
731  if ( !fakeVtx
732  && vertex_number>=_nvtx_min
733  && vertex_ndof >_vtxndof_min
734  && vertex_chi2 <_vtxchi2_max
735  && fabs(vertex_Z)<_vtxz_max ) bPrimaryVertex = true;
736  }
737  }
738  // ==========================================================
739 
741  iEvent.getByLabel( gtTag, gtReadoutRecord);
742 
743  if (!gtReadoutRecord.isValid()) {
744  LogDebug("") << "CaloMETAnalyzer: Could not find GT readout record" << std::endl;
745  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find GT readout record product" << std::endl;
746  }
747 
748  bool bTechTriggers = true;
749  bool bTechTriggersAND = true;
750  bool bTechTriggersOR = false;
751  bool bTechTriggersNOT = false;
752 
753  if (gtReadoutRecord.isValid()) {
754  const TechnicalTriggerWord& technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();
755 
756  if (_techTrigsAND.size() == 0)
757  bTechTriggersAND = true;
758  else
759  for (unsigned ttr = 0; ttr != _techTrigsAND.size(); ttr++) {
760  bTechTriggersAND = bTechTriggersAND && technicalTriggerWordBeforeMask.at(_techTrigsAND.at(ttr));
761  }
762 
763  if (_techTrigsAND.size() == 0)
764  bTechTriggersOR = true;
765  else
766  for (unsigned ttr = 0; ttr != _techTrigsOR.size(); ttr++) {
767  bTechTriggersOR = bTechTriggersOR || technicalTriggerWordBeforeMask.at(_techTrigsOR.at(ttr));
768  }
769  if (_techTrigsNOT.size() == 0)
770  bTechTriggersNOT = false;
771  else
772  for (unsigned ttr = 0; ttr != _techTrigsNOT.size(); ttr++) {
773  bTechTriggersNOT = bTechTriggersNOT || technicalTriggerWordBeforeMask.at(_techTrigsNOT.at(ttr));
774  }
775  }
776  else
777  {
778  bTechTriggersAND = true;
779  bTechTriggersOR = true;
780  bTechTriggersNOT = false;
781  }
782 
783  if (_techTrigsAND.size()==0)
784  bTechTriggersAND = true;
785  if (_techTrigsOR.size()==0)
786  bTechTriggersOR = true;
787  if (_techTrigsNOT.size()==0)
788  bTechTriggersNOT = false;
789 
790  bTechTriggers = bTechTriggersAND && bTechTriggersOR && !bTechTriggersNOT;
791 
792  // ==========================================================
793  // Reconstructed MET Information - fill MonitorElements
794 
795  bool bHcalNoise = bHcalNoiseFilter;
796  bool bBeamHaloID = bBeamHaloIDLoosePass;
797  bool bJetID = true;
798 
799  bool bPhysicsDeclared = true;
800  if(_doHLTPhysicsOn) bPhysicsDeclared =_trig_PhysDec;
801 
802 
803  if (_tightHcalFiltering) bHcalNoise = bHcalNoiseFilterTight;
804  if (_tightBHFiltering) bBeamHaloID = bBeamHaloIDTightPass;
805 
806  if (_tightJetIDFiltering==1) bJetID = bJetIDMinimal;
807  else if (_tightJetIDFiltering==2) bJetID = bJetIDLoose;
808  else if (_tightJetIDFiltering==3) bJetID = bJetIDTight;
809  else if (_tightJetIDFiltering==-1) bJetID = true;
810 
811  bool bBasicCleanup = bTechTriggers && bPrimaryVertex && bPhysicsDeclared;
812  bool bExtraCleanup = bBasicCleanup && bHcalNoise && bJetID && bBeamHaloID;
813 
814  //std::string DirName = _FolderName+_source;
815 
816  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
817  ic != _FolderNames.end(); ic++){
818  if (*ic=="All") fillMESet(iEvent, DirName+"/"+*ic, *met);
819  if (DCSFilter->filter(iEvent, iSetup)) {
820  if (_cleanupSelection){
821  if (*ic=="BasicCleanup" && bBasicCleanup) fillMESet(iEvent, DirName+"/"+*ic, *met);
822  if (*ic=="ExtraCleanup" && bExtraCleanup) fillMESet(iEvent, DirName+"/"+*ic, *met);
823  }
824  if (_allSelection) {
825  if (*ic=="HcalNoiseFilter" && bHcalNoiseFilter ) fillMESet(iEvent, DirName+"/"+*ic, *met);
826  if (*ic=="HcalNoiseFilterTight" && bHcalNoiseFilterTight ) fillMESet(iEvent, DirName+"/"+*ic, *met);
827  if (*ic=="JetIDMinimal" && bJetIDMinimal) fillMESet(iEvent, DirName+"/"+*ic, *met);
828  if (*ic=="JetIDLoose" && bJetIDLoose) fillMESet(iEvent, DirName+"/"+*ic, *met);
829  if (*ic=="JetIDTight" && bJetIDTight) fillMESet(iEvent, DirName+"/"+*ic, *met);
830  if (*ic=="BeamHaloIDTightPass" && bBeamHaloIDTightPass) fillMESet(iEvent, DirName+"/"+*ic, *met);
831  if (*ic=="BeamHaloIDLoosePass" && bBeamHaloIDLoosePass) fillMESet(iEvent, DirName+"/"+*ic, *met);
832  if (*ic=="Triggers" && bTechTriggers) fillMESet(iEvent, DirName+"/"+*ic, *met);
833  if (*ic=="PV" && bPrimaryVertex) fillMESet(iEvent, DirName+"/"+*ic, *met);
834  }
835  } // DCS
836  }
837 }
838 
839 // ***********************************************************
841  const reco::MET& met)
842 {
843 
844  _dbe->setCurrentFolder(DirName);
845 
846  bool bLumiSecPlot=false;
847  if (DirName.find("All")) bLumiSecPlot=true;
848 
849  if (_trig_JetMB) fillMonitorElement(iEvent,DirName,"",met, bLumiSecPlot);
850  if (_hlt_HighPtJet.size() && _trig_HighPtJet) fillMonitorElement(iEvent,DirName,"HighPtJet",met,false);
851  if (_hlt_LowPtJet.size() && _trig_LowPtJet) fillMonitorElement(iEvent,DirName,"LowPtJet",met,false);
852  if (_hlt_MinBias.size() && _trig_MinBias) fillMonitorElement(iEvent,DirName,"MinBias",met,false);
853  if (_hlt_HighMET.size() && _trig_HighMET) fillMonitorElement(iEvent,DirName,"HighMET",met,false);
854  if (_hlt_LowMET.size() && _trig_LowMET) fillMonitorElement(iEvent,DirName,"LowMET",met,false);
855  if (_hlt_Ele.size() && _trig_Ele) fillMonitorElement(iEvent,DirName,"Ele",met,false);
856  if (_hlt_Muon.size() && _trig_Muon) fillMonitorElement(iEvent,DirName,"Muon",met,false);
857 }
858 
859 // ***********************************************************
861  std::string TriggerTypeName,
862  const reco::MET& met, bool bLumiSecPlot)
863 {
864 
865  if (TriggerTypeName=="HighPtJet") {
866  if (!selectHighPtJetEvent(iEvent)) return;
867  }
868  else if (TriggerTypeName=="LowPtJet") {
869  if (!selectLowPtJetEvent(iEvent)) return;
870  }
871  else if (TriggerTypeName=="HighMET") {
872  if (met.pt()<_highMETThreshold) return;
873  }
874  else if (TriggerTypeName=="LowMET") {
875  if (met.pt()<_lowMETThreshold) return;
876  }
877  else if (TriggerTypeName=="Ele") {
878  if (!selectWElectronEvent(iEvent)) return;
879  }
880  else if (TriggerTypeName=="Muon") {
881  if (!selectWMuonEvent(iEvent)) return;
882  }
883 
884 // Reconstructed MET Information
885  double SumET = met.sumEt();
886  double METSig = met.mEtSig();
887  double Ez = met.e_longitudinal();
888  double MET = met.pt();
889  double MEx = met.px();
890  double MEy = met.py();
891  double METPhi = met.phi();
892 
893  //
894  int myLuminosityBlock;
895  // myLuminosityBlock = (evtCounter++)/1000;
896  myLuminosityBlock = iEvent.luminosityBlock();
897  //
898 
899  if (TriggerTypeName!="") DirName = DirName +"/"+TriggerTypeName;
900 
901  if (_verbose) std::cout << "_etThreshold = " << _etThreshold << std::endl;
902  if (SumET>_etThreshold){
903 
904  hMEx = _dbe->get(DirName+"/"+"METTask_MEx"); if (hMEx && hMEx->getRootObject()) hMEx ->Fill(MEx);
905  hMEy = _dbe->get(DirName+"/"+"METTask_MEy"); if (hMEy && hMEy->getRootObject()) hMEy ->Fill(MEy);
906  hMET = _dbe->get(DirName+"/"+"METTask_MET"); if (hMET && hMET->getRootObject()) hMET ->Fill(MET);
907  hMETPhi = _dbe->get(DirName+"/"+"METTask_METPhi"); if (hMETPhi && hMETPhi->getRootObject()) hMETPhi ->Fill(METPhi);
908  hSumET = _dbe->get(DirName+"/"+"METTask_SumET"); if (hSumET && hSumET->getRootObject()) hSumET ->Fill(SumET);
909  hMETSig = _dbe->get(DirName+"/"+"METTask_METSig"); if (hMETSig && hMETSig->getRootObject()) hMETSig ->Fill(METSig);
910  hEz = _dbe->get(DirName+"/"+"METTask_Ez"); if (hEz && hEz->getRootObject()) hEz ->Fill(Ez);
911 
912  hMET_logx = _dbe->get(DirName+"/"+"METTask_MET_logx"); if (hMET_logx && hMET_logx->getRootObject()) hMET_logx->Fill(log10(MET));
913  hSumET_logx = _dbe->get(DirName+"/"+"METTask_SumET_logx"); if (hSumET_logx && hSumET_logx->getRootObject()) hSumET_logx->Fill(log10(SumET));
914 
915  hMETIonFeedbck = _dbe->get(DirName+"/"+"METTask_METIonFeedbck"); if (hMETIonFeedbck && hMETIonFeedbck->getRootObject()) hMETIonFeedbck->Fill(MET);
916  hMETHPDNoise = _dbe->get(DirName+"/"+"METTask_METHPDNoise"); if (hMETHPDNoise && hMETHPDNoise->getRootObject()) hMETHPDNoise->Fill(MET);
917 
918  if (_allhist){
919  if (bLumiSecPlot){
920  hMExLS = _dbe->get(DirName+"/"+"METTask_MExLS"); if (hMExLS && hMExLS->getRootObject()) hMExLS->Fill(MEx,myLuminosityBlock);
921  hMEyLS = _dbe->get(DirName+"/"+"METTask_MEyLS"); if (hMEyLS && hMEyLS->getRootObject()) hMEyLS->Fill(MEy,myLuminosityBlock);
922  }
923  } // _allhist
924 
926  if (theMETCollectionLabel.label() == "tcMet" ) {
927 
928  if(track_h.isValid()) {
929  for( edm::View<reco::Track>::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
930  htrkPt = _dbe->get(DirName+"/"+"METTask_trkPt"); if (htrkPt && htrkPt->getRootObject()) htrkPt->Fill( trkit->pt() );
931  htrkEta = _dbe->get(DirName+"/"+"METTask_trkEta"); if (htrkEta && htrkEta->getRootObject()) htrkEta->Fill( trkit->eta() );
932  htrkNhits = _dbe->get(DirName+"/"+"METTask_trkNhits"); if (htrkNhits && htrkNhits->getRootObject()) htrkNhits->Fill( trkit->numberOfValidHits() );
933  htrkChi2 = _dbe->get(DirName+"/"+"METTask_trkChi2"); if (htrkChi2 && htrkChi2->getRootObject()) htrkChi2->Fill( trkit->chi2() / trkit->ndof() );
934  double d0 = -1 * trkit->dxy( bspot );
935  htrkD0 = _dbe->get(DirName+"/"+"METTask_trkD0"); if (htrkD0 && htrkD0->getRootObject()) htrkD0->Fill( d0 );
936  }
937  }
938 
939  if(electron_h.isValid()) {
940  for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
941  helePt = _dbe->get(DirName+"/"+"METTask_helePt"); if (helePt && helePt->getRootObject()) helePt->Fill( eleit->p4().pt() );
942  heleEta = _dbe->get(DirName+"/"+"METTask_heleEta"); if (heleEta && heleEta->getRootObject()) heleEta->Fill( eleit->p4().eta() );
943  heleHoE = _dbe->get(DirName+"/"+"METTask_heleHoE"); if (heleHoE && heleHoE->getRootObject()) heleHoE->Fill( eleit->hadronicOverEm() );
944  }
945  }
946 
947  if(muon_h.isValid()) {
948  for( reco::MuonCollection::const_iterator muonit = muon_h->begin(); muonit != muon_h->end(); muonit++ ) {
949  const reco::TrackRef siTrack = muonit->innerTrack();
950  hmuPt = _dbe->get(DirName+"/"+"METTask_muPt"); if (hmuPt && hmuPt->getRootObject()) hmuPt ->Fill( muonit->p4().pt() );
951  hmuEta = _dbe->get(DirName+"/"+"METTask_muEta"); if (hmuEta && hmuEta->getRootObject()) hmuEta ->Fill( muonit->p4().eta() );
952  hmuNhits = _dbe->get(DirName+"/"+"METTask_muNhits"); if (hmuNhits && hmuNhits->getRootObject()) hmuNhits->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
953  hmuChi2 = _dbe->get(DirName+"/"+"METTask_muChi2"); if (hmuChi2 && hmuChi2->getRootObject()) hmuChi2 ->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
954  double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
955  hmuD0 = _dbe->get(DirName+"/"+"METTask_muD0"); if (hmuD0 && hmuD0->getRootObject()) hmuD0->Fill( d0 );
956  }
957 
958  const unsigned int nMuons = muon_h->size();
959  for( unsigned int mus = 0; mus < nMuons; mus++ ) {
960  reco::MuonRef muref( muon_h, mus);
961  reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
962  hMExCorrection = _dbe->get(DirName+"/"+"METTask_MExCorrection"); if (hMExCorrection && hMExCorrection->getRootObject()) hMExCorrection-> Fill(muCorrData.corrY());
963  hMEyCorrection = _dbe->get(DirName+"/"+"METTask_MEyCorrection"); if (hMEyCorrection && hMEyCorrection->getRootObject()) hMEyCorrection-> Fill(muCorrData.corrX());
964  hMuonCorrectionFlag = _dbe->get(DirName+"/"+"METTask_MuonCorrectionFlag"); if (hMuonCorrectionFlag && hMuonCorrectionFlag->getRootObject()) hMuonCorrectionFlag-> Fill(muCorrData.type());
965  }
966  }
967  }
968 
969  } // et threshold cut
970 
971 }
972 
973 // ***********************************************************
975 
976  bool return_value=false;
977 
979  iEvent.getByLabel(theJetCollectionLabel, caloJets);
980  if (!caloJets.isValid()) {
981  LogDebug("") << "METAnalyzer: Could not find jet product" << std::endl;
982  if (_verbose) std::cout << "METAnalyzer: Could not find jet product" << std::endl;
983  }
984 
985  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
986  cal!=caloJets->end(); ++cal){
987  if (cal->pt()>_highPtJetThreshold){
988  return_value=true;
989  }
990  }
991 
992  return return_value;
993 }
994 
995 // // ***********************************************************
997 
998  bool return_value=false;
999 
1001  iEvent.getByLabel(theJetCollectionLabel, caloJets);
1002  if (!caloJets.isValid()) {
1003  LogDebug("") << "METAnalyzer: Could not find jet product" << std::endl;
1004  if (_verbose) std::cout << "METAnalyzer: Could not find jet product" << std::endl;
1005  }
1006 
1007  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
1008  cal!=caloJets->end(); ++cal){
1009  if (cal->pt()>_lowPtJetThreshold){
1010  return_value=true;
1011  }
1012  }
1013 
1014  return return_value;
1015 
1016 }
1017 
1018 
1019 // ***********************************************************
1021 
1022  bool return_value=true;
1023 
1024  /*
1025  W-electron event selection comes here
1026  */
1027 
1028  return return_value;
1029 
1030 }
1031 
1032 // ***********************************************************
1034 
1035  bool return_value=true;
1036 
1037  /*
1038  W-muon event selection comes here
1039  */
1040 
1041  return return_value;
1042 
1043 }
1044 
#define LogDebug(id)
const double Pi
const bool EcalTightHaloId() const
T getParameter(std::string const &) const
double e_longitudinal() const
Definition: MET.h:55
int i
Definition: DBlmapReader.cc:9
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:208
void beginJob(DQMStore *dbe)
Inizialize parameters for histo binning.
Definition: METAnalyzer.cc:79
void endJob()
Finish up a job.
Definition: METAnalyzer.cc:198
const bool HcalTightHaloId() const
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:519
const bool GlobalLooseHaloId() const
void beginRun(const edm::Run &, const edm::EventSetup &)
Initialize run-based parameters.
Definition: METAnalyzer.cc:319
tuple d0
Definition: debug_cff.py:3
const std::string metname
bool accept() const
Has at least one path accepted the event?
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)
edm::LuminosityBlockNumber_t luminosityBlock() const
Definition: EventBase.h:59
bool selectLowPtJetEvent(const edm::Event &)
Definition: METAnalyzer.cc:996
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
void fillMonitorElement(const edm::Event &, std::string, std::string, const reco::MET &, bool)
Definition: METAnalyzer.cc:860
void fillMESet(const edm::Event &, std::string, const reco::MET &)
Definition: METAnalyzer.cc:840
Provides a code based selection for trigger and DCS information in order to have no failing filters i...
Strings::size_type size() const
Definition: TriggerNames.cc:39
const bool GlobalTightHaloId() const
const bool HcalLooseHaloId() const
const bool CSCTightHaloId() const
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:248
void makeRatePlot(std::string, double)
Definition: METAnalyzer.cc:386
double mEtSig() const
Definition: MET.h:50
int iEvent
Definition: GenABIO.cc:243
double sumEt() const
Definition: MET.h:48
void bookMonitorElement(std::string, bool)
Definition: METAnalyzer.cc:251
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
Definition: MET.h:32
bool selectWElectronEvent(const edm::Event &)
unsigned int size() const
Get number of paths stored.
void endRun(const edm::Run &iRun, const edm::EventSetup &iSetup, DQMStore *dbe)
Finish up a run.
Definition: METAnalyzer.cc:332
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
Collection of MET.
bool isValid() const
Definition: HandleBase.h:76
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:359
#define LogTrace(id)
TObject * getRootObject(void) const
virtual double px() const
x coordinate of momentum vector
virtual double pt() const
transverse momentum
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:13
TH1F * getTH1F(void) const
bool selectWMuonEvent(const edm::Event &)
T const * product() const
Definition: Handle.h:74
METAnalyzer(const edm::ParameterSet &)
Constructor.
Definition: METAnalyzer.cc:35
const bool CSCLooseHaloId() const
tuple cout
Definition: gather_cfg.py:41
void bookMESet(std::string)
Definition: METAnalyzer.cc:206
virtual ~METAnalyzer()
Destructor.
Definition: METAnalyzer.cc:67
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:239
virtual double phi() const
momentum azimuthal angle
const bool EcalLooseHaloId() const
mathSSE::Vec4< T > v
virtual double py() const
y coordinate of momentum vector
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:237
void analyze(const edm::Event &, const edm::EventSetup &, const edm::TriggerResults &)
Get the analysis.
Definition: METAnalyzer.cc:415
Definition: Run.h:31
bool selectHighPtJetEvent(const edm::Event &)
Definition: METAnalyzer.cc:974