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