CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PFMETAnalyzer.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * \author K. Hatakeyama - Rockefeller University
5  * A.Apresyan - Caltech
6  */
7 
8 #include "DQMOffline/JetMET/interface/PFMETAnalyzer.h"
9 #include "DataFormats/Common/interface/Handle.h"
10 #include "FWCore/Common/interface/TriggerNames.h"
11 
12 #include "DataFormats/JetReco/interface/PFJetCollection.h"
13 #include "DataFormats/JetReco/interface/PFJet.h"
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 PFMETAnalyzer::PFMETAnalyzer(const edm::ParameterSet& pSet, ConsumesCollector&& iC) {
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_, iC ) );
48  _HighPtJetEventFlag = new GenericTriggerEventFlag( highptjetparms, iC );
49  _LowPtJetEventFlag = new GenericTriggerEventFlag( lowptjetparms , iC );
50  _MinBiasEventFlag = new GenericTriggerEventFlag( minbiasparms , iC );
51  _HighMETEventFlag = new GenericTriggerEventFlag( highmetparms , iC );
52  // _LowMETEventFlag = new GenericTriggerEventFlag( lowmetparms , iC );
53  _EleEventFlag = new GenericTriggerEventFlag( eleparms , iC );
54  _MuonEventFlag = new GenericTriggerEventFlag( muonparms , iC );
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 PFMETAnalyzer::~PFMETAnalyzer() {
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 PFMETAnalyzer::beginJob(DQMStore * dbe) {
80 
81  evtCounter = 0;
82  metname = "pfMETAnalyzer";
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  // ==========================================================
103  //DCS information
104  // ==========================================================
105  DCSFilter = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilter"));
106 
107  //Vertex requirements
108  _doPVCheck = theCleaningParameters.getParameter<bool>("doPrimaryVertexCheck");
109  vertexTag = theCleaningParameters.getParameter<edm::InputTag>("vertexLabel");
110 
111  if (_doPVCheck) {
112  _nvtx_min = theCleaningParameters.getParameter<int>("nvtx_min");
113  _nvtxtrks_min = theCleaningParameters.getParameter<int>("nvtxtrks_min");
114  _vtxndof_min = theCleaningParameters.getParameter<int>("vtxndof_min");
115  _vtxchi2_max = theCleaningParameters.getParameter<double>("vtxchi2_max");
116  _vtxz_max = theCleaningParameters.getParameter<double>("vtxz_max");
117  }
118 
119 
120  // PFMET information
121  thePfMETCollectionLabel = parameters.getParameter<edm::InputTag>("METCollectionLabel");
122  thePfJetCollectionLabel = parameters.getParameter<edm::InputTag>("PfJetCollectionLabel");
123  _source = parameters.getParameter<std::string>("Source");
124 
125  // Other data collections
126  theJetCollectionLabel = parameters.getParameter<edm::InputTag>("JetCollectionLabel");
127  PFCandidatesTag = parameters.getParameter<edm::InputTag>("PFCandidates");
128  HcalNoiseRBXCollectionTag = parameters.getParameter<edm::InputTag>("HcalNoiseRBXCollection");
129  BeamHaloSummaryTag = parameters.getParameter<edm::InputTag>("BeamHaloSummaryLabel");
130  HBHENoiseFilterResultTag = parameters.getParameter<edm::InputTag>("HBHENoiseFilterResultLabel");
131 
132  // misc
133  _verbose = parameters.getParameter<int>("verbose");
134  _etThreshold = parameters.getParameter<double>("etThreshold"); // MET threshold
135  _allhist = parameters.getParameter<bool>("allHist"); // Full set of monitoring histograms
136  _allSelection= parameters.getParameter<bool>("allSelection"); // Plot with all sets of event selection
137  _cleanupSelection= parameters.getParameter<bool>("cleanupSelection"); // Plot with all sets of event selection
138 
139  _highPtPFJetThreshold = parameters.getParameter<double>("HighPtJetThreshold");
140  _lowPtPFJetThreshold = parameters.getParameter<double>("LowPtJetThreshold");
141  _highPFMETThreshold = parameters.getParameter<double>("HighMETThreshold");
142 
143  //
144  jetID = new reco::helper::JetIDHelper(parameters.getParameter<ParameterSet>("JetIDParams"));
145 
146  // DQStore stuff
147  LogTrace(metname)<<"[PFMETAnalyzer] Parameters initialization";
148  std::string DirName = "JetMET/MET/"+_source;
149  dbe->setCurrentFolder(DirName);
150 
151  metME = dbe->book1D("metReco", "metReco", 4, 1, 5);
152  metME->setBinLabel(3,"PFMET",1);
153 
154  _dbe = dbe;
155 
156  _FolderNames.push_back("All");
157  _FolderNames.push_back("BasicCleanup");
158  _FolderNames.push_back("ExtraCleanup");
159  _FolderNames.push_back("HcalNoiseFilter");
160  _FolderNames.push_back("JetIDMinimal");
161  _FolderNames.push_back("JetIDLoose");
162  _FolderNames.push_back("JetIDTight");
163  _FolderNames.push_back("BeamHaloIDTightPass");
164  _FolderNames.push_back("BeamHaloIDLoosePass");
165  _FolderNames.push_back("Triggers");
166  _FolderNames.push_back("PV");
167 
168  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
169  ic != _FolderNames.end(); ic++){
170  if (*ic=="All") bookMESet(DirName+"/"+*ic);
171  if (_cleanupSelection){
172  if (*ic=="BasicCleanup") bookMESet(DirName+"/"+*ic);
173  if (*ic=="ExtraCleanup") bookMESet(DirName+"/"+*ic);
174  }
175  if (_allSelection){
176  if (*ic=="HcalNoiseFilter") bookMESet(DirName+"/"+*ic);
177  if (*ic=="JetIDMinimal") bookMESet(DirName+"/"+*ic);
178  if (*ic=="JetIDLoose") bookMESet(DirName+"/"+*ic);
179  if (*ic=="JetIDTight") bookMESet(DirName+"/"+*ic);
180  if (*ic=="BeamHaloIDTightPass") bookMESet(DirName+"/"+*ic);
181  if (*ic=="BeamHaloIDLoosePass") bookMESet(DirName+"/"+*ic);
182  if (*ic=="Triggers") bookMESet(DirName+"/"+*ic);
183  if (*ic=="PV") bookMESet(DirName+"/"+*ic);
184  }
185  }
186 }
187 
188 // ***********************************************************
189 void PFMETAnalyzer::endJob() {
190 
191  delete jetID;
192  delete DCSFilter;
193 
194 }
195 
196 // ***********************************************************
197 void PFMETAnalyzer::bookMESet(std::string DirName)
198 {
199 
200  bool bLumiSecPlot=false;
201  if (DirName.find("All")!=std::string::npos) bLumiSecPlot=true;
202 
203  bookMonitorElement(DirName,bLumiSecPlot);
204 
205  if ( _HighPtJetEventFlag->on() ) {
206  bookMonitorElement(DirName+"/"+"HighPtJet",false);
207  meTriggerName_HighPtJet = _dbe->bookString("triggerName_HighPtJet", highPtJetExpr_[0]);
208  }
209 
210  if ( _LowPtJetEventFlag->on() ) {
211  bookMonitorElement(DirName+"/"+"LowPtJet",false);
212  meTriggerName_LowPtJet = _dbe->bookString("triggerName_LowPtJet", lowPtJetExpr_[0]);
213  }
214 
215  if ( _MinBiasEventFlag->on() ) {
216  bookMonitorElement(DirName+"/"+"MinBias",false);
217  meTriggerName_MinBias = _dbe->bookString("triggerName_MinBias", minbiasExpr_[0]);
218  if (_verbose) std::cout << "_MinBiasEventFlag is on, folder created\n";
219  }
220 
221  if ( _HighMETEventFlag->on() ) {
222  bookMonitorElement(DirName+"/"+"HighMET",false);
223  meTriggerName_HighMET = _dbe->bookString("triggerName_HighMET", highMETExpr_[0]);
224  }
225 
226  if ( _EleEventFlag->on() ) {
227  bookMonitorElement(DirName+"/"+"Ele",false);
228  meTriggerName_Ele = _dbe->bookString("triggerName_Ele", elecExpr_[0]);
229  if (_verbose) std::cout << "_EleEventFlag is on, folder created\n";
230  }
231 
232  if ( _MuonEventFlag->on() ) {
233  bookMonitorElement(DirName+"/"+"Muon",false);
234  meTriggerName_Muon = _dbe->bookString("triggerName_Muon", muonExpr_[0]);
235  if (_verbose) std::cout << "_MuonEventFlag is on, folder created\n";
236  }
237 }
238 
239 
240 //------------------------------------------------------------------------------
241 // bookMonitorElement
242 //------------------------------------------------------------------------------
243 void PFMETAnalyzer::bookMonitorElement(std::string DirName,
244  bool bLumiSecPlot = false)
245 {
246  _dbe->setCurrentFolder(DirName);
247 
248 
249  mePfMEx = _dbe->book1D("METTask_PfMEx", "pfmet.px()", 200, -500, 500);
250  mePfMEy = _dbe->book1D("METTask_PfMEy", "pfmet.py()", 200, -500, 500);
251  mePfMET = _dbe->book1D("METTask_PfMET", "pfmet.pt()", 200, 0, 1000);
252  mePfSumET = _dbe->book1D("METTask_PfSumET", "pfmet.sumEt()", 400, 0, 4000);
253  mePfMETSig = _dbe->book1D("METTask_PfMETSig", "pfmet.mEtSig()", 51, 0, 51);
254  mePfMETPhi = _dbe->book1D("METTask_PfMETPhi", "pfmet.phi()", 60, -3.2, 3.2);
255  mePfMET_logx = _dbe->book1D("METTask_PfMET_logx", "log10(pfmet.pt())", 40, -1, 7);
256  mePfSumET_logx = _dbe->book1D("METTask_PfSumET_logx", "log10(pfmet.sumEt())", 40, -1, 7);
257 
258 
259  mePhotonEtFraction = _dbe->book1D("METTask_PfPhotonEtFraction", "pfmet.photonEtFraction()", 50, 0, 1);
260  mePhotonEt = _dbe->book1D("METTask_PfPhotonEt", "pfmet.photonEt()", 100, 0, 1000);
261  meNeutralHadronEtFraction = _dbe->book1D("METTask_PfNeutralHadronEtFraction", "pfmet.neutralHadronEtFraction()", 50, 0, 1);
262  meNeutralHadronEt = _dbe->book1D("METTask_PfNeutralHadronEt", "pfmet.neutralHadronEt()", 100, 0, 1000);
263  meElectronEtFraction = _dbe->book1D("METTask_PfElectronEtFraction", "pfmet.electronEtFraction()", 50, 0, 1);
264  meElectronEt = _dbe->book1D("METTask_PfElectronEt", "pfmet.electronEt()", 100, 0, 1000);
265  meChargedHadronEtFraction = _dbe->book1D("METTask_PfChargedHadronEtFraction", "pfmet.chargedHadronEtFraction()", 50, 0, 1);
266  meChargedHadronEt = _dbe->book1D("METTask_PfChargedHadronEt", "pfmet.chargedHadronEt()", 100, 0, 1000);
267  meMuonEtFraction = _dbe->book1D("METTask_PfMuonEtFraction", "pfmet.muonEtFraction()", 50, 0, 1);
268  meMuonEt = _dbe->book1D("METTask_PfMuonEt", "pfmet.muonEt()", 100, 0, 1000);
269  meHFHadronEtFraction = _dbe->book1D("METTask_PfHFHadronEtFraction", "pfmet.HFHadronEtFraction()", 50, 0, 1);
270  meHFHadronEt = _dbe->book1D("METTask_PfHFHadronEt", "pfmet.HFHadronEt()", 100, 0, 1000);
271  meHFEMEtFraction = _dbe->book1D("METTask_PfHFEMEtFraction", "pfmet.HFEMEtFraction()", 50, 0, 1);
272  meHFEMEt = _dbe->book1D("METTask_PfHFEMEt", "pfmet.HFEMEt()", 100, 0, 1000);
273 
274 
275  if (_allhist) {
276  if (bLumiSecPlot) {
277 
278  mePfMExLS = _dbe->book2D("METTask_PfMEx_LS", "METTask_PfMEx_LS", 200, -200, 200, 50, 0, 500);
279  mePfMEyLS = _dbe->book2D("METTask_PfMEy_LS", "METTask_PfMEy_LS", 200, -200, 200, 50, 0, 500);
280 
281  mePfMExLS->setAxisTitle("pfmet.px()", 1);
282  mePfMEyLS->setAxisTitle("pfmet.px()", 1);
283 
284  mePfMExLS->setAxisTitle("event.luminosityBlock()", 2);
285  mePfMEyLS->setAxisTitle("event.luminosityBlock()", 2);
286  }
287  }
288 
289 
290  // Book NPV profiles
291  //----------------------------------------------------------------------------
292  mePfMEx_profile = _dbe->bookProfile("METTask_PfMEx_profile", "pfmet.px()", nbinsPV, PVlow, PVup, 200, -500, 500);
293  mePfMEy_profile = _dbe->bookProfile("METTask_PfMEy_profile", "pfmet.py()", nbinsPV, PVlow, PVup, 200, -500, 500);
294  mePfMET_profile = _dbe->bookProfile("METTask_PfMET_profile", "pfmet.pt()", nbinsPV, PVlow, PVup, 200, 0, 1000);
295  mePfSumET_profile = _dbe->bookProfile("METTask_PfSumET_profile", "pfmet.sumEt()", nbinsPV, PVlow, PVup, 400, 0, 4000);
296 
297  mePhotonEtFraction_profile = _dbe->bookProfile("METTask_PfPhotonEtFraction_profile", "pfmet.photonEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
298  mePhotonEt_profile = _dbe->bookProfile("METTask_PfPhotonEt_profile", "pfmet.photonEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
299  meNeutralHadronEtFraction_profile = _dbe->bookProfile("METTask_PfNeutralHadronEtFraction_profile", "pfmet.neutralHadronEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
300  meNeutralHadronEt_profile = _dbe->bookProfile("METTask_PfNeutralHadronEt_profile", "pfmet.neutralHadronEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
301  meElectronEtFraction_profile = _dbe->bookProfile("METTask_PfElectronEtFraction_profile", "pfmet.electronEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
302  meElectronEt_profile = _dbe->bookProfile("METTask_PfElectronEt_profile", "pfmet.electronEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
303  meChargedHadronEtFraction_profile = _dbe->bookProfile("METTask_PfChargedHadronEtFraction_profile", "pfmet.chargedHadronEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
304  meChargedHadronEt_profile = _dbe->bookProfile("METTask_PfChargedHadronEt_profile", "pfmet.chargedHadronEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
305  meMuonEtFraction_profile = _dbe->bookProfile("METTask_PfMuonEtFraction_profile", "pfmet.muonEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
306  meMuonEt_profile = _dbe->bookProfile("METTask_PfMuonEt_profile", "pfmet.muonEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
307  meHFHadronEtFraction_profile = _dbe->bookProfile("METTask_PfHFHadronEtFraction_profile", "pfmet.HFHadronEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
308  meHFHadronEt_profile = _dbe->bookProfile("METTask_PfHFHadronEt_profile", "pfmet.HFHadronEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
309  meHFEMEtFraction_profile = _dbe->bookProfile("METTask_PfHFEMEtFraction_profile", "pfmet.HFEMEtFraction()", nbinsPV, PVlow, PVup, 50, 0, 1);
310  meHFEMEt_profile = _dbe->bookProfile("METTask_PfHFEMEt_profile", "pfmet.HFEMEt()", nbinsPV, PVlow, PVup, 100, 0, 1000);
311 
312 
313  // Set NPV profiles x-axis title
314  //----------------------------------------------------------------------------
315  mePfMEx_profile ->setAxisTitle("nvtx", 1);
316  mePfMEy_profile ->setAxisTitle("nvtx", 1);
317  mePfMET_profile ->setAxisTitle("nvtx", 1);
318  mePfSumET_profile->setAxisTitle("nvtx", 1);
319 
320  mePhotonEtFraction_profile ->setAxisTitle("nvtx", 1);
321  mePhotonEt_profile ->setAxisTitle("nvtx", 1);
322  meNeutralHadronEtFraction_profile->setAxisTitle("nvtx", 1);
323  meNeutralHadronEt_profile ->setAxisTitle("nvtx", 1);
324  meElectronEtFraction_profile ->setAxisTitle("nvtx", 1);
325  meElectronEt_profile ->setAxisTitle("nvtx", 1);
326  meChargedHadronEtFraction_profile->setAxisTitle("nvtx", 1);
327  meChargedHadronEt_profile ->setAxisTitle("nvtx", 1);
328  meMuonEtFraction_profile ->setAxisTitle("nvtx", 1);
329  meMuonEt_profile ->setAxisTitle("nvtx", 1);
330  meHFHadronEtFraction_profile ->setAxisTitle("nvtx", 1);
331  meHFHadronEt_profile ->setAxisTitle("nvtx", 1);
332  meHFEMEtFraction_profile ->setAxisTitle("nvtx", 1);
333  meHFEMEt_profile ->setAxisTitle("nvtx", 1);
334 }
335 
336 
337 //------------------------------------------------------------------------------
338 // beginRun
339 //------------------------------------------------------------------------------
340 void PFMETAnalyzer::beginRun(const edm::Run& iRun,
341  const edm::EventSetup& iSetup)
342 {
343  if (_HighPtJetEventFlag->on()) _HighPtJetEventFlag->initRun(iRun, iSetup);
344  if (_LowPtJetEventFlag ->on()) _LowPtJetEventFlag ->initRun(iRun, iSetup);
345  if (_MinBiasEventFlag ->on()) _MinBiasEventFlag ->initRun(iRun, iSetup);
346  if (_HighMETEventFlag ->on()) _HighMETEventFlag ->initRun(iRun, iSetup);
347  if (_EleEventFlag ->on()) _EleEventFlag ->initRun(iRun, iSetup);
348  if (_MuonEventFlag ->on()) _MuonEventFlag ->initRun(iRun, iSetup);
349 
350  if (_HighPtJetEventFlag->on() && _HighPtJetEventFlag->expressionsFromDB(_HighPtJetEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
351  highPtJetExpr_ = _HighPtJetEventFlag->expressionsFromDB(_HighPtJetEventFlag->hltDBKey(), iSetup);
352 
353  if (_LowPtJetEventFlag->on() && _LowPtJetEventFlag->expressionsFromDB(_LowPtJetEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
354  lowPtJetExpr_ = _LowPtJetEventFlag->expressionsFromDB(_LowPtJetEventFlag->hltDBKey(), iSetup);
355 
356  if (_HighMETEventFlag->on() && _HighMETEventFlag->expressionsFromDB(_HighMETEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
357  highMETExpr_ = _HighMETEventFlag->expressionsFromDB(_HighMETEventFlag->hltDBKey(), iSetup);
358 
359  if (_MuonEventFlag->on() && _MuonEventFlag->expressionsFromDB(_MuonEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
360  muonExpr_ = _MuonEventFlag->expressionsFromDB(_MuonEventFlag->hltDBKey(), iSetup);
361 
362  if (_EleEventFlag->on() && _EleEventFlag->expressionsFromDB(_EleEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
363  elecExpr_ = _EleEventFlag->expressionsFromDB(_EleEventFlag->hltDBKey(), iSetup);
364 
365  if (_MinBiasEventFlag->on() && _MinBiasEventFlag->expressionsFromDB(_MinBiasEventFlag->hltDBKey(), iSetup)[0] != "CONFIG_ERROR")
366  minbiasExpr_ = _MinBiasEventFlag->expressionsFromDB(_MinBiasEventFlag->hltDBKey(), iSetup);
367 }
368 
369 
370 //------------------------------------------------------------------------------
371 // endRun
372 //------------------------------------------------------------------------------
373 void PFMETAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup, DQMStore * dbe)
374 {
375 
376  //
377  //--- Check the time length of the Run from the lumi section plots
378 
379  std::string dirName = "JetMET/MET/"+_source+"/";
380  _dbe->setCurrentFolder(dirName);
381 
382  TH1F* tlumisec;
383 
384  MonitorElement *meLumiSec = _dbe->get("aaa");
385  meLumiSec = _dbe->get("JetMET/lumisec");
386 
387  int totlsec=0;
388  double totltime=0.;
389  if ( meLumiSec->getRootObject() ) {
390  tlumisec = meLumiSec->getTH1F();
391  for (int i=0; i<500; i++){
392  if (tlumisec->GetBinContent(i+1)) totlsec++;
393  }
394  totltime = double(totlsec*90); // one lumi sec ~ 90 (sec)
395  }
396 
397  if (totltime==0.) totltime=1.;
398 
399  //
400  //--- Make the integrated plots with rate (Hz)
401 
402  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin(); ic != _FolderNames.end(); ic++)
403  {
404 
405  std::string DirName;
406  DirName = dirName+*ic;
407 
408  makeRatePlot(DirName,totltime);
409  if ( _HighPtJetEventFlag->on() )
410  makeRatePlot(DirName+"/"+"triggerName_HighJetPt",totltime);
411  if ( _LowPtJetEventFlag->on() )
412  makeRatePlot(DirName+"/"+"triggerName_LowJetPt",totltime);
413  if ( _MinBiasEventFlag->on() )
414  makeRatePlot(DirName+"/"+"triggerName_MinBias",totltime);
415  if ( _HighMETEventFlag->on() )
416  makeRatePlot(DirName+"/"+"triggerName_HighMET",totltime);
417  if ( _EleEventFlag->on() )
418  makeRatePlot(DirName+"/"+"triggerName_Ele",totltime);
419  if ( _MuonEventFlag->on() )
420  makeRatePlot(DirName+"/"+"triggerName_Muon",totltime);
421  }
422 }
423 
424 
425 // ***********************************************************
426 void PFMETAnalyzer::makeRatePlot(std::string DirName, double totltime)
427 {
428 
429  _dbe->setCurrentFolder(DirName);
430  MonitorElement *mePfMET = _dbe->get(DirName+"/"+"METTask_PfMET");
431 
432  TH1F* tPfMET;
433  TH1F* tPfMETRate;
434 
435  if ( mePfMET )
436  if ( mePfMET->getRootObject() ) {
437  tPfMET = mePfMET->getTH1F();
438 
439  // Integral plot & convert number of events to rate (hz)
440  tPfMETRate = (TH1F*) tPfMET->Clone("METTask_PfMETRate");
441  for (int i = tPfMETRate->GetNbinsX()-1; i>=0; i--){
442  tPfMETRate->SetBinContent(i+1,tPfMETRate->GetBinContent(i+2)+tPfMET->GetBinContent(i+1));
443  }
444  for (int i = 0; i<tPfMETRate->GetNbinsX(); i++){
445  tPfMETRate->SetBinContent(i+1,tPfMETRate->GetBinContent(i+1)/double(totltime));
446  }
447 
448  tPfMETRate->SetName("METTask_PfMETRate");
449  tPfMETRate->SetTitle("METTask_PfMETRate");
450  mePfMETRate = _dbe->book1D("METTask_PfMETRate",tPfMETRate);
451 
452  }
453 }
454 
455 // ***********************************************************
456 void PFMETAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup,
457  const edm::TriggerResults& triggerResults) {
458 
459  if (_verbose) std::cout << "PfMETAnalyzer analyze" << std::endl;
460 
461  LogTrace(metname)<<"[PFMETAnalyzer] Analyze PFMET";
462 
463  metME->Fill(3);
464 
465  // ==========================================================
466  // Trigger information
467  //
468  _trig_JetMB=0;
469  _trig_HighPtJet=0;
470  _trig_LowPtJet=0;
471  _trig_MinBias=0;
472  _trig_HighMET=0;
473  _trig_Ele=0;
474  _trig_Muon=0;
475  _trig_PhysDec=0;
476  if(&triggerResults) {
477 
479 
480  //
481  //
482  // Check how many HLT triggers are in triggerResults
483  int ntrigs = triggerResults.size();
484  if (_verbose) std::cout << "ntrigs=" << ntrigs << std::endl;
485 
486  //
487  //
488  // If index=ntrigs, this HLT trigger doesn't exist in the HLT table for this data.
489  const edm::TriggerNames & triggerNames = iEvent.triggerNames(triggerResults);
490 
491  //
492  //
493  const unsigned int nTrig(triggerNames.size());
494  for (unsigned int i=0;i<nTrig;++i)
495  {
496  if (triggerNames.triggerName(i).find(highPtJetExpr_[0].substr(0,highPtJetExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
497  _trig_HighPtJet=true;
498  else if (triggerNames.triggerName(i).find(lowPtJetExpr_[0].substr(0,lowPtJetExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
499  _trig_LowPtJet=true;
500  else if (triggerNames.triggerName(i).find(highMETExpr_[0].substr(0,highMETExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
501  _trig_HighMET=true;
502  // else if (triggerNames.triggerName(i).find(lowMETExpr_[0].substr(0,lowMETExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
503  // _trig_LowMET=true;
504  else if (triggerNames.triggerName(i).find(muonExpr_[0].substr(0,muonExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
505  _trig_Muon=true;
506  else if (triggerNames.triggerName(i).find(elecExpr_[0].substr(0,elecExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
507  _trig_Ele=true;
508  else if (triggerNames.triggerName(i).find(minbiasExpr_[0].substr(0,minbiasExpr_[0].rfind("_v")+2))!=std::string::npos && triggerResults.accept(i))
509  _trig_MinBias=true;
510  }
511 
512  // count number of requested Jet or MB HLT paths which have fired
513  for (unsigned int i=0; i!=HLTPathsJetMBByName_.size(); i++) {
514  unsigned int triggerIndex = triggerNames.triggerIndex(HLTPathsJetMBByName_[i]);
515  if (triggerIndex<triggerResults.size()) {
516  if (triggerResults.accept(triggerIndex)) {
517  _trig_JetMB++;
518  }
519  }
520  }
521  // for empty input vectors (n==0), take all HLT triggers!
522  if (HLTPathsJetMBByName_.size()==0) _trig_JetMB=triggerResults.size()-1;
523 
524 
525  if (triggerNames.triggerIndex(_hlt_PhysDec) != triggerNames.size() &&
526  triggerResults.accept(triggerNames.triggerIndex(_hlt_PhysDec))) _trig_PhysDec=1;
527  } else {
528 
529  edm::LogInfo("PFMetAnalyzer") << "TriggerResults::HLT not found, "
530  "automatically select events";
531 
532  // TriggerResults object not found. Look at all events.
533  _trig_JetMB=1;
534  }
535 
536  // ==========================================================
537  // PfMET information
538 
539  // **** Get the MET container
540  edm::Handle<reco::PFMETCollection> pfmetcoll;
541  iEvent.getByLabel(thePfMETCollectionLabel, pfmetcoll);
542 
543  if(!pfmetcoll.isValid()) return;
544 
545  const PFMETCollection *pfmetcol = pfmetcoll.product();
546  const PFMET *pfmet;
547  pfmet = &(pfmetcol->front());
548 
549  LogTrace(metname)<<"[PfMETAnalyzer] Call to the PfMET analyzer";
550 
551  // ==========================================================
552  //
553  edm::Handle<HcalNoiseRBXCollection> HRBXCollection;
554  iEvent.getByLabel(HcalNoiseRBXCollectionTag,HRBXCollection);
555  if (!HRBXCollection.isValid()) {
556  LogDebug("") << "PfMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
557  if (_verbose) std::cout << "PfMETAnalyzer: Could not find HcalNoiseRBX Collection" << std::endl;
558  }
559 
560 
561  edm::Handle<bool> HBHENoiseFilterResultHandle;
562  iEvent.getByLabel(HBHENoiseFilterResultTag, HBHENoiseFilterResultHandle);
563  bool HBHENoiseFilterResult = *HBHENoiseFilterResultHandle;
564  if (!HBHENoiseFilterResultHandle.isValid()) {
565  LogDebug("") << "PFMETAnalyzer: Could not find HBHENoiseFilterResult" << std::endl;
566  if (_verbose) std::cout << "PFMETAnalyzer: Could not find HBHENoiseFilterResult" << std::endl;
567  }
568 
569 
570  edm::Handle<reco::CaloJetCollection> caloJets;
571  iEvent.getByLabel(theJetCollectionLabel, caloJets);
572  if (!caloJets.isValid()) {
573  LogDebug("") << "PFMETAnalyzer: Could not find jet product" << std::endl;
574  if (_verbose) std::cout << "PFMETAnalyzer: Could not find jet product" << std::endl;
575  }
576 
577  edm::Handle<edm::View<PFCandidate> > pfCandidates;
578  iEvent.getByLabel(PFCandidatesTag, pfCandidates);
579  if (!pfCandidates.isValid()) {
580  LogDebug("") << "PfMETAnalyzer: Could not find pfcandidates product" << std::endl;
581  if (_verbose) std::cout << "PfMETAnalyzer: Could not find pfcandidates product" << std::endl;
582  }
583 
584  edm::Handle<reco::PFJetCollection> pfJets;
585  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
586  if (!pfJets.isValid()) {
587  LogDebug("") << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
588  if (_verbose) std::cout << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
589  }
590  // ==========================================================
591  // PfMET sanity check
592 
593  if (_source=="PfMET") validateMET(*pfmet, pfCandidates);
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 PF 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  bool bBeamHaloIDTightPass = true;
702  bool bBeamHaloIDLoosePass = true;
703 
704  if(!TheBeamHaloSummary.isValid()) {
705 
706  const BeamHaloSummary TheSummary = (*TheBeamHaloSummary.product() );
707 
708  if( !TheSummary.EcalLooseHaloId() && !TheSummary.HcalLooseHaloId() &&
709  !TheSummary.CSCLooseHaloId() && !TheSummary.GlobalLooseHaloId() )
710  bBeamHaloIDLoosePass = false;
711 
712  if( !TheSummary.EcalTightHaloId() && !TheSummary.HcalTightHaloId() &&
713  !TheSummary.CSCTightHaloId() && !TheSummary.GlobalTightHaloId() )
714  bBeamHaloIDTightPass = false;
715 
716  }
717 
718  // ==========================================================
719  //Vertex information
720 
721  _numPV = 0;
722  bool bPrimaryVertex = true;
723  if(_doPVCheck){
724  bPrimaryVertex = false;
725  Handle<VertexCollection> vertexHandle;
726 
727  iEvent.getByLabel(vertexTag, vertexHandle);
728 
729  if (!vertexHandle.isValid()) {
730  LogDebug("") << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
731  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find vertex collection" << std::endl;
732  }
733 
734  if ( vertexHandle.isValid() ){
735  VertexCollection vertexCollection = *(vertexHandle.product());
736  int vertex_number = vertexCollection.size();
737  VertexCollection::const_iterator v = vertexCollection.begin();
738  for ( ; v != vertexCollection.end(); ++v) {
739  double vertex_chi2 = v->normalizedChi2();
740  double vertex_ndof = v->ndof();
741  bool fakeVtx = v->isFake();
742  double vertex_Z = v->z();
743 
744  if ( !fakeVtx
745  && vertex_number>=_nvtx_min
746  && vertex_ndof >_vtxndof_min
747  && vertex_chi2 <_vtxchi2_max
748  && fabs(vertex_Z)<_vtxz_max ) {
749  bPrimaryVertex = true;
750  ++_numPV;
751  }
752  }
753  }
754  }
755  // ==========================================================
756 
757  edm::Handle< L1GlobalTriggerReadoutRecord > gtReadoutRecord;
758  iEvent.getByLabel( gtTag, gtReadoutRecord);
759 
760  if (!gtReadoutRecord.isValid()) {
761  LogDebug("") << "CaloMETAnalyzer: Could not find GT readout record" << std::endl;
762  if (_verbose) std::cout << "CaloMETAnalyzer: Could not find GT readout record product" << std::endl;
763  }
764 
765  bool bTechTriggers = true;
766  bool bTechTriggersAND = true;
767  bool bTechTriggersOR = false;
768  bool bTechTriggersNOT = false;
769 
770  if (gtReadoutRecord.isValid()) {
771  const TechnicalTriggerWord& technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();
772 
773  if (_techTrigsAND.size() == 0)
774  bTechTriggersAND = true;
775  else
776  for (unsigned ttr = 0; ttr != _techTrigsAND.size(); ttr++) {
777  bTechTriggersAND = bTechTriggersAND && technicalTriggerWordBeforeMask.at(_techTrigsAND.at(ttr));
778  }
779 
780  if (_techTrigsAND.size() == 0)
781  bTechTriggersOR = true;
782  else
783  for (unsigned ttr = 0; ttr != _techTrigsOR.size(); ttr++) {
784  bTechTriggersOR = bTechTriggersOR || technicalTriggerWordBeforeMask.at(_techTrigsOR.at(ttr));
785  }
786  if (_techTrigsNOT.size() == 0)
787  bTechTriggersNOT = false;
788  else
789  for (unsigned ttr = 0; ttr != _techTrigsNOT.size(); ttr++) {
790  bTechTriggersNOT = bTechTriggersNOT || technicalTriggerWordBeforeMask.at(_techTrigsNOT.at(ttr));
791  }
792  }
793  else
794  {
795  bTechTriggersAND = true;
796  bTechTriggersOR = true;
797  bTechTriggersNOT = false;
798  }
799 
800  if (_techTrigsAND.size()==0)
801  bTechTriggersAND = true;
802  if (_techTrigsOR.size()==0)
803  bTechTriggersOR = true;
804  if (_techTrigsNOT.size()==0)
805  bTechTriggersNOT = false;
806 
807  bTechTriggers = bTechTriggersAND && bTechTriggersOR && !bTechTriggersNOT;
808 
809  // ==========================================================
810  // Reconstructed MET Information - fill MonitorElements
811 
812  bool bHcalNoise = bHcalNoiseFilter;
813  bool bBeamHaloID = bBeamHaloIDLoosePass;
814  bool bJetID = bJetIDMinimal;
815 
816  bool bPhysicsDeclared = true;
817  if(_doHLTPhysicsOn) bPhysicsDeclared =_trig_PhysDec;
818 
819  if (_tightBHFiltering) bBeamHaloID = bBeamHaloIDTightPass;
820 
821  if (_tightJetIDFiltering==1) bJetID = bJetIDMinimal;
822  else if (_tightJetIDFiltering==2) bJetID = bJetIDLoose;
823  else if (_tightJetIDFiltering==3) bJetID = bJetIDTight;
824  else if (_tightJetIDFiltering==-1) bJetID = true;
825 
826  bool bBasicCleanup = bTechTriggers && bPrimaryVertex && bPhysicsDeclared;
827  bool bExtraCleanup = bBasicCleanup && bHcalNoise && bJetID && bBeamHaloID;
828 
829  std::string DirName = "JetMET/MET/"+_source;
830 
831  for (std::vector<std::string>::const_iterator ic = _FolderNames.begin();
832  ic != _FolderNames.end(); ic++){
833  if (*ic=="All") fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
834  if (DCSFilter->filter(iEvent, iSetup)) {
835  if (_cleanupSelection){
836  if (*ic=="BasicCleanup" && bBasicCleanup) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
837  if (*ic=="ExtraCleanup" && bExtraCleanup) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
838  }
839  if (_allSelection) {
840  if (*ic=="HcalNoiseFilter" && bHcalNoiseFilter ) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
841  if (*ic=="JetIDMinimal" && bJetIDMinimal) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
842  if (*ic=="JetIDLoose" && bJetIDLoose) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
843  if (*ic=="JetIDTight" && bJetIDTight) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
844  if (*ic=="BeamHaloIDTightPass" && bBeamHaloIDTightPass) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
845  if (*ic=="BeamHaloIDLoosePass" && bBeamHaloIDLoosePass) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
846  if (*ic=="Triggers" && bTechTriggers) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
847  if (*ic=="PV" && bPrimaryVertex) fillMESet(iEvent, DirName+"/"+*ic, *pfmet);
848  }
849  } // DCS
850  }
851 }
852 
853 
854 // ***********************************************************
855 void PFMETAnalyzer::validateMET(const reco::PFMET& pfmet,
856  edm::Handle<edm::View<PFCandidate> > pfCandidates)
857 {
858  double sumEx = 0;
859  double sumEy = 0;
860  double sumEt = 0;
861 
862  for( unsigned i=0; i<pfCandidates->size(); i++ ) {
863 
864  const reco::PFCandidate& cand = (*pfCandidates)[i];
865 
866  double E = cand.energy();
867 
869  // if( cand.particleId()==PFCandidate::h_HF ||
870  // cand.particleId()==PFCandidate::egamma_HF )
871  // E *= hfCalibFactor_;
872 
873  double phi = cand.phi();
874  double cosphi = cos(phi);
875  double sinphi = sin(phi);
876 
877  double theta = cand.theta();
878  double sintheta = sin(theta);
879 
880  double et = E*sintheta;
881  double ex = et*cosphi;
882  double ey = et*sinphi;
883 
884  sumEx += ex;
885  sumEy += ey;
886  sumEt += et;
887  }
888 
889  double Et = sqrt( sumEx*sumEx + sumEy*sumEy);
890  XYZTLorentzVector missingEt( -sumEx, -sumEy, 0, Et);
891 
892  if(_verbose)
893  if (sumEt!=pfmet.sumEt() || sumEx!=pfmet.px() || sumEy!=pfmet.py() || missingEt.T()!=pfmet.pt() )
894  {
895  std::cout<<"PFSumEt: " << sumEt <<", "<<"PFMETBlock: "<<pfmet.pt()<<std::endl;
896  std::cout<<"PFMET: " << missingEt.T() <<", "<<"PFMETBlock: "<<pfmet.pt()<<std::endl;
897  std::cout<<"PFMETx: " << missingEt.X() <<", "<<"PFMETBlockx: "<<pfmet.pt()<<std::endl;
898  std::cout<<"PFMETy: " << missingEt.Y() <<", "<<"PFMETBlocky: "<<pfmet.pt()<<std::endl;
899  }
900 }
901 
902 // ***********************************************************
903 void PFMETAnalyzer::fillMESet(const edm::Event& iEvent, std::string DirName,
904  const reco::PFMET& pfmet)
905 {
906 
907  _dbe->setCurrentFolder(DirName);
908 
909  bool bLumiSecPlot=false;
910  if (DirName.find("All")) bLumiSecPlot=true;
911 
912  if (_trig_JetMB)
913  fillMonitorElement(iEvent,DirName,"",pfmet, bLumiSecPlot);
914  if (_trig_HighPtJet)
915  fillMonitorElement(iEvent,DirName,"HighPtJet",pfmet,false);
916  if (_trig_LowPtJet)
917  fillMonitorElement(iEvent,DirName,"LowPtJet",pfmet,false);
918  if (_trig_MinBias)
919  fillMonitorElement(iEvent,DirName,"MinBias",pfmet,false);
920  if (_trig_HighMET)
921  fillMonitorElement(iEvent,DirName,"HighMET",pfmet,false);
922  if (_trig_Ele)
923  fillMonitorElement(iEvent,DirName,"Ele",pfmet,false);
924  if (_trig_Muon)
925  fillMonitorElement(iEvent,DirName,"Muon",pfmet,false);
926 }
927 
928 
929 //------------------------------------------------------------------------------
930 // fillMonitorElement
931 //------------------------------------------------------------------------------
932 void PFMETAnalyzer::fillMonitorElement(const edm::Event& iEvent,
933  std::string DirName,
934  std::string TriggerTypeName,
935  const reco::PFMET& pfmet,
936  bool bLumiSecPlot)
937 {
938  if (TriggerTypeName == "HighPtJet") {
939  if (!selectHighPtJetEvent(iEvent)) return;
940  }
941  else if (TriggerTypeName == "LowPtJet") {
942  if (!selectLowPtJetEvent(iEvent)) return;
943  }
944  else if (TriggerTypeName == "HighMET") {
945  if (pfmet.pt()<_highPFMETThreshold) return;
946  }
947  else if (TriggerTypeName == "Ele") {
948  if (!selectWElectronEvent(iEvent)) return;
949  }
950  else if (TriggerTypeName == "Muon") {
951  if (!selectWMuonEvent(iEvent)) return;
952  }
953 
954  if (TriggerTypeName != "") DirName = DirName + "/" + TriggerTypeName;
955 
956 
957  // Reconstructed PFMET information
958  //----------------------------------------------------------------------------
959  double pfSumET = pfmet.sumEt();
960  double pfMETSig = pfmet.mEtSig();
961  double pfMET = pfmet.pt();
962  double pfMEx = pfmet.px();
963  double pfMEy = pfmet.py();
964  double pfMETPhi = pfmet.phi();
965 
966 
967  // PFMET getters
968  //----------------------------------------------------------------------------
969  double pfPhotonEtFraction = pfmet.photonEtFraction();
970  double pfPhotonEt = pfmet.photonEt();
971  double pfNeutralHadronEtFraction = pfmet.neutralHadronEtFraction();
972  double pfNeutralHadronEt = pfmet.neutralHadronEt();
973  double pfElectronEtFraction = pfmet.electronEtFraction();
974  double pfElectronEt = pfmet.electronEt();
975  double pfChargedHadronEtFraction = pfmet.chargedHadronEtFraction();
976  double pfChargedHadronEt = pfmet.chargedHadronEt();
977  double pfMuonEtFraction = pfmet.muonEtFraction();
978  double pfMuonEt = pfmet.muonEt();
979  double pfHFHadronEtFraction = pfmet.HFHadronEtFraction();
980  double pfHFHadronEt = pfmet.HFHadronEt();
981  double pfHFEMEtFraction = pfmet.HFEMEtFraction();
982  double pfHFEMEt = pfmet.HFEMEt();
983 
984 
985  if (pfSumET > _etThreshold) {
986 
987  mePfMEx = _dbe->get(DirName + "/METTask_PfMEx");
988  mePfMEy = _dbe->get(DirName + "/METTask_PfMEy");
989  mePfMET = _dbe->get(DirName + "/METTask_PfMET");
990  mePfMETPhi = _dbe->get(DirName + "/METTask_PfMETPhi");
991  mePfSumET = _dbe->get(DirName + "/METTask_PfSumET");
992  mePfMETSig = _dbe->get(DirName + "/METTask_PfMETSig");
993  mePfMET_logx = _dbe->get(DirName + "/METTask_PfMET_logx");
994  mePfSumET_logx = _dbe->get(DirName + "/METTask_PfSumET_logx");
995 
996  if (mePfMEx && mePfMEx ->getRootObject()) mePfMEx ->Fill(pfMEx);
997  if (mePfMEy && mePfMEy ->getRootObject()) mePfMEy ->Fill(pfMEy);
998  if (mePfMET && mePfMET ->getRootObject()) mePfMET ->Fill(pfMET);
999  if (mePfMETPhi && mePfMETPhi ->getRootObject()) mePfMETPhi ->Fill(pfMETPhi);
1000  if (mePfSumET && mePfSumET ->getRootObject()) mePfSumET ->Fill(pfSumET);
1001  if (mePfMETSig && mePfMETSig ->getRootObject()) mePfMETSig ->Fill(pfMETSig);
1002  if (mePfMET_logx && mePfMET_logx ->getRootObject()) mePfMET_logx ->Fill(log10(pfMET));
1003  if (mePfSumET_logx && mePfSumET_logx->getRootObject()) mePfSumET_logx->Fill(log10(pfSumET));
1004 
1005 
1006  mePhotonEtFraction = _dbe->get(DirName + "/METTask_PfPhotonEtFraction");
1007  mePhotonEt = _dbe->get(DirName + "/METTask_PfPhotonEt");
1008  meNeutralHadronEtFraction = _dbe->get(DirName + "/METTask_PfNeutralHadronEtFraction");
1009  meNeutralHadronEt = _dbe->get(DirName + "/METTask_PfNeutralHadronEt");
1010  meElectronEtFraction = _dbe->get(DirName + "/METTask_PfElectronEtFraction");
1011  meElectronEt = _dbe->get(DirName + "/METTask_PfElectronEt");
1012  meChargedHadronEtFraction = _dbe->get(DirName + "/METTask_PfChargedHadronEtFraction");
1013  meChargedHadronEt = _dbe->get(DirName + "/METTask_PfChargedHadronEt");
1014  meMuonEtFraction = _dbe->get(DirName + "/METTask_PfMuonEtFraction");
1015  meMuonEt = _dbe->get(DirName + "/METTask_PfMuonEt");
1016  meHFHadronEtFraction = _dbe->get(DirName + "/METTask_PfHFHadronEtFraction");
1017  meHFHadronEt = _dbe->get(DirName + "/METTask_PfHFHadronEt");
1018  meHFEMEtFraction = _dbe->get(DirName + "/METTask_PfHFEMEtFraction");
1019  meHFEMEt = _dbe->get(DirName + "/METTask_PfHFEMEt");
1020 
1021  if (mePhotonEtFraction && mePhotonEtFraction ->getRootObject()) mePhotonEtFraction ->Fill(pfPhotonEtFraction);
1022  if (mePhotonEt && mePhotonEt ->getRootObject()) mePhotonEt ->Fill(pfPhotonEt);
1023  if (meNeutralHadronEtFraction && meNeutralHadronEtFraction->getRootObject()) meNeutralHadronEtFraction->Fill(pfNeutralHadronEtFraction);
1024  if (meNeutralHadronEt && meNeutralHadronEt ->getRootObject()) meNeutralHadronEt ->Fill(pfNeutralHadronEt);
1025  if (meElectronEtFraction && meElectronEtFraction ->getRootObject()) meElectronEtFraction ->Fill(pfElectronEtFraction);
1026  if (meElectronEt && meElectronEt ->getRootObject()) meElectronEt ->Fill(pfElectronEt);
1027  if (meChargedHadronEtFraction && meChargedHadronEtFraction->getRootObject()) meChargedHadronEtFraction->Fill(pfChargedHadronEtFraction);
1028  if (meChargedHadronEt && meChargedHadronEt ->getRootObject()) meChargedHadronEt ->Fill(pfChargedHadronEt);
1029  if (meMuonEtFraction && meMuonEtFraction ->getRootObject()) meMuonEtFraction ->Fill(pfMuonEtFraction);
1030  if (meMuonEt && meMuonEt ->getRootObject()) meMuonEt ->Fill(pfMuonEt);
1031  if (meHFHadronEtFraction && meHFHadronEtFraction ->getRootObject()) meHFHadronEtFraction ->Fill(pfHFHadronEtFraction);
1032  if (meHFHadronEt && meHFHadronEt ->getRootObject()) meHFHadronEt ->Fill(pfHFHadronEt);
1033  if (meHFEMEtFraction && meHFEMEtFraction ->getRootObject()) meHFEMEtFraction ->Fill(pfHFEMEtFraction);
1034  if (meHFEMEt && meHFEMEt ->getRootObject()) meHFEMEt ->Fill(pfHFEMEt);
1035 
1036 
1037  if (_allhist) {
1038  if (bLumiSecPlot) {
1039 
1040  mePfMExLS = _dbe->get(DirName + "/METTask_PfMExLS");
1041  mePfMEyLS = _dbe->get(DirName + "/METTask_PfMEyLS");
1042 
1043  if (mePfMExLS && mePfMExLS->getRootObject()) mePfMExLS->Fill(pfMEx, iEvent.luminosityBlock());
1044  if (mePfMEyLS && mePfMEyLS->getRootObject()) mePfMEyLS->Fill(pfMEy, iEvent.luminosityBlock());
1045  }
1046  }
1047 
1048 
1049  // Fill NPV profiles
1050  //--------------------------------------------------------------------------
1051  mePfMEx_profile = _dbe->get(DirName + "/METTask_PfMEx_profile");
1052  mePfMEy_profile = _dbe->get(DirName + "/METTask_PfMEy_profile");
1053  mePfMET_profile = _dbe->get(DirName + "/METTask_PfMET_profile");
1054  mePfSumET_profile = _dbe->get(DirName + "/METTask_PfSumET_profile");
1055 
1056  if (mePfMEx_profile && mePfMEx_profile ->getRootObject()) mePfMEx_profile ->Fill(_numPV, pfMEx);
1057  if (mePfMEy_profile && mePfMEy_profile ->getRootObject()) mePfMEy_profile ->Fill(_numPV, pfMEy);
1058  if (mePfMET_profile && mePfMET_profile ->getRootObject()) mePfMET_profile ->Fill(_numPV, pfMET);
1059  if (mePfSumET_profile && mePfSumET_profile->getRootObject()) mePfSumET_profile->Fill(_numPV, pfSumET);
1060 
1061 
1062  mePhotonEtFraction_profile = _dbe->get(DirName + "/METTask_PfPhotonEtFraction_profile");
1063  mePhotonEt_profile = _dbe->get(DirName + "/METTask_PfPhotonEt_profile");
1064  meNeutralHadronEtFraction_profile = _dbe->get(DirName + "/METTask_PfNeutralHadronEtFraction_profile");
1065  meNeutralHadronEt_profile = _dbe->get(DirName + "/METTask_PfNeutralHadronEt_profile");
1066  meElectronEtFraction_profile = _dbe->get(DirName + "/METTask_PfElectronEtFraction_profile");
1067  meElectronEt_profile = _dbe->get(DirName + "/METTask_PfElectronEt_profile");
1068  meChargedHadronEtFraction_profile = _dbe->get(DirName + "/METTask_PfChargedHadronEtFraction_profile");
1069  meChargedHadronEt_profile = _dbe->get(DirName + "/METTask_PfChargedHadronEt_profile");
1070  meMuonEtFraction_profile = _dbe->get(DirName + "/METTask_PfMuonEtFraction_profile");
1071  meMuonEt_profile = _dbe->get(DirName + "/METTask_PfMuonEt_profile");
1072  meHFHadronEtFraction_profile = _dbe->get(DirName + "/METTask_PfHFHadronEtFraction_profile");
1073  meHFHadronEt_profile = _dbe->get(DirName + "/METTask_PfHFHadronEt_profile");
1074  meHFEMEtFraction_profile = _dbe->get(DirName + "/METTask_PfHFEMEtFraction_profile");
1075  meHFEMEt_profile = _dbe->get(DirName + "/METTask_PfHFEMEt_profile");
1076 
1077  if (mePhotonEtFraction_profile && mePhotonEtFraction_profile ->getRootObject()) mePhotonEtFraction_profile ->Fill(_numPV, pfPhotonEtFraction);
1078  if (mePhotonEt_profile && mePhotonEt_profile ->getRootObject()) mePhotonEt_profile ->Fill(_numPV, pfPhotonEt);
1079  if (meNeutralHadronEtFraction_profile && meNeutralHadronEtFraction_profile->getRootObject()) meNeutralHadronEtFraction_profile->Fill(_numPV, pfNeutralHadronEtFraction);
1080  if (meNeutralHadronEt_profile && meNeutralHadronEt_profile ->getRootObject()) meNeutralHadronEt_profile ->Fill(_numPV, pfNeutralHadronEt);
1081  if (meElectronEtFraction_profile && meElectronEtFraction_profile ->getRootObject()) meElectronEtFraction_profile ->Fill(_numPV, pfElectronEtFraction);
1082  if (meElectronEt_profile && meElectronEt_profile ->getRootObject()) meElectronEt_profile ->Fill(_numPV, pfElectronEt);
1083  if (meChargedHadronEtFraction_profile && meChargedHadronEtFraction_profile->getRootObject()) meChargedHadronEtFraction_profile->Fill(_numPV, pfChargedHadronEtFraction);
1084  if (meChargedHadronEt_profile && meChargedHadronEt_profile ->getRootObject()) meChargedHadronEt_profile ->Fill(_numPV, pfChargedHadronEt);
1085  if (meMuonEtFraction_profile && meMuonEtFraction_profile ->getRootObject()) meMuonEtFraction_profile ->Fill(_numPV, pfMuonEtFraction);
1086  if (meMuonEt_profile && meMuonEt_profile ->getRootObject()) meMuonEt_profile ->Fill(_numPV, pfMuonEt);
1087  if (meHFHadronEtFraction_profile && meHFHadronEtFraction_profile ->getRootObject()) meHFHadronEtFraction_profile ->Fill(_numPV, pfHFHadronEtFraction);
1088  if (meHFHadronEt_profile && meHFHadronEt_profile ->getRootObject()) meHFHadronEt_profile ->Fill(_numPV, pfHFHadronEt);
1089  if (meHFEMEtFraction_profile && meHFEMEtFraction_profile ->getRootObject()) meHFEMEtFraction_profile ->Fill(_numPV, pfHFEMEtFraction);
1090  if (meHFEMEt_profile && meHFEMEt_profile ->getRootObject()) meHFEMEt_profile ->Fill(_numPV, pfHFEMEt);
1091  }
1092 }
1093 
1094 
1095 //------------------------------------------------------------------------------
1096 // selectHighPtJetEvent
1097 //------------------------------------------------------------------------------
1098 bool PFMETAnalyzer::selectHighPtJetEvent(const edm::Event& iEvent){
1099 
1100  bool return_value=false;
1101 
1102  edm::Handle<reco::PFJetCollection> pfJets;
1103  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
1104  if (!pfJets.isValid()) {
1105  LogDebug("") << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
1106  if (_verbose) std::cout << "PFMETAnalyzer: Could not find pfjet product" << std::endl;
1107  }
1108 
1109  for (reco::PFJetCollection::const_iterator pf = pfJets->begin();
1110  pf!=pfJets->end(); ++pf){
1111  if (pf->pt()>_highPtPFJetThreshold){
1112  return_value=true;
1113  }
1114  }
1115 
1116  return return_value;
1117 }
1118 
1119 // // ***********************************************************
1120 bool PFMETAnalyzer::selectLowPtJetEvent(const edm::Event& iEvent){
1121 
1122  bool return_value=false;
1123 
1124  edm::Handle<reco::PFJetCollection> pfJets;
1125  iEvent.getByLabel(thePfJetCollectionLabel, pfJets);
1126  if (!pfJets.isValid()) {
1127  LogDebug("") << "PFMETAnalyzer: Could not find jet product" << std::endl;
1128  if (_verbose) std::cout << "PFMETAnalyzer: Could not find jet product" << std::endl;
1129  }
1130 
1131  for (reco::PFJetCollection::const_iterator cal = pfJets->begin();
1132  cal!=pfJets->end(); ++cal){
1133  if (cal->pt()>_lowPtPFJetThreshold){
1134  return_value=true;
1135  }
1136  }
1137 
1138  return return_value;
1139 
1140 }
1141 
1142 // ***********************************************************
1143 bool PFMETAnalyzer::selectWElectronEvent(const edm::Event& iEvent){
1144 
1145  bool return_value=true;
1146 
1147  /*
1148  W-electron event selection comes here
1149  */
1150 
1151  return return_value;
1152 
1153 }
1154 
1155 // ***********************************************************
1156 bool PFMETAnalyzer::selectWMuonEvent(const edm::Event& iEvent){
1157 
1158  bool return_value=true;
1159 
1160  /*
1161  W-muon event selection comes here
1162  */
1163 
1164  return return_value;
1165 
1166 }
1167 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
reco::BeamHaloSummary::EcalTightHaloId
const bool EcalTightHaloId() const
Definition: BeamHaloSummary.h:38
reco::LeafCandidate::energy
virtual double energy() const GCC11_FINAL
energy
Definition: LeafCandidate.h:134
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::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:204
reco::PFMET::HFEMEtFraction
double HFEMEtFraction() const
Definition: PFMET.h:47
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
PFMETAnalyzer::~PFMETAnalyzer
virtual ~PFMETAnalyzer()
Destructor.
Definition: PFMETAnalyzer.cc:67
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:44
PFMETAnalyzer::validateMET
void validateMET(const reco::PFMET &, edm::Handle< edm::View< reco::PFCandidate > >)
Definition: PFMETAnalyzer.cc:855
reco::PFMET::neutralHadronEtFraction
double neutralHadronEtFraction() const
Definition: PFMET.h:32
PFMETAnalyzer::PFMETAnalyzer
PFMETAnalyzer(const edm::ParameterSet &, edm::ConsumesCollector &&)
Constructor.
Definition: PFMETAnalyzer.cc:35
funct::sin
Sin< T >::type sin(const T &t)
Definition: Sin.h:22
edm::HLTGlobalStatus::accept
bool accept() const
Has at least one path accepted the event?
Definition: HLTGlobalStatus.h:52
reco::PFMET::muonEt
double muonEt() const
Definition: PFMET.h:42
PFMETAnalyzer::selectWMuonEvent
bool selectWMuonEvent(const edm::Event &)
Definition: PFMETAnalyzer.cc:1156
theta
Geom::Theta< T > theta() const
Definition: Basic3DVectorLD.h:172
PFMETAnalyzer::fillMESet
void fillMESet(const edm::Event &, std::string, const reco::PFMET &)
Definition: PFMETAnalyzer.cc:903
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
reco::VertexCollection
std::vector< Vertex > VertexCollection
collection of Vertex objects
Definition: VertexFwd.h:9
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::LeafCandidate::theta
virtual double theta() const GCC11_FINAL
momentum polar angle
Definition: LeafCandidate.h:157
reco::BeamHaloSummary::GlobalTightHaloId
const bool GlobalTightHaloId() const
Definition: BeamHaloSummary.h:44
PFMETAnalyzer::endJob
void endJob()
Finish up a job.
Definition: PFMETAnalyzer.cc:189
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:105
pfMET_cfi.pfMET
tuple pfMET
Definition: pfMET_cfi.py:7
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
nbinsPV
const int nbinsPV
Definition: GlobalVariables.h:5
PFMETAnalyzer::fillMonitorElement
void fillMonitorElement(const edm::Event &, std::string, std::string, const reco::PFMET &, bool)
Definition: PFMETAnalyzer.cc:932
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
reco::BeamHaloSummary::HcalLooseHaloId
const bool HcalLooseHaloId() const
Definition: BeamHaloSummary.h:34
reco::tau::pfCandidates
std::vector< PFCandidatePtr > pfCandidates(const PFJet &jet, int particleId, bool sort=true)
Definition: RecoTauCommonUtilities.cc:34
reco::BeamHaloSummary::CSCTightHaloId
const bool CSCTightHaloId() const
Definition: BeamHaloSummary.h:41
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
bTagSequences_cff.jetID
tuple jetID
Definition: bTagSequences_cff.py:4
PVup
const double PVup
Definition: GlobalVariables.h:7
reco::LeafCandidate::phi
virtual float phi() const GCC11_FINAL
momentum azimuthal angle
Definition: LeafCandidate.h:155
reco::MET::mEtSig
double mEtSig() const
Definition: MET.h:50
reco::PFMET::HFHadronEtFraction
double HFHadronEtFraction() const
Definition: PFMET.h:44
iEvent
int iEvent
Definition: GenABIO.cc:243
reco::MET::sumEt
double sumEt() const
Definition: MET.h:48
reco::PFMET::muonEtFraction
double muonEtFraction() const
Definition: PFMET.h:41
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
PFMETAnalyzer::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Initialize run-based parameters.
Definition: PFMETAnalyzer.cc:340
PFMETAnalyzer::analyze
void analyze(const edm::Event &, const edm::EventSetup &, const edm::TriggerResults &)
Get the analysis.
Definition: PFMETAnalyzer.cc:456
reco::PFMET::HFHadronEt
double HFHadronEt() const
Definition: PFMET.h:45
TrackerOfflineValidation_Dqm_cff.dirName
tuple dirName
Definition: TrackerOfflineValidation_Dqm_cff.py:56
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
edm::HLTGlobalStatus::size
unsigned int size() const
Get number of paths stored.
Definition: HLTGlobalStatus.h:39
PFMETAnalyzer::makeRatePlot
void makeRatePlot(std::string, double)
Definition: PFMETAnalyzer.cc:426
reco::PFMET::photonEtFraction
double photonEtFraction() const
Definition: PFMET.h:29
funct::cos
Cos< T >::type cos(const T &t)
Definition: Cos.h:22
reco::LeafCandidate::px
virtual double px() const GCC11_FINAL
x coordinate of momentum vector
Definition: LeafCandidate.h:147
PFMETAnalyzer::bookMESet
void bookMESet(std::string)
Definition: PFMETAnalyzer.cc:197
PFMETAnalyzer::selectLowPtJetEvent
bool selectLowPtJetEvent(const edm::Event &)
Definition: PFMETAnalyzer.cc:1120
TechnicalTriggerWord
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
Definition: L1GlobalTriggerReadoutSetupFwd.h:41
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
reco::PFMET::HFEMEt
double HFEMEt() const
Definition: PFMET.h:48
PFMETAnalyzer::bookMonitorElement
void bookMonitorElement(std::string, bool)
Definition: PFMETAnalyzer.cc:243
PVlow
const double PVlow
Definition: GlobalVariables.h:6
PFMETAnalyzer::beginJob
void beginJob(DQMStore *dbe)
Inizialize parameters for histo binning.
Definition: PFMETAnalyzer.cc:79
reco::PFMET::electronEt
double electronEt() const
Definition: PFMET.h:36
MonitorElement::getRootObject
TObject * getRootObject(void) const
Definition: MonitorElement.cc:1484
PFMETAnalyzer::selectHighPtJetEvent
bool selectHighPtJetEvent(const edm::Event &)
Definition: PFMETAnalyzer.cc:1098
reco::PFMET::photonEt
double photonEt() const
Definition: PFMET.h:30
edm::TriggerNames::triggerName
std::string const & triggerName(unsigned int index) const
Definition: TriggerNames.cc:27
edm::triggerResults
static std::string const triggerResults("TriggerResults")
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
PFMETAnalyzer::endRun
void endRun(const edm::Run &iRun, const edm::EventSetup &iSetup, DQMStore *dbe)
Finish up a run.
Definition: PFMETAnalyzer.cc:373
edm::Handle::product
T const * product() const
Definition: Handle.h:81
PFMETAnalyzer::selectWElectronEvent
bool selectWElectronEvent(const edm::Event &)
Definition: PFMETAnalyzer.cc:1143
reco::PFMET::electronEtFraction
double electronEtFraction() const
Definition: PFMET.h:35
reco::BeamHaloSummary::CSCLooseHaloId
const bool CSCLooseHaloId() const
Definition: BeamHaloSummary.h:40
reco::PFMET::chargedHadronEtFraction
double chargedHadronEtFraction() const
Definition: PFMET.h:38
reco::PFCandidate
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:38
FamosSequences_cff.caloJets
tuple caloJets
Definition: FamosSequences_cff.py:69
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
reco::PFMET::neutralHadronEt
double neutralHadronEt() const
Definition: PFMET.h:33
reco::LeafCandidate::pt
virtual float pt() const GCC11_FINAL
transverse momentum
Definition: LeafCandidate.h:153
pfJets_cff.pfJets
tuple pfJets
Definition: pfJets_cff.py:8
reco::BeamHaloSummary::EcalLooseHaloId
const bool EcalLooseHaloId() const
Definition: BeamHaloSummary.h:37
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
reco::PFMET::chargedHadronEt
double chargedHadronEt() const
Definition: PFMET.h:39
edm::Run
Definition: Run.h:41
phi
Definition: DDAxes.h:10
PFMETCollection
Collection of PF MET.
Generated for CMSSW Reference Manual by doxygen 1.8.5