CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PFMETAnalyzer.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:49 $
5  * $Revision: 1.34.6.1 $
6  * \author K. Hatakeyama - Rockefeller University
7  * A.Apresyan - Caltech
8  */
9 
13 
17 
19 
24 
26 
30 
31 #include <string>
32 using namespace edm;
33 using namespace reco;
34 using namespace math;
35 
36 // ***********************************************************
38 
39  parameters = pSet;
40 
41  edm::ParameterSet highptjetparms = parameters.getParameter<edm::ParameterSet>("highPtJetTrigger");
42  edm::ParameterSet lowptjetparms = parameters.getParameter<edm::ParameterSet>("lowPtJetTrigger" );
43  edm::ParameterSet minbiasparms = parameters.getParameter<edm::ParameterSet>("minBiasTrigger" );
44  edm::ParameterSet highmetparms = parameters.getParameter<edm::ParameterSet>("highMETTrigger" );
45  edm::ParameterSet lowmetparms = parameters.getParameter<edm::ParameterSet>("lowMETTrigger" );
46  edm::ParameterSet eleparms = parameters.getParameter<edm::ParameterSet>("eleTrigger" );
47  edm::ParameterSet muonparms = parameters.getParameter<edm::ParameterSet>("muonTrigger" );
48 
49  //genericTriggerEventFlag_( new GenericTriggerEventFlag( conf_ ) );
50  _HighPtJetEventFlag = new GenericTriggerEventFlag( highptjetparms );
51  _LowPtJetEventFlag = new GenericTriggerEventFlag( lowptjetparms );
52  _MinBiasEventFlag = new GenericTriggerEventFlag( minbiasparms );
53  _HighMETEventFlag = new GenericTriggerEventFlag( highmetparms );
54  _LowMETEventFlag = new GenericTriggerEventFlag( lowmetparms );
55  _EleEventFlag = new GenericTriggerEventFlag( eleparms );
56  _MuonEventFlag = new GenericTriggerEventFlag( muonparms );
57 
58 
59 }
60 
61 // ***********************************************************
63 
64  delete _HighPtJetEventFlag;
65  delete _LowPtJetEventFlag;
66  delete _MinBiasEventFlag;
67  delete _HighMETEventFlag;
68  delete _LowMETEventFlag;
69  delete _EleEventFlag;
70  delete _MuonEventFlag;
71 
72 }
73 
75 
76  evtCounter = 0;
77  metname = "pfMETAnalyzer";
78 
79  // trigger information
80  HLTPathsJetMBByName_ = parameters.getParameter<std::vector<std::string > >("HLTPathsJetMB");
81 
82  theCleaningParameters = parameters.getParameter<ParameterSet>("CleaningParameters"),
83 
84  //Trigger parameters
85  gtTag = theCleaningParameters.getParameter<edm::InputTag>("gtLabel");
86  _techTrigsAND = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsAND");
87  _techTrigsOR = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsOR");
88  _techTrigsNOT = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsNOT");
89 
90  _doHLTPhysicsOn = theCleaningParameters.getParameter<bool>("doHLTPhysicsOn");
91  _hlt_PhysDec = theCleaningParameters.getParameter<std::string>("HLT_PhysDec");
92 
93  _tightBHFiltering = theCleaningParameters.getParameter<bool>("tightBHFiltering");
94  _tightJetIDFiltering = theCleaningParameters.getParameter<int>("tightJetIDFiltering");
95  _tightHcalFiltering = theCleaningParameters.getParameter<bool>("tightHcalFiltering");
96 
97  // ==========================================================
98  //DCS information
99  // ==========================================================
100  DCSFilter = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilter"));
101 
102  //Vertex requirements
103  _doPVCheck = theCleaningParameters.getParameter<bool>("doPrimaryVertexCheck");
104  vertexTag = theCleaningParameters.getParameter<edm::InputTag>("vertexLabel");
105 
106  if (_doPVCheck) {
107  _nvtx_min = theCleaningParameters.getParameter<int>("nvtx_min");
108  _nvtxtrks_min = theCleaningParameters.getParameter<int>("nvtxtrks_min");
109  _vtxndof_min = theCleaningParameters.getParameter<int>("vtxndof_min");
110  _vtxchi2_max = theCleaningParameters.getParameter<double>("vtxchi2_max");
111  _vtxz_max = theCleaningParameters.getParameter<double>("vtxz_max");
112  }
113 
114 
115  // PFMET information
116  thePfMETCollectionLabel = parameters.getParameter<edm::InputTag>("METCollectionLabel");
117  thePfJetCollectionLabel = parameters.getParameter<edm::InputTag>("PfJetCollectionLabel");
118  _source = parameters.getParameter<std::string>("Source");
119 
120  // Other data collections
121  theJetCollectionLabel = parameters.getParameter<edm::InputTag>("JetCollectionLabel");
122  PFCandidatesTag = parameters.getParameter<edm::InputTag>("PFCandidates");
123  HcalNoiseRBXCollectionTag = parameters.getParameter<edm::InputTag>("HcalNoiseRBXCollection");
124  HcalNoiseSummaryTag = parameters.getParameter<edm::InputTag>("HcalNoiseSummary");
125  BeamHaloSummaryTag = parameters.getParameter<edm::InputTag>("BeamHaloSummaryLabel");
126 
127  // misc
128  _verbose = parameters.getParameter<int>("verbose");
129  _etThreshold = parameters.getParameter<double>("etThreshold"); // MET threshold
130  _allhist = parameters.getParameter<bool>("allHist"); // Full set of monitoring histograms
131  _allSelection= parameters.getParameter<bool>("allSelection"); // Plot with all sets of event selection
132  _cleanupSelection= parameters.getParameter<bool>("cleanupSelection"); // Plot with all sets of event selection
133 
134  _highPtPFJetThreshold = parameters.getParameter<double>("HighPtJetThreshold"); // High Pt Jet threshold
135  _lowPtPFJetThreshold = parameters.getParameter<double>("LowPtJetThreshold"); // Low Pt Jet threshold
136  _highPFMETThreshold = parameters.getParameter<double>("HighMETThreshold"); // High MET threshold
137  _lowPFMETThreshold = parameters.getParameter<double>("LowMETThreshold"); // Low MET threshold
138 
139  //
140  jetID = new reco::helper::JetIDHelper(parameters.getParameter<ParameterSet>("JetIDParams"));
141 
142  // DQStore stuff
143  LogTrace(metname)<<"[PFMETAnalyzer] Parameters initialization";
144  std::string DirName = "JetMET/MET/"+_source;
145  dbe->setCurrentFolder(DirName);
146 
147  metME = dbe->book1D("metReco", "metReco", 4, 1, 5);
148  metME->setBinLabel(3,"PFMET",1);
149 
150  _dbe = dbe;
151 
152  _FolderNames.push_back("All");
153  _FolderNames.push_back("BasicCleanup");
154  _FolderNames.push_back("ExtraCleanup");
155  _FolderNames.push_back("HcalNoiseFilter");
156  _FolderNames.push_back("HcalNoiseFilterTight");
157  _FolderNames.push_back("JetIDMinimal");
158  _FolderNames.push_back("JetIDLoose");
159  _FolderNames.push_back("JetIDTight");
160  _FolderNames.push_back("BeamHaloIDTightPass");
161  _FolderNames.push_back("BeamHaloIDLoosePass");
162  _FolderNames.push_back("Triggers");
163  _FolderNames.push_back("PV");
164 
165  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
166  ic != _FolderNames.end(); ic++){
167  if (*ic=="All") bookMESet(DirName+"/"+*ic);
168  if (_cleanupSelection){
169  if (*ic=="BasicCleanup") bookMESet(DirName+"/"+*ic);
170  if (*ic=="ExtraCleanup") bookMESet(DirName+"/"+*ic);
171  }
172  if (_allSelection){
173  if (*ic=="HcalNoiseFilter") bookMESet(DirName+"/"+*ic);
174  if (*ic=="HcalNoiseFilterTight") bookMESet(DirName+"/"+*ic);
175  if (*ic=="JetIDMinimal") bookMESet(DirName+"/"+*ic);
176  if (*ic=="JetIDLoose") bookMESet(DirName+"/"+*ic);
177  if (*ic=="JetIDTight") bookMESet(DirName+"/"+*ic);
178  if (*ic=="BeamHaloIDTightPass") bookMESet(DirName+"/"+*ic);
179  if (*ic=="BeamHaloIDLoosePass") bookMESet(DirName+"/"+*ic);
180  if (*ic=="Triggers") bookMESet(DirName+"/"+*ic);
181  if (*ic=="PV") bookMESet(DirName+"/"+*ic);
182  }
183  }
184 }
185 
186 // ***********************************************************
188 
189  delete jetID;
190  delete DCSFilter;
191 
192 }
193 
194 // ***********************************************************
196 {
197 
198  bool bLumiSecPlot=false;
199  if (DirName.find("All")!=std::string::npos) bLumiSecPlot=true;
200 
201  bookMonitorElement(DirName,bLumiSecPlot);
202 
203  if ( _HighPtJetEventFlag->on() ) {
204  bookMonitorElement(DirName+"/"+"HighPtJet",false);
205  meTriggerName_HighPtJet = _dbe->bookString("triggerName_HighPtJet", _hlt_HighPtJet);
206  }
207 
208  if ( _LowPtJetEventFlag->on() ) {
209  bookMonitorElement(DirName+"/"+"LowPtJet",false);
210  meTriggerName_LowPtJet = _dbe->bookString("triggerName_LowPtJet", _hlt_LowPtJet);
211  }
212 
213  if ( _MinBiasEventFlag->on() ) {
214  bookMonitorElement(DirName+"/"+"MinBias",false);
215  meTriggerName_MinBias = _dbe->bookString("triggerName_MinBias", _hlt_MinBias);
216  }
217 
218  if ( _HighMETEventFlag->on() ) {
219  bookMonitorElement(DirName+"/"+"HighMET",false);
220  meTriggerName_HighMET = _dbe->bookString("triggerName_HighMET", _hlt_HighMET);
221  }
222 
223  if ( _LowMETEventFlag->on() ) {
224  bookMonitorElement(DirName+"/"+"LowMET",false);
225  meTriggerName_LowMET = _dbe->bookString("triggerName_LowMET", _hlt_LowMET);
226  }
227 
228  if ( _EleEventFlag->on() ) {
229  bookMonitorElement(DirName+"/"+"Ele",false);
230  meTriggerName_Ele = _dbe->bookString("triggerName_Ele", _hlt_Ele);
231  }
232 
233  if ( _MuonEventFlag->on() ) {
234  bookMonitorElement(DirName+"/"+"Muon",false);
235  meTriggerName_Muon = _dbe->bookString("triggerName_Muon", _hlt_Muon);
236  }
237 }
238 
239 // ***********************************************************
240 void PFMETAnalyzer::bookMonitorElement(std::string DirName, bool bLumiSecPlot=false)
241 {
242 
243  if (_verbose) std::cout << "booMonitorElement " << DirName << std::endl;
244  _dbe->setCurrentFolder(DirName);
245 
246  meNevents = _dbe->book1D("METTask_Nevents", "METTask_Nevents" ,1,0,1);
247  mePfMEx = _dbe->book1D("METTask_PfMEx", "METTask_PfMEx" ,500,-500,500);
248  mePfMEx->setAxisTitle("MEx [GeV]",1);
249  mePfMEy = _dbe->book1D("METTask_PfMEy", "METTask_PfMEy" ,500,-500,500);
250  mePfMEy->setAxisTitle("MEy [GeV]",1);
251  mePfEz = _dbe->book1D("METTask_PfEz", "METTask_PfEz" ,500,-500,500);
252  mePfEz->setAxisTitle("MEz [GeV]",1);
253  mePfMETSig = _dbe->book1D("METTask_PfMETSig","METTask_PfMETSig",51,0,51);
254  mePfMETSig->setAxisTitle("METSig",1);
255  mePfMET = _dbe->book1D("METTask_PfMET", "METTask_PfMET" ,500,0,1000);
256  mePfMET->setAxisTitle("MET [GeV]",1);
257  mePfMETPhi = _dbe->book1D("METTask_PfMETPhi","METTask_PfMETPhi",80,-TMath::Pi(),TMath::Pi());
258  mePfMETPhi->setAxisTitle("METPhi [rad]",1);
259  mePfSumET = _dbe->book1D("METTask_PfSumET", "METTask_PfSumET" ,500,0,2000);
260  mePfSumET->setAxisTitle("SumET [GeV]",1);
261 
262  mePfMET_logx = _dbe->book1D("METTask_PfMET_logx", "METTask_PfMET_logx" ,40,-1.,7.);
263  mePfMET_logx->setAxisTitle("log(MET) [GeV]",1);
264  mePfSumET_logx = _dbe->book1D("METTask_PfSumET_logx", "METTask_PfSumET_logx" ,40,-1.,7.);
265  mePfSumET_logx->setAxisTitle("log(SumET) [GeV]",1);
266 
267  mePfNeutralEMFraction = _dbe->book1D("METTask_PfNeutralEMFraction", "METTask_PfNeutralEMFraction" ,50,0.,1.);
268  mePfNeutralEMFraction->setAxisTitle("Pf Neutral EM Fraction",1);
269  mePfNeutralHadFraction = _dbe->book1D("METTask_PfNeutralHadFraction","METTask_PfNeutralHadFraction",50,0.,1.);
270  mePfNeutralHadFraction->setAxisTitle("Pf Neutral Had Fraction",1);
271  mePfChargedEMFraction = _dbe->book1D("METTask_PfChargedEMFraction", "METTask_PfChargedEMFraction" ,50,0.,1.);
272  mePfChargedEMFraction->setAxisTitle("Pf Charged EM Fraction",1);
273  mePfChargedHadFraction = _dbe->book1D("METTask_PfChargedHadFraction","METTask_PfChargedHadFraction",50,0.,1.);
274  mePfChargedHadFraction->setAxisTitle("Pf Charged Had Fraction",1);
275  mePfMuonFraction = _dbe->book1D("METTask_PfMuonFraction", "METTask_PfMuonFraction" ,50,0.,1.);
276  mePfMuonFraction->setAxisTitle("Pf Muon Fraction",1);
277 
278  mePfMETIonFeedbck = _dbe->book1D("METTask_PfMETIonFeedbck", "METTask_PfMETIonFeedbck" ,500,0,1000);
279  mePfMETIonFeedbck->setAxisTitle("MET [GeV]",1);
280  mePfMETHPDNoise = _dbe->book1D("METTask_PfMETHPDNoise", "METTask_PfMETHPDNoise" ,500,0,1000);
281  mePfMETHPDNoise->setAxisTitle("MET [GeV]",1);
282  mePfMETRBXNoise = _dbe->book1D("METTask_PfMETRBXNoise", "METTask_PfMETRBXNoise" ,500,0,1000);
283  mePfMETRBXNoise->setAxisTitle("MET [GeV]",1);
284 
285  if (_allhist){
286  if (bLumiSecPlot){
287  mePfMExLS = _dbe->book2D("METTask_PfMEx_LS","METTask_PfMEx_LS",200,-200,200,50,0.,500.);
288  mePfMExLS->setAxisTitle("MEx [GeV]",1);
289  mePfMExLS->setAxisTitle("Lumi Section",2);
290  mePfMEyLS = _dbe->book2D("METTask_PfMEy_LS","METTask_PfMEy_LS",200,-200,200,50,0.,500.);
291  mePfMEyLS->setAxisTitle("MEy [GeV]",1);
292  mePfMEyLS->setAxisTitle("Lumi Section",2);
293  }
294  }
295 }
296 
297 // ***********************************************************
298 void PFMETAnalyzer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
299 {
300  if ( _HighPtJetEventFlag->on() ) _HighPtJetEventFlag->initRun( iRun, iSetup );
301  if ( _LowPtJetEventFlag ->on() ) _LowPtJetEventFlag ->initRun( iRun, iSetup );
302  if ( _MinBiasEventFlag ->on() ) _MinBiasEventFlag ->initRun( iRun, iSetup );
303  if ( _HighMETEventFlag ->on() ) _HighMETEventFlag ->initRun( iRun, iSetup );
304  if ( _LowMETEventFlag ->on() ) _LowMETEventFlag ->initRun( iRun, iSetup );
305  if ( _EleEventFlag ->on() ) _EleEventFlag ->initRun( iRun, iSetup );
306  if ( _MuonEventFlag ->on() ) _MuonEventFlag ->initRun( iRun, iSetup );
307 
308 }
309 
310 // ***********************************************************
311 void PFMETAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup, DQMStore * dbe)
312 {
313 
314  //
315  //--- Check the time length of the Run from the lumi section plots
316 
317  std::string dirName = "JetMET/MET/"+_source+"/";
318  _dbe->setCurrentFolder(dirName);
319 
320  TH1F* tlumisec;
321 
322  MonitorElement *meLumiSec = _dbe->get("aaa");
323  meLumiSec = _dbe->get("JetMET/lumisec");
324 
325  int totlsec=0;
326  double totltime=0.;
327  if ( meLumiSec->getRootObject() ) {
328  tlumisec = meLumiSec->getTH1F();
329  for (int i=0; i<500; i++){
330  if (tlumisec->GetBinContent(i+1)) totlsec++;
331  }
332  totltime = double(totlsec*90); // one lumi sec ~ 90 (sec)
333  }
334 
335  if (totltime==0.) totltime=1.;
336 
337  //
338  //--- Make the integrated plots with rate (Hz)
339 
340  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); ic != _FolderNames.end(); ic++)
341  {
342 
343  std::string DirName;
344  DirName = dirName+*ic;
345 
346  makeRatePlot(DirName,totltime);
347  if ( _HighPtJetEventFlag->on() )
348  makeRatePlot(DirName+"/"+"triggerName_HighJetPt",totltime);
349  if ( _LowPtJetEventFlag->on() )
350  makeRatePlot(DirName+"/"+"triggerName_LowJetPt",totltime);
351  if ( _MinBiasEventFlag->on() )
352  makeRatePlot(DirName+"/"+"triggerName_MinBias",totltime);
353  if ( _HighMETEventFlag->on() )
354  makeRatePlot(DirName+"/"+"triggerName_HighMET",totltime);
355  if ( _LowMETEventFlag->on() )
356  makeRatePlot(DirName+"/"+"triggerName_LowMET",totltime);
357  if ( _EleEventFlag->on() )
358  makeRatePlot(DirName+"/"+"triggerName_Ele",totltime);
359  if ( _MuonEventFlag->on() )
360  makeRatePlot(DirName+"/"+"triggerName_Muon",totltime);
361  }
362 }
363 
364 // ***********************************************************
365 void PFMETAnalyzer::makeRatePlot(std::string DirName, double totltime)
366 {
367 
368  _dbe->setCurrentFolder(DirName);
369  MonitorElement *mePfMET = _dbe->get(DirName+"/"+"METTask_PfMET");
370 
371  TH1F* tPfMET;
372  TH1F* tPfMETRate;
373 
374  if ( mePfMET )
375  if ( mePfMET->getRootObject() ) {
376  tPfMET = mePfMET->getTH1F();
377 
378  // Integral plot & convert number of events to rate (hz)
379  tPfMETRate = (TH1F*) tPfMET->Clone("METTask_PfMETRate");
380  for (int i = tPfMETRate->GetNbinsX()-1; i>=0; i--){
381  tPfMETRate->SetBinContent(i+1,tPfMETRate->GetBinContent(i+2)+tPfMET->GetBinContent(i+1));
382  }
383  for (int i = 0; i<tPfMETRate->GetNbinsX(); i++){
384  tPfMETRate->SetBinContent(i+1,tPfMETRate->GetBinContent(i+1)/double(totltime));
385  }
386 
387  tPfMETRate->SetName("METTask_PfMETRate");
388  tPfMETRate->SetTitle("METTask_PfMETRate");
389  mePfMETRate = _dbe->book1D("METTask_PfMETRate",tPfMETRate);
390 
391  }
392 }
393 
394 // ***********************************************************
396  const edm::TriggerResults& triggerResults) {
397 
398  if (_verbose) std::cout << "PfMETAnalyzer analyze" << std::endl;
399 
400  LogTrace(metname)<<"[PFMETAnalyzer] Analyze PFMET";
401 
402  metME->Fill(3);
403 
404  // ==========================================================
405  // Trigger information
406  //
407  _trig_JetMB=0;
408  _trig_HighPtJet=0;
409  _trig_LowPtJet=0;
410  _trig_MinBias=0;
411  _trig_HighMET=0;
412  _trig_LowMET=0;
413  _trig_Ele=0;
414  _trig_Muon=0;
415  _trig_PhysDec=0;
416  if(&triggerResults) {
417 
419 
420  //
421  //
422  // Check how many HLT triggers are in triggerResults
423  int ntrigs = triggerResults.size();
424  if (_verbose) std::cout << "ntrigs=" << ntrigs << std::endl;
425 
426  //
427  //
428  // If index=ntrigs, this HLT trigger doesn't exist in the HLT table for this data.
429  const edm::TriggerNames & triggerNames = iEvent.triggerNames(triggerResults);
430 
431  //
432  //
433  // count number of requested Jet or MB HLT paths which have fired
434  for (unsigned int i=0; i!=HLTPathsJetMBByName_.size(); i++) {
435  unsigned int triggerIndex = triggerNames.triggerIndex(HLTPathsJetMBByName_[i]);
436  if (triggerIndex<triggerResults.size()) {
437  if (triggerResults.accept(triggerIndex)) {
438  _trig_JetMB++;
439  }
440  }
441  }
442  // for empty input vectors (n==0), take all HLT triggers!
443  if (HLTPathsJetMBByName_.size()==0) _trig_JetMB=triggerResults.size()-1;
444 
445  //
446  if (_verbose) std::cout << "triggerNames size" << " " << triggerNames.size() << std::endl;
447  if (_verbose) std::cout << _hlt_HighPtJet << " " << triggerNames.triggerIndex(_hlt_HighPtJet) << std::endl;
448  if (_verbose) std::cout << _hlt_LowPtJet << " " << triggerNames.triggerIndex(_hlt_LowPtJet) << std::endl;
449  if (_verbose) std::cout << _hlt_MinBias << " " << triggerNames.triggerIndex(_hlt_MinBias) << std::endl;
450  if (_verbose) std::cout << _hlt_HighMET << " " << triggerNames.triggerIndex(_hlt_HighMET) << std::endl;
451  if (_verbose) std::cout << _hlt_LowMET << " " << triggerNames.triggerIndex(_hlt_LowMET) << std::endl;
452  if (_verbose) std::cout << _hlt_Ele << " " << triggerNames.triggerIndex(_hlt_Ele) << std::endl;
453  if (_verbose) std::cout << _hlt_Muon << " " << triggerNames.triggerIndex(_hlt_Muon) << std::endl;
454  if (_verbose) std::cout << _hlt_PhysDec << " " << triggerNames.triggerIndex(_hlt_PhysDec) << std::endl;
455 
456  if ( _HighPtJetEventFlag->on() && _HighPtJetEventFlag->accept( iEvent, iSetup ) )
457  _trig_HighPtJet=1;
458 
459  if ( _LowPtJetEventFlag->on() && _LowPtJetEventFlag->accept( iEvent, iSetup ) )
460  _trig_LowPtJet=1;
461 
462  if ( _MinBiasEventFlag->on() && _MinBiasEventFlag->accept( iEvent, iSetup ) )
463  _trig_MinBias=1;
464 
465  if ( _HighMETEventFlag->on() && _HighMETEventFlag->accept( iEvent, iSetup ) )
466  _trig_HighMET=1;
467 
468  if ( _LowMETEventFlag->on() && _LowMETEventFlag->accept( iEvent, iSetup ) )
469  _trig_LowMET=1;
470 
471  if ( _EleEventFlag->on() && _EleEventFlag->accept( iEvent, iSetup ) )
472  _trig_Ele=1;
473 
474  if ( _MuonEventFlag->on() && _MuonEventFlag->accept( iEvent, iSetup ) )
475  _trig_Muon=1;
476 
477  if (triggerNames.triggerIndex(_hlt_PhysDec) != triggerNames.size() &&
478  triggerResults.accept(triggerNames.triggerIndex(_hlt_PhysDec))) _trig_PhysDec=1;
479 
480  } else {
481 
482  edm::LogInfo("PFMetAnalyzer") << "TriggerResults::HLT not found, "
483  "automatically select events";
484 
485  // TriggerResults object not found. Look at all events.
486  _trig_JetMB=1;
487  }
488 
489  // ==========================================================
490  // PfMET information
491 
492  // **** Get the MET container
494  iEvent.getByLabel(thePfMETCollectionLabel, pfmetcoll);
495 
496  if(!pfmetcoll.isValid()) return;
497 
498  const PFMETCollection *pfmetcol = pfmetcoll.product();
499  const PFMET *pfmet;
500  pfmet = &(pfmetcol->front());
501 
502  LogTrace(metname)<<"[PfMETAnalyzer] Call to the PfMET analyzer";
503 
504  // ==========================================================
505  //
507  iEvent.getByLabel(HcalNoiseRBXCollectionTag,HRBXCollection);
508  if (!HRBXCollection.isValid()) {
509  LogDebug("") << "PfMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
510  if (_verbose) std::cout << "PfMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
511  }
512 
513  edm::Handle<HcalNoiseSummary> HNoiseSummary;
514  iEvent.getByLabel(HcalNoiseSummaryTag,HNoiseSummary);
515  if (!HNoiseSummary.isValid()) {
516  LogDebug("") << "PfMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
517  if (_verbose) std::cout << "PfMETAnalyzer: Could not find Hcal NoiseSummary product" << std::endl;
518  }
519 
521  iEvent.getByLabel(theJetCollectionLabel, caloJets);
522  if (!caloJets.isValid()) {
523  LogDebug("") << "PFMETAnalyzer: Could not find jet product" << std::endl;
524  if (_verbose) std::cout << "PFMETAnalyzer: Could not find jet product" << std::endl;
525  }
526 
528  iEvent.getByLabel(PFCandidatesTag, pfCandidates);
529  if (!pfCandidates.isValid()) {
530  LogDebug("") << "PfMETAnalyzer: Could not find pfcandidates product" << std::endl;
531  if (_verbose) std::cout << "PfMETAnalyzer: Could not find pfcandidates product" << std::endl;
532  }
533 
535  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
536  if (!pfJets.isValid()) {
537  LogDebug("") << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
538  if (_verbose) std::cout << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
539  }
540  // ==========================================================
541  // PfMET sanity check
542 
543  if (_source=="PfMET") validateMET(*pfmet, pfCandidates);
544 
545  // ==========================================================
546  // JetID
547 
548  if (_verbose) std::cout << "JetID starts" << std::endl;
549 
550  //
551  // --- Minimal cuts
552  //
553  bool bJetIDMinimal=true;
554  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
555  cal!=caloJets->end(); ++cal){
556  jetID->calculate(iEvent, *cal);
557  if (cal->pt()>10.){
558  if (fabs(cal->eta())<=2.6 &&
559  cal->emEnergyFraction()<=0.01) bJetIDMinimal=false;
560  }
561  }
562 
563  //
564  // --- Loose cuts, not PF specific for now!
565  //
566  bool bJetIDLoose=true;
567  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
568  cal!=caloJets->end(); ++cal){
569  jetID->calculate(iEvent, *cal);
570  if (_verbose) std::cout << jetID->n90Hits() << " "
571  << jetID->restrictedEMF() << " "
572  << cal->pt() << std::endl;
573  if (cal->pt()>10.){
574  //
575  // for all regions
576  if (jetID->n90Hits()<2) bJetIDLoose=false;
577  if (jetID->fHPD()>=0.98) bJetIDLoose=false;
578  //if (jetID->restrictedEMF()<0.01) bJetIDLoose=false;
579  //
580  // for non-forward
581  if (fabs(cal->eta())<2.55){
582  if (cal->emEnergyFraction()<=0.01) bJetIDLoose=false;
583  }
584  // for forward
585  else {
586  if (cal->emEnergyFraction()<=-0.9) bJetIDLoose=false;
587  if (cal->pt()>80.){
588  if (cal->emEnergyFraction()>= 1.0) bJetIDLoose=false;
589  }
590  } // forward vs non-forward
591  } // pt>10 GeV/c
592  } // calor-jets loop
593 
594  //
595  // --- Tight cuts
596  //
597  bool bJetIDTight=true;
598  bJetIDTight=bJetIDLoose;
599  for (reco::CaloJetCollection::const_iterator cal = caloJets->begin();
600  cal!=caloJets->end(); ++cal){
601  jetID->calculate(iEvent, *cal);
602  if (cal->pt()>25.){
603  //
604  // for all regions
605  if (jetID->fHPD()>=0.95) bJetIDTight=false;
606  //
607  // for 1.0<|eta|<1.75
608  if (fabs(cal->eta())>=1.00 && fabs(cal->eta())<1.75){
609  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
610  }
611  //
612  // for 1.75<|eta|<2.55
613  else if (fabs(cal->eta())>=1.75 && fabs(cal->eta())<2.55){
614  if (cal->pt()>80. && cal->emEnergyFraction()>=1.) bJetIDTight=false;
615  }
616  //
617  // for 2.55<|eta|<3.25
618  else if (fabs(cal->eta())>=2.55 && fabs(cal->eta())<3.25){
619  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3) bJetIDTight=false;
620  if (cal->pt()>=50. && cal->pt()< 80. && cal->emEnergyFraction()<=-0.2) bJetIDTight=false;
621  if (cal->pt()>=80. && cal->pt()<340. && cal->emEnergyFraction()<=-0.1) bJetIDTight=false;
622  if (cal->pt()>=340. && cal->emEnergyFraction()<=-0.1
623  && cal->emEnergyFraction()>=0.95) bJetIDTight=false;
624  }
625  //
626  // for 3.25<|eta|
627  else if (fabs(cal->eta())>=3.25){
628  if (cal->pt()< 50. && cal->emEnergyFraction()<=-0.3
629  && cal->emEnergyFraction()>=0.90) bJetIDTight=false;
630  if (cal->pt()>=50. && cal->pt()<130. && cal->emEnergyFraction()<=-0.2
631  && cal->emEnergyFraction()>=0.80) bJetIDTight=false;
632  if (cal->pt()>=130. && cal->emEnergyFraction()<=-0.1
633  && cal->emEnergyFraction()>=0.70) bJetIDTight=false;
634  }
635  } // pt>10 GeV/c
636  } // calor-jets loop
637 
638  if (_verbose) std::cout << "JetID ends" << std::endl;
639 
640 
641  // ==========================================================
642  // HCAL Noise filter
643 
644  bool bHcalNoiseFilter = HNoiseSummary->passLooseNoiseFilter();
645  bool bHcalNoiseFilterTight = HNoiseSummary->passTightNoiseFilter();
646 
647  // ==========================================================
648  // Get BeamHaloSummary
649  edm::Handle<BeamHaloSummary> TheBeamHaloSummary ;
650  iEvent.getByLabel(BeamHaloSummaryTag, TheBeamHaloSummary) ;
651 
652  bool bBeamHaloIDTightPass = true;
653  bool bBeamHaloIDLoosePass = true;
654 
655  if(!TheBeamHaloSummary.isValid()) {
656 
657  const BeamHaloSummary TheSummary = (*TheBeamHaloSummary.product() );
658 
659  if( !TheSummary.EcalLooseHaloId() && !TheSummary.HcalLooseHaloId() &&
660  !TheSummary.CSCLooseHaloId() && !TheSummary.GlobalLooseHaloId() )
661  bBeamHaloIDLoosePass = false;
662 
663  if( !TheSummary.EcalTightHaloId() && !TheSummary.HcalTightHaloId() &&
664  !TheSummary.CSCTightHaloId() && !TheSummary.GlobalTightHaloId() )
665  bBeamHaloIDTightPass = false;
666 
667  }
668 
669  // ==========================================================
670  //Vertex information
671 
672  bool bPrimaryVertex = true;
673  if(_doPVCheck){
674  bPrimaryVertex = false;
675  Handle<VertexCollection> vertexHandle;
676 
677  iEvent.getByLabel(vertexTag, vertexHandle);
678 
679  if (!vertexHandle.isValid()) {
680  LogDebug("") << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
681  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
682  }
683 
684  if ( vertexHandle.isValid() ){
685  VertexCollection vertexCollection = *(vertexHandle.product());
686  int vertex_number = vertexCollection.size();
687  VertexCollection::const_iterator v = vertexCollection.begin();
688  double vertex_chi2 = v->normalizedChi2();
689  double vertex_ndof = v->ndof();
690  bool fakeVtx = v->isFake();
691  double vertex_Z = v->z();
692 
693  if ( !fakeVtx
694  && vertex_number>=_nvtx_min
695  && vertex_ndof >_vtxndof_min
696  && vertex_chi2 <_vtxchi2_max
697  && fabs(vertex_Z)<_vtxz_max ) bPrimaryVertex = true;
698  }
699  }
700  // ==========================================================
701 
703  iEvent.getByLabel( gtTag, gtReadoutRecord);
704 
705  if (!gtReadoutRecord.isValid()) {
706  LogDebug("") << "CaloMETAnalyzer: Could not find GT readout record" << std::endl;
707  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find GT readout record product" << std::endl;
708  }
709 
710  bool bTechTriggers = true;
711  bool bTechTriggersAND = true;
712  bool bTechTriggersOR = false;
713  bool bTechTriggersNOT = false;
714 
715  if (gtReadoutRecord.isValid()) {
716  const TechnicalTriggerWord& technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();
717 
718  if (_techTrigsAND.size() == 0)
719  bTechTriggersAND = true;
720  else
721  for (unsigned ttr = 0; ttr != _techTrigsAND.size(); ttr++) {
722  bTechTriggersAND = bTechTriggersAND && technicalTriggerWordBeforeMask.at(_techTrigsAND.at(ttr));
723  }
724 
725  if (_techTrigsAND.size() == 0)
726  bTechTriggersOR = true;
727  else
728  for (unsigned ttr = 0; ttr != _techTrigsOR.size(); ttr++) {
729  bTechTriggersOR = bTechTriggersOR || technicalTriggerWordBeforeMask.at(_techTrigsOR.at(ttr));
730  }
731  if (_techTrigsNOT.size() == 0)
732  bTechTriggersNOT = false;
733  else
734  for (unsigned ttr = 0; ttr != _techTrigsNOT.size(); ttr++) {
735  bTechTriggersNOT = bTechTriggersNOT || technicalTriggerWordBeforeMask.at(_techTrigsNOT.at(ttr));
736  }
737  }
738  else
739  {
740  bTechTriggersAND = true;
741  bTechTriggersOR = true;
742  bTechTriggersNOT = false;
743  }
744 
745  if (_techTrigsAND.size()==0)
746  bTechTriggersAND = true;
747  if (_techTrigsOR.size()==0)
748  bTechTriggersOR = true;
749  if (_techTrigsNOT.size()==0)
750  bTechTriggersNOT = false;
751 
752  bTechTriggers = bTechTriggersAND && bTechTriggersOR && !bTechTriggersNOT;
753 
754  // ==========================================================
755  // Reconstructed MET Information - fill MonitorElements
756 
757  bool bHcalNoise = bHcalNoiseFilter;
758  bool bBeamHaloID = bBeamHaloIDLoosePass;
759  bool bJetID = bJetIDMinimal;
760 
761  bool bPhysicsDeclared = true;
762  if(_doHLTPhysicsOn) bPhysicsDeclared =_trig_PhysDec;
763 
764  if (_tightHcalFiltering) bHcalNoise = bHcalNoiseFilterTight;
765  if (_tightBHFiltering) bBeamHaloID = bBeamHaloIDTightPass;
766 
767  if (_tightJetIDFiltering==1) bJetID = bJetIDMinimal;
768  else if (_tightJetIDFiltering==2) bJetID = bJetIDLoose;
769  else if (_tightJetIDFiltering==3) bJetID = bJetIDTight;
770  else if (_tightJetIDFiltering==-1) bJetID = true;
771 
772  bool bBasicCleanup = bTechTriggers && bPrimaryVertex && bPhysicsDeclared;
773  bool bExtraCleanup = bBasicCleanup && bHcalNoise && bJetID && bBeamHaloID;
774 
775  std::string DirName = "JetMET/MET/"+_source;
776 
777  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
778  ic != _FolderNames.end(); ic++){
779  if (*ic=="All") fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
780  if (DCSFilter->filter(iEvent, iSetup)) {
781  if (_cleanupSelection){
782  if (*ic=="BasicCleanup" && bBasicCleanup) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
783  if (*ic=="ExtraCleanup" && bExtraCleanup) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
784  }
785  if (_allSelection) {
786  if (*ic=="HcalNoiseFilter" && bHcalNoiseFilter ) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
787  if (*ic=="HcalNoiseFilterTight" && bHcalNoiseFilterTight ) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
788  if (*ic=="JetIDMinimal" && bJetIDMinimal) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
789  if (*ic=="JetIDLoose" && bJetIDLoose) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
790  if (*ic=="JetIDTight" && bJetIDTight) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
791  if (*ic=="BeamHaloIDTightPass" && bBeamHaloIDTightPass) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
792  if (*ic=="BeamHaloIDLoosePass" && bBeamHaloIDLoosePass) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
793  if (*ic=="Triggers" && bTechTriggers) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
794  if (*ic=="PV" && bPrimaryVertex) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
795  }
796  } // DCS
797  }
798 }
799 
800 // ***********************************************************
803 {
804  double sumEx = 0;
805  double sumEy = 0;
806  double sumEt = 0;
807 
808  for( unsigned i=0; i<pfCandidates->size(); i++ ) {
809 
810  const reco::PFCandidate& cand = (*pfCandidates)[i];
811 
812  double E = cand.energy();
813 
815  // if( cand.particleId()==PFCandidate::h_HF ||
816  // cand.particleId()==PFCandidate::egamma_HF )
817  // E *= hfCalibFactor_;
818 
819  double phi = cand.phi();
820  double cosphi = cos(phi);
821  double sinphi = sin(phi);
822 
823  double theta = cand.theta();
824  double sintheta = sin(theta);
825 
826  double et = E*sintheta;
827  double ex = et*cosphi;
828  double ey = et*sinphi;
829 
830  sumEx += ex;
831  sumEy += ey;
832  sumEt += et;
833  }
834 
835  double Et = sqrt( sumEx*sumEx + sumEy*sumEy);
836  XYZTLorentzVector missingEt( -sumEx, -sumEy, 0, Et);
837 
838  if(_verbose)
839  if (sumEt!=pfmet.sumEt() || sumEx!=pfmet.px() || sumEy!=pfmet.py() || missingEt.T()!=pfmet.pt() )
840  {
841  std::cout<<"PFSumEt: " << sumEt <<", "<<"PFMETBlock: "<<pfmet.pt()<<std::endl;
842  std::cout<<"PFMET: " << missingEt.T() <<", "<<"PFMETBlock: "<<pfmet.pt()<<std::endl;
843  std::cout<<"PFMETx: " << missingEt.X() <<", "<<"PFMETBlockx: "<<pfmet.pt()<<std::endl;
844  std::cout<<"PFMETy: " << missingEt.Y() <<", "<<"PFMETBlocky: "<<pfmet.pt()<<std::endl;
845  }
846 }
847 
848 // ***********************************************************
850  const reco::PFMET& pfmet)
851 {
852 
853  _dbe->setCurrentFolder(DirName);
854 
855  bool bLumiSecPlot=false;
856  if (DirName.find("All")) bLumiSecPlot=true;
857 
858  if (_trig_JetMB) fillMonitorElement(iEvent,DirName,"",pfmet, bLumiSecPlot);
859  if (_hlt_HighPtJet.size() && _trig_HighPtJet) fillMonitorElement(iEvent,DirName,"HighPtJet",pfmet,false);
860  if (_hlt_LowPtJet.size() && _trig_LowPtJet) fillMonitorElement(iEvent,DirName,"LowPtJet",pfmet,false);
861  if (_hlt_MinBias.size() && _trig_MinBias) fillMonitorElement(iEvent,DirName,"MinBias",pfmet,false);
862  if (_hlt_HighMET.size() && _trig_HighMET) fillMonitorElement(iEvent,DirName,"HighMET",pfmet,false);
863  if (_hlt_LowMET.size() && _trig_LowMET) fillMonitorElement(iEvent,DirName,"LowMET",pfmet,false);
864  if (_hlt_Ele.size() && _trig_Ele) fillMonitorElement(iEvent,DirName,"Ele",pfmet,false);
865  if (_hlt_Muon.size() && _trig_Muon) fillMonitorElement(iEvent,DirName,"Muon",pfmet,false);
866 }
867 
868 // ***********************************************************
870  std::string TriggerTypeName,
871  const reco::PFMET& pfmet, bool bLumiSecPlot)
872 {
873 
874  if (TriggerTypeName=="HighPtJet") {
875  if (!selectHighPtJetEvent(iEvent)) return;
876  }
877  else if (TriggerTypeName=="LowPtJet") {
878  if (!selectLowPtJetEvent(iEvent)) return;
879  }
880  else if (TriggerTypeName=="HighMET") {
881  if (pfmet.pt()<_highPFMETThreshold) return;
882  }
883  else if (TriggerTypeName=="LowMET") {
884  if (pfmet.pt()<_lowPFMETThreshold) return;
885  }
886  else if (TriggerTypeName=="Ele") {
887  if (!selectWElectronEvent(iEvent)) return;
888  }
889  else if (TriggerTypeName=="Muon") {
890  if (!selectWMuonEvent(iEvent)) return;
891  }
892 
893  // Reconstructed MET Information
894  double pfSumET = pfmet.sumEt();
895  double pfMETSig = pfmet.mEtSig();
896  double pfEz = pfmet.e_longitudinal();
897  double pfMET = pfmet.pt();
898  double pfMEx = pfmet.px();
899  double pfMEy = pfmet.py();
900  double pfMETPhi = pfmet.phi();
901 
902  double pfNeutralEMFraction = pfmet.NeutralEMFraction();
903  double pfNeutralHadFraction = pfmet.NeutralHadFraction();
904  double pfChargedEMFraction = pfmet.ChargedEMFraction();
905  double pfChargedHadFraction = pfmet.ChargedHadFraction();
906  double pfMuonFraction = pfmet.MuonFraction();
907 
908 
909  //
910  int myLuminosityBlock;
911  // myLuminosityBlock = (evtCounter++)/1000;
912  myLuminosityBlock = iEvent.luminosityBlock();
913  //
914 
915  if (TriggerTypeName!="") DirName = DirName +"/"+TriggerTypeName;
916 
917  if (_verbose) std::cout << "_etThreshold = " << _etThreshold << std::endl;
918  if (pfSumET>_etThreshold){
919 
920  mePfMEx = _dbe->get(DirName+"/"+"METTask_PfMEx"); if (mePfMEx && mePfMEx->getRootObject()) mePfMEx->Fill(pfMEx);
921  mePfMEy = _dbe->get(DirName+"/"+"METTask_PfMEy"); if (mePfMEy && mePfMEy->getRootObject()) mePfMEy->Fill(pfMEy);
922  mePfMET = _dbe->get(DirName+"/"+"METTask_PfMET"); if (mePfMET && mePfMET->getRootObject()) mePfMET->Fill(pfMET);
923  mePfMETPhi = _dbe->get(DirName+"/"+"METTask_PfMETPhi"); if (mePfMETPhi && mePfMETPhi->getRootObject()) mePfMETPhi->Fill(pfMETPhi);
924  mePfSumET = _dbe->get(DirName+"/"+"METTask_PfSumET"); if (mePfSumET && mePfSumET->getRootObject()) mePfSumET->Fill(pfSumET);
925  mePfMETSig = _dbe->get(DirName+"/"+"METTask_PfMETSig"); if (mePfMETSig && mePfMETSig->getRootObject()) mePfMETSig->Fill(pfMETSig);
926  mePfEz = _dbe->get(DirName+"/"+"METTask_PfEz"); if (mePfEz && mePfEz->getRootObject()) mePfEz->Fill(pfEz);
927 
928  mePfMET_logx = _dbe->get(DirName+"/"+"METTask_PfMET_logx"); if (mePfMET_logx && mePfMET_logx->getRootObject()) mePfMET_logx->Fill(log10(pfMET));
929  mePfSumET_logx = _dbe->get(DirName+"/"+"METTask_PfSumET_logx"); if (mePfSumET_logx && mePfSumET_logx->getRootObject()) mePfSumET_logx->Fill(log10(pfSumET));
930 
931  mePfMETIonFeedbck = _dbe->get(DirName+"/"+"METTask_PfMETIonFeedbck"); if (mePfMETIonFeedbck && mePfMETIonFeedbck->getRootObject()) mePfMETIonFeedbck->Fill(pfMET);
932  mePfMETHPDNoise = _dbe->get(DirName+"/"+"METTask_PfMETHPDNoise"); if (mePfMETHPDNoise && mePfMETHPDNoise->getRootObject()) mePfMETHPDNoise->Fill(pfMET);
933  mePfMETRBXNoise = _dbe->get(DirName+"/"+"METTask_PfMETRBXNoise"); if (mePfMETRBXNoise && mePfMETRBXNoise->getRootObject()) mePfMETRBXNoise->Fill(pfMET);
934 
935  mePfNeutralEMFraction = _dbe->get(DirName+"/"+"METTask_mePfNeutralEMFraction");
936  if (mePfNeutralEMFraction && mePfNeutralEMFraction->getRootObject()) mePfNeutralEMFraction->Fill(pfNeutralEMFraction);
937  mePfNeutralHadFraction = _dbe->get(DirName+"/"+"METTask_mePfNeutralHadFraction");
938  if (mePfNeutralHadFraction && mePfNeutralHadFraction->getRootObject()) mePfNeutralHadFraction->Fill(pfNeutralHadFraction);
939  mePfChargedEMFraction = _dbe->get(DirName+"/"+"METTask_mePfChargedEMFraction");
940  if (mePfChargedEMFraction && mePfChargedEMFraction->getRootObject()) mePfChargedEMFraction->Fill(pfChargedEMFraction);
941  mePfChargedHadFraction = _dbe->get(DirName+"/"+"METTask_mePfChargedHadFraction");
942  if (mePfChargedHadFraction && mePfChargedHadFraction->getRootObject()) mePfChargedHadFraction->Fill(pfChargedHadFraction);
943  mePfMuonFraction = _dbe->get(DirName+"/"+"METTask_mePfMuonFraction");
944  if (mePfMuonFraction && mePfMuonFraction->getRootObject()) mePfMuonFraction->Fill(pfMuonFraction);
945 
946  if (_allhist){
947  if (bLumiSecPlot){
948  mePfMExLS = _dbe->get(DirName+"/"+"METTask_PfMExLS"); if (mePfMExLS && mePfMExLS->getRootObject()) mePfMExLS->Fill(pfMEx,myLuminosityBlock);
949  mePfMEyLS = _dbe->get(DirName+"/"+"METTask_PfMEyLS"); if (mePfMEyLS && mePfMEyLS->getRootObject()) mePfMEyLS->Fill(pfMEy,myLuminosityBlock);
950  }
951  } // _allhist
952  } // et threshold cut
953 }
954 
955 // ***********************************************************
957 
958  bool return_value=false;
959 
961  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
962  if (!pfJets.isValid()) {
963  LogDebug("") << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
964  if (_verbose) std::cout << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
965  }
966 
967  for (reco::PFJetCollection::const_iterator pf = pfJets->begin();
968  pf!=pfJets->end(); ++pf){
969  if (pf->pt()>_highPtPFJetThreshold){
970  return_value=true;
971  }
972  }
973 
974  return return_value;
975 }
976 
977 // // ***********************************************************
979 
980  bool return_value=false;
981 
983  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
984  if (!pfJets.isValid()) {
985  LogDebug("") << "PFMETAnalyzer: Could not find jet product" << std::endl;
986  if (_verbose) std::cout << "PFMETAnalyzer: Could not find jet product" << std::endl;
987  }
988 
989  for (reco::PFJetCollection::const_iterator cal = pfJets->begin();
990  cal!=pfJets->end(); ++cal){
991  if (cal->pt()>_lowPtPFJetThreshold){
992  return_value=true;
993  }
994  }
995 
996  return return_value;
997 
998 }
999 
1000 // ***********************************************************
1002 
1003  bool return_value=true;
1004 
1005  /*
1006  W-electron event selection comes here
1007  */
1008 
1009  return return_value;
1010 
1011 }
1012 
1013 // ***********************************************************
1015 
1016  bool return_value=true;
1017 
1018  /*
1019  W-muon event selection comes here
1020  */
1021 
1022  return return_value;
1023 
1024 }
1025 
#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
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:208
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
virtual ~PFMETAnalyzer()
Destructor.
const std::string metname
double ChargedEMFraction() const
Definition: PFMET.h:67
void validateMET(const reco::PFMET &, edm::Handle< edm::View< reco::PFCandidate > >)
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
bool accept() const
Has at least one path accepted the event?
bool selectWMuonEvent(const edm::Event &)
void fillMESet(const edm::Event &, std::string, const reco::PFMET &)
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
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
Geom::Theta< T > theta() const
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
void endJob()
Finish up a job.
void fillMonitorElement(const edm::Event &, std::string, std::string, const reco::PFMET &, bool)
const bool HcalLooseHaloId() const
std::vector< PFCandidatePtr > pfCandidates(const PFJet &jet, int particleId, bool sort=true)
const bool CSCTightHaloId() const
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:30
PFMETAnalyzer(const edm::ParameterSet &)
Constructor.
virtual double energy() const
energy
double mEtSig() const
Definition: MET.h:50
int iEvent
Definition: GenABIO.cc:243
double sumEt() const
Definition: MET.h:48
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
void beginRun(const edm::Run &, const edm::EventSetup &)
Initialize run-based parameters.
void analyze(const edm::Event &, const edm::EventSetup &, const edm::TriggerResults &)
Get the analysis.
T sqrt(T t)
Definition: SSEVec.h:28
unsigned int size() const
Get number of paths stored.
void makeRatePlot(std::string, double)
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
void bookMESet(std::string)
bool selectLowPtJetEvent(const edm::Event &)
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
bool isValid() const
Definition: HandleBase.h:76
bool getByLabel(InputTag const &tag, Handle< PROD > &result) const
Definition: Event.h:359
#define LogTrace(id)
void bookMonitorElement(std::string, bool)
void beginJob(DQMStore *dbe)
Inizialize parameters for histo binning.
virtual double theta() const
momentum polar angle
double ChargedHadFraction() const
Definition: PFMET.h:68
TObject * getRootObject(void) const
bool selectHighPtJetEvent(const edm::Event &)
virtual double px() const
x coordinate of momentum vector
virtual double pt() const
transverse momentum
double NeutralEMFraction() const
Definition: PFMET.h:65
TH1F * getTH1F(void) const
void endRun(const edm::Run &iRun, const edm::EventSetup &iSetup, DQMStore *dbe)
Finish up a run.
T const * product() const
Definition: Handle.h:74
bool selectWElectronEvent(const edm::Event &)
const bool CSCLooseHaloId() const
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:34
double NeutralHadFraction() const
Definition: PFMET.h:66
double MuonFraction() const
Definition: PFMET.h:69
tuple cout
Definition: gather_cfg.py:41
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
Definition: Run.h:31
Definition: DDAxes.h:10
Collection of PF MET.