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