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