CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
JetMETAnalyzer.cc
Go to the documentation of this file.
1 /*
2  * See header file for a description of this class.
3  *
4  * $Date: 2010/12/04 00:52:21 $
5  * $Revision: 1.69 $
6  * \author F. Chlebana - Fermilab
7  * K. Hatakeyama - Rockefeller University
8  */
9 
10 #include "DQMOffline/JetMET/interface/JetMETAnalyzer.h"
11 
12 #include "FWCore/Framework/interface/Event.h"
13 #include "FWCore/Framework/interface/EventSetup.h"
14 #include "FWCore/Common/interface/TriggerNames.h"
15 
16 #include "DataFormats/METReco/interface/CaloMETFwd.h"
17 #include "DataFormats/METReco/interface/METFwd.h"
18 #include "DataFormats/METReco/interface/PFMETFwd.h"
19 #include "DataFormats/JetReco/interface/CaloJetCollection.h"
20 #include "DataFormats/JetReco/interface/CaloJet.h"
21 #include "DataFormats/JetReco/interface/JPTJetCollection.h"
22 #include "DataFormats/JetReco/interface/PFJetCollection.h"
23 #include "DataFormats/JetReco/interface/PFJet.h"
24 
25 #include "DataFormats/Common/interface/Handle.h"
26 #include "FWCore/MessageLogger/interface/MessageLogger.h"
27 
28 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
29 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
30 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
31 
32 #include <string>
33 using namespace edm;
34 
35 #define DEBUG 0
36 
37 // ***********************************************************
38 JetMETAnalyzer::JetMETAnalyzer(const edm::ParameterSet& pSet) {
39 
40  parameters = pSet;
41 
42  // Jet Collection Label
43  theAKJetCollectionLabel = parameters.getParameter<edm::InputTag>("AKJetsCollectionLabel");
44  theSCJetCollectionLabel = parameters.getParameter<edm::InputTag>("SCJetsCollectionLabel");
45  theICJetCollectionLabel = parameters.getParameter<edm::InputTag>("ICJetsCollectionLabel");
46  theJPTJetCollectionLabel = parameters.getParameter<edm::InputTag>("JPTJetsCollectionLabel");
47  thePFJetCollectionLabel = parameters.getParameter<edm::InputTag>("PFJetsCollectionLabel");
48 
49  theTriggerResultsLabel = parameters.getParameter<edm::InputTag>("TriggerResultsLabel");
50 
51  theJetAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoJetAnalysis", true);
52  theJetCleaningFlag = parameters.getUntrackedParameter<bool>("DoJetCleaning", true);
53  theIConeJetAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoIterativeCone", false);
54  theSConeJetAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoSisCone", false);
55  theJetPtAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoJetPtAnalysis", false);
56  theJetPtCleaningFlag = parameters.getUntrackedParameter<bool>("DoJetPtCleaning", false);
57  theJPTJetAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoJPTJetAnalysis", false);
58  theJPTJetCleaningFlag = parameters.getUntrackedParameter<bool>("DoJPTJetCleaning", true);
59  thePFJetAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoPFJetAnalysis", false);
60  thePFJetCleaningFlag = parameters.getUntrackedParameter<bool>("DoPFJetCleaning", true);
61  //
62  theDiJetSelectionFlag = parameters.getUntrackedParameter<bool>("DoDiJetSelection", true);
63  //
64  theCaloMETAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoCaloMETAnalysis",true);
65  theTcMETAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoTcMETAnalysis", true);
66  theMuCorrMETAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoMuCorrMETAnalysis", true);
67  thePfMETAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoPfMETAnalysis", true);
68  theHTMHTAnalyzerFlag = parameters.getUntrackedParameter<bool>("DoHTMHTAnalysis", true);
69 
70  // ==========================================================
71  //DCS information
72  // ==========================================================
73  DCSFilterCalo = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilterCalo"));
74  DCSFilterPF = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilterPF"));
75  DCSFilterJPT = new JetMETDQMDCSFilter(parameters.getParameter<ParameterSet>("DCSFilterJPT"));
76  // Used for Jet DQM - For MET DQM, DCS selection applied in ***METAnalyzer
77 
78  // --- do the analysis on the Jets
79  if(theJetAnalyzerFlag) {
80  theAKJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("jetAnalysis"));
81  theAKJetAnalyzer->setSource("AntiKtJets");
82  if(theSConeJetAnalyzerFlag) {
83  theSCJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("jetAnalysis"));
84  theSCJetAnalyzer->setSource("SISConeJets");
85  }
86  if(theIConeJetAnalyzerFlag){
87  theICJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("jetAnalysis"));
88  theICJetAnalyzer->setSource("IterativeConeJets");
89  }
90  }
91 
92  if(theJetCleaningFlag) {
93  theCleanedAKJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("CleanedjetAnalysis"));
94  theCleanedAKJetAnalyzer->setSource("CleanedAntiKtJets");
95  if(theSConeJetAnalyzerFlag){
96  theCleanedSCJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("CleanedjetAnalysis"));
97  theCleanedSCJetAnalyzer->setSource("CleanedSISConeJets");
98  }
99  if(theIConeJetAnalyzerFlag){
100  theCleanedICJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("CleanedjetAnalysis"));
101  theCleanedICJetAnalyzer->setSource("CleanedIterativeConeJets");
102  }
103  }
104 
105  if(theDiJetSelectionFlag){
106  theDiJetAnalyzer = new JetAnalyzer(parameters.getParameter<ParameterSet>("DijetAnalysis"));
107  theDiJetAnalyzer->setSource("DiJets");
108  }
109 
110  // Do Pt analysis
111  if(theJetPtAnalyzerFlag ) {
112  thePtAKJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("PtAnalysis"));
113  thePtAKJetAnalyzer->setSource("PtAnalysisAntiKtJets");
114  if(theSConeJetAnalyzerFlag){
115  thePtSCJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("PtAnalysis"));
116  thePtSCJetAnalyzer->setSource("PtAnalysisSISConeJets");
117  }
118  if(theIConeJetAnalyzerFlag){
119  thePtICJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("PtAnalysis"));
120  thePtICJetAnalyzer->setSource("PtAnalysisIterativeConeJets");
121  }
122  }
123  // Do Cleaned Pt analysis
124  if(theJetPtCleaningFlag ) {
125  theCleanedPtAKJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("CleanedPtAnalysis"));
126  theCleanedPtAKJetAnalyzer->setSource("PtAnalysisCleanedAntiKtJets");
127  if(theSConeJetAnalyzerFlag){
128  theCleanedPtSCJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("CleanedPtAnalysis"));
129  theCleanedPtSCJetAnalyzer->setSource("PtAnalysisCleanedSISConeJets");
130  }
131  if(theIConeJetAnalyzerFlag){
132  theCleanedPtICJetAnalyzer = new JetPtAnalyzer(parameters.getParameter<ParameterSet>("CleanedPtAnalysis"));
133  theCleanedPtICJetAnalyzer->setSource("PtAnalysisCleanedIterativeConeJets");
134  }
135  }
136 
137  // --- do the analysis on JPT Jets
138  if(theJPTJetAnalyzerFlag) {
139  theJPTJetAnalyzer = new JPTJetAnalyzer(parameters.getParameter<ParameterSet>("JPTJetAnalysis"));
140  }
141  // --- do the analysis on JPT Cleaned Jets
142  if(theJPTJetCleaningFlag) {
143  theCleanedJPTJetAnalyzer = new JPTJetAnalyzer(parameters.getParameter<ParameterSet>("CleanedJPTJetAnalysis"));
144  }
145 
146  // --- do the analysis on the PFJets
147  if(thePFJetAnalyzerFlag){
148  thePFJetAnalyzer = new PFJetAnalyzer(parameters.getParameter<ParameterSet>("pfJetAnalysis"));
149  thePFJetAnalyzer->setSource("uncPFJets");
150  }
151  // --- do the analysis on the CleanedPFJets
152  if(thePFJetCleaningFlag) {
153  theCleanedPFJetAnalyzer = new PFJetAnalyzer(parameters.getParameter<ParameterSet>("CleanedpfJetAnalysis"));
154  theCleanedPFJetAnalyzer->setSource("PFJets");
155  }
156  //Trigger selectoin
157  edm::ParameterSet highptjetparms = parameters.getParameter<edm::ParameterSet>("highPtJetTrigger");
158  edm::ParameterSet lowptjetparms = parameters.getParameter<edm::ParameterSet>("lowPtJetTrigger" );
159 
160  LoJetTrigger = highptjetparms.getParameter<std::string>("hltDBKey");
161  HiJetTrigger = lowptjetparms .getParameter<std::string>("hltDBKey");
162 
163  _HighPtJetEventFlag = new GenericTriggerEventFlag( highptjetparms );
164  _LowPtJetEventFlag = new GenericTriggerEventFlag( lowptjetparms );
165 
166 
167  // --- do the analysis on the MET
168  if(theCaloMETAnalyzerFlag){
169  theCaloMETAnalyzer = new CaloMETAnalyzer(parameters.getParameter<ParameterSet>("caloMETAnalysis"));
170  theCaloMETNoHFAnalyzer = new CaloMETAnalyzer(parameters.getParameter<ParameterSet>("caloMETNoHFAnalysis"));
171  theCaloMETHOAnalyzer = new CaloMETAnalyzer(parameters.getParameter<ParameterSet>("caloMETHOAnalysis"));
172  theCaloMETNoHFHOAnalyzer = new CaloMETAnalyzer(parameters.getParameter<ParameterSet>("caloMETNoHFHOAnalysis"));
173  }
174  if(theTcMETAnalyzerFlag){
175  theTcMETAnalyzer = new METAnalyzer(parameters.getParameter<ParameterSet>("tcMETAnalysis"));
176  }
177  if(theMuCorrMETAnalyzerFlag){
178  theMuCorrMETAnalyzer = new CaloMETAnalyzer(parameters.getParameter<ParameterSet>("mucorrMETAnalysis"));
179  }
180  if(thePfMETAnalyzerFlag){
181  thePfMETAnalyzer = new PFMETAnalyzer(parameters.getParameter<ParameterSet>("pfMETAnalysis"));
182  }
183  if(theHTMHTAnalyzerFlag){
184  theHTMHTAnalyzer = new HTMHTAnalyzer(parameters.getParameter<ParameterSet>("HTMHTAnalysis"));
185  }
186 
187  _LSBegin = parameters.getParameter<int>("LSBegin");
188  _LSEnd = parameters.getParameter<int>("LSEnd");
189 
190  processname_ = parameters.getParameter<std::string>("processname");
191 
192  //jet cleanup parameters
193  theCleaningParameters = parameters.getParameter<ParameterSet>("CleaningParameters"),
194 
195  _hlt_PhysDec = theCleaningParameters.getParameter<std::string>("HLT_PhysDec");
196 
197  _techTrigsAND = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsAND");
198  _techTrigsOR = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsOR");
199  _techTrigsNOT = theCleaningParameters.getParameter<std::vector<unsigned > >("techTrigsNOT");
200 
201  _doPVCheck = theCleaningParameters.getParameter<bool>("doPrimaryVertexCheck");
202  _doHLTPhysicsOn = theCleaningParameters.getParameter<bool>("doHLTPhysicsOn");
203 
204  _tightBHFiltering = theCleaningParameters.getParameter<bool>("tightBHFiltering");
205  _tightHcalFiltering = theCleaningParameters.getParameter<bool>("tightHcalFiltering");
206 
207  _theVertexLabel = theCleaningParameters.getParameter<edm::InputTag>("vertexLabel");
208  _theGTLabel = theCleaningParameters.getParameter<edm::InputTag>("gtLabel");
209 
210  //Vertex requirements
211  if (_doPVCheck) {
212  _nvtx_min = theCleaningParameters.getParameter<int>("nvtx_min");
213  _nvtxtrks_min = theCleaningParameters.getParameter<int>("nvtxtrks_min");
214  _vtxndof_min = theCleaningParameters.getParameter<int>("vtxndof_min");
215  _vtxchi2_max = theCleaningParameters.getParameter<double>("vtxchi2_max");
216  _vtxz_max = theCleaningParameters.getParameter<double>("vtxz_max");
217  }
218 
219 }
220 
221 // ***********************************************************
222 JetMETAnalyzer::~JetMETAnalyzer() {
223 
224  if(theJetAnalyzerFlag) {
225  delete theAKJetAnalyzer;
226  if(theSConeJetAnalyzerFlag) delete theSCJetAnalyzer;
227  if(theIConeJetAnalyzerFlag) delete theICJetAnalyzer;
228  }
229  if(theJetCleaningFlag) {
230  delete theCleanedAKJetAnalyzer;
231  if(theSConeJetAnalyzerFlag) delete theCleanedSCJetAnalyzer;
232  if(theIConeJetAnalyzerFlag) delete theCleanedICJetAnalyzer;
233  }
234  if(theDiJetSelectionFlag) {
235  delete theDiJetAnalyzer;
236  }
237  if(theJetPtAnalyzerFlag) {
238  delete thePtAKJetAnalyzer;
239  if(theSConeJetAnalyzerFlag) delete thePtSCJetAnalyzer;
240  if(theIConeJetAnalyzerFlag) delete thePtICJetAnalyzer;
241  }
242 
243  if(theJetPtCleaningFlag) {
244  delete theCleanedPtAKJetAnalyzer;
245  if(theSConeJetAnalyzerFlag) delete theCleanedPtSCJetAnalyzer;
246  if(theIConeJetAnalyzerFlag) delete theCleanedPtICJetAnalyzer;
247  }
248 
249  if(theJPTJetAnalyzerFlag) delete theJPTJetAnalyzer;
250  if(theJPTJetCleaningFlag) delete theCleanedJPTJetAnalyzer;
251 
252  if(thePFJetAnalyzerFlag) delete thePFJetAnalyzer;
253  if(thePFJetCleaningFlag) delete theCleanedPFJetAnalyzer;
254 
255  delete _HighPtJetEventFlag;
256  delete _LowPtJetEventFlag;
257 
258  if(theCaloMETAnalyzerFlag){
259  delete theCaloMETAnalyzer;
260  delete theCaloMETNoHFAnalyzer;
261  delete theCaloMETHOAnalyzer;
262  delete theCaloMETNoHFHOAnalyzer;
263  }
264  if(theTcMETAnalyzerFlag) delete theTcMETAnalyzer;
265  if(theMuCorrMETAnalyzerFlag) delete theMuCorrMETAnalyzer;
266  if(thePfMETAnalyzerFlag) delete thePfMETAnalyzer;
267  if(theHTMHTAnalyzerFlag) delete theHTMHTAnalyzer;
268 
269  delete DCSFilterCalo;
270  delete DCSFilterPF;
271  delete DCSFilterJPT;
272 
273 }
274 
275 // ***********************************************************
276 void JetMETAnalyzer::beginJob(void) {
277 
278  metname = "JetMETAnalyzer";
279 
280  LogTrace(metname)<<"[JetMETAnalyzer] Parameters initialization";
281  dbe = edm::Service<DQMStore>().operator->();
282 
283  //
284  //--- Jet
285  if(theJetAnalyzerFlag) {
286  theAKJetAnalyzer->beginJob(dbe);
287  if(theSConeJetAnalyzerFlag) theSCJetAnalyzer->beginJob(dbe);
288  if(theIConeJetAnalyzerFlag) theICJetAnalyzer->beginJob(dbe);
289  }
290  if(theJetCleaningFlag) {
291  theCleanedAKJetAnalyzer->beginJob(dbe);
292  if(theSConeJetAnalyzerFlag) theCleanedSCJetAnalyzer->beginJob(dbe);
293  if(theIConeJetAnalyzerFlag) theCleanedICJetAnalyzer->beginJob(dbe);
294  }
295  if(theDiJetSelectionFlag) theDiJetAnalyzer->beginJob(dbe);
296  if(theJetPtAnalyzerFlag ) {
297  thePtAKJetAnalyzer->beginJob(dbe);
298  if(theSConeJetAnalyzerFlag) thePtSCJetAnalyzer->beginJob(dbe);
299  if(theIConeJetAnalyzerFlag) thePtICJetAnalyzer->beginJob(dbe);
300  }
301  if(theJetPtCleaningFlag ) {
302  theCleanedPtAKJetAnalyzer->beginJob(dbe);
303  if(theSConeJetAnalyzerFlag) theCleanedPtSCJetAnalyzer->beginJob(dbe);
304  if(theIConeJetAnalyzerFlag) theCleanedPtICJetAnalyzer->beginJob(dbe);
305  }
306 
307  if(theJPTJetAnalyzerFlag) theJPTJetAnalyzer->beginJob(dbe);
308  if(theJPTJetCleaningFlag) theCleanedJPTJetAnalyzer->beginJob(dbe);
309 
310  if(thePFJetAnalyzerFlag) thePFJetAnalyzer->beginJob(dbe);
311  if(thePFJetCleaningFlag) theCleanedPFJetAnalyzer->beginJob(dbe);
312 
313  //
314  //--- MET
315  if(theCaloMETAnalyzerFlag){
316  theCaloMETAnalyzer->beginJob(dbe);
317  theCaloMETNoHFAnalyzer->beginJob(dbe);
318  theCaloMETHOAnalyzer->beginJob(dbe);
319  theCaloMETNoHFHOAnalyzer->beginJob(dbe);
320  }
321  if(theTcMETAnalyzerFlag) theTcMETAnalyzer->beginJob(dbe);
322  if(theMuCorrMETAnalyzerFlag) theMuCorrMETAnalyzer->beginJob(dbe);
323  if(thePfMETAnalyzerFlag) thePfMETAnalyzer->beginJob(dbe);
324  if(theHTMHTAnalyzerFlag) theHTMHTAnalyzer->beginJob(dbe);
325 
326  dbe->setCurrentFolder("JetMET");
327  lumisecME = dbe->book1D("lumisec", "lumisec", 500, 0., 500.);
328 
329 }
330 
331 // ***********************************************************
332 void JetMETAnalyzer::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
333 {
334  //LogDebug("JetMETAnalyzer") << "beginRun, run " << run.id();
335  //
336 
337  if ( _HighPtJetEventFlag->on() ) _HighPtJetEventFlag->initRun( iRun, iSetup );
338  if ( _LowPtJetEventFlag ->on() ) _LowPtJetEventFlag ->initRun( iRun, iSetup );
339  //--- htlConfig_
340  //processname_="HLT";
341  bool changed(true);
342  _hlt_initialized = hltConfig_.init(iRun,iSetup,processname_,changed);
343  if (!_hlt_initialized) {
344  //if (!hltConfig_.init(iRun,iSetup,processname_,changed)) {
345  processname_ = "FU";
346  _hlt_initialized = hltConfig_.init(iRun,iSetup,processname_,changed);
347  if(!_hlt_initialized){
348  //if (!hltConfig_.init(iRun,iSetup,processname_,changed)){
349  LogDebug("JetMETAnalyzer") << "HLTConfigProvider failed to initialize.";
350  }
351  }
352 
353  hltpathME = 0;
354  if (_hlt_initialized) {
355  //if (hltConfig_.init(iRun,iSetup,processname_,changed)) {
356  if (hltConfig_.size()){
357  dbe->setCurrentFolder("JetMET");
358  hltpathME = dbe->book1D("hltpath", "hltpath", 300, 0., 300.);
359  }
360 
361  for (unsigned int j=0; j!=hltConfig_.size(); ++j) {
362  if (hltpathME) hltpathME->setBinLabel(j+1,hltConfig_.triggerName(j));
363  // if (hltConfig_.triggerName(j)=="HLT_PhysicsDeclared")
364  }
365  }
366  //
367  //--- Jet
368 
369  //
370  //--- MET
371  if(theCaloMETAnalyzerFlag){
372  theCaloMETAnalyzer->beginRun(iRun, iSetup);
373  theCaloMETNoHFAnalyzer->beginRun(iRun, iSetup);
374  theCaloMETHOAnalyzer->beginRun(iRun, iSetup);
375  theCaloMETNoHFHOAnalyzer->beginRun(iRun, iSetup);
376  }
377  if(theTcMETAnalyzerFlag) theTcMETAnalyzer->beginRun(iRun, iSetup);
378  if(theMuCorrMETAnalyzerFlag) theMuCorrMETAnalyzer->beginRun(iRun, iSetup);
379  if(thePfMETAnalyzerFlag) thePfMETAnalyzer->beginRun(iRun, iSetup);
380  //if(theHTMHTAnalyzerFlag) theHTMHTAnalyzer->beginRun(iRun, iSetup);
381 
382 }
383 
384 // ***********************************************************
385 void JetMETAnalyzer::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
386 {
387  //
388  //--- Jet
389 
390  //
391  //--- MET
392  if(theCaloMETAnalyzerFlag){
393  theCaloMETAnalyzer->endRun(iRun, iSetup, dbe);
394  theCaloMETNoHFAnalyzer->endRun(iRun, iSetup, dbe);
395  theCaloMETHOAnalyzer->endRun(iRun, iSetup, dbe);
396  theCaloMETNoHFHOAnalyzer->endRun(iRun, iSetup, dbe);
397  }
398  if(theTcMETAnalyzerFlag) theTcMETAnalyzer->endRun(iRun, iSetup, dbe);
399  if(theMuCorrMETAnalyzerFlag) theMuCorrMETAnalyzer->endRun(iRun, iSetup, dbe);
400  if(thePfMETAnalyzerFlag) thePfMETAnalyzer->endRun(iRun, iSetup, dbe);
401  //if(theHTMHTAnalyzerFlag) theHTMHTAnalyzer->endRun(iRun, iSetup, dbe);
402 
403 }
404 
405 // ***********************************************************
406 void JetMETAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
407 
408  LogTrace(metname)<<"[JetMETAnalyzer] Analysis of event # ";
409 
410  // *** Fill lumisection ME
411  int myLuminosityBlock;
412  myLuminosityBlock = iEvent.luminosityBlock();
413  lumisecME->Fill(myLuminosityBlock);
414 
415  if (myLuminosityBlock<_LSBegin) return;
416  if (myLuminosityBlock>_LSEnd && _LSEnd>0) return;
417 
418  // **** Get the TriggerResults container
419  edm::Handle<TriggerResults> triggerResults;
420  iEvent.getByLabel(theTriggerResultsLabel, triggerResults);
421 
422  bool bPhysicsDeclared = false;
423  if(!_doHLTPhysicsOn) bPhysicsDeclared = true;
424 
425  if (triggerResults.isValid()){
426  const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
427 
428  if( triggerNames.triggerIndex("HLT_PhysicsDeclared") != triggerNames.size() )
429  if (triggerResults->accept(triggerNames.triggerIndex("HLT_PhysicsDeclared"))) {
430  if(_doHLTPhysicsOn) bPhysicsDeclared = true;
431  }
432 
433  //sanity check
434  if (_hlt_initialized && hltConfig_.size() && triggerResults->size()==hltConfig_.size()){
435  //check the trigger results
436  for (unsigned int j=0; j!=hltConfig_.size(); ++j) {
437  if (triggerResults->accept(j)){
438  if (hltpathME) hltpathME->Fill(j);
439  }
440  }
441  }
442  }
443 
444  if (DEBUG) std::cout << "trigger label " << theTriggerResultsLabel << std::endl;
445 
446  Int_t JetLoPass = 0;
447  Int_t JetHiPass = 0;
448 
449  if ( _HighPtJetEventFlag->on() && _HighPtJetEventFlag->accept( iEvent, iSetup ) )
450  JetHiPass=1;
451 
452  if ( _LowPtJetEventFlag->on() && _LowPtJetEventFlag->accept( iEvent, iSetup ) )
453  JetLoPass=1;
454 
455  //if (triggerResults.isValid()) {
456  //
457  // if (DEBUG) std::cout << "trigger valid " << std::endl;
458  // const edm::TriggerNames & triggerNames = iEvent.triggerNames(*triggerResults);
459  // unsigned int n = triggerResults->size();
460  // for (unsigned int i=0; i!=n; i++) {
461  //
462  // if ( triggerNames.triggerName(i) == LoJetTrigger ) {
463  // JetLoPass = triggerResults->accept(i);
464  // if (DEBUG) std::cout << "Found HLT_Jet30" << std::endl;
465  // }
466  // if ( triggerNames.triggerName(i) == HiJetTrigger ) {
467  // JetHiPass = triggerResults->accept(i);
468  // }
469  // }
470  //
471  //} else {
472  //
473  // //
474  // triggerResults = edm::Handle<TriggerResults>();
475  //
476  // if (DEBUG) std::cout << "trigger not valid " << std::endl;
477  // edm::LogInfo("JetMETAnalyzer") << "TriggerResults::HLT not found, "
478  // "automatically select events";
479  //
480  //}
481  if (DEBUG) {
482  std::cout << ">>> Trigger Lo = " << JetLoPass
483  << " Hi = " << JetHiPass
484  << std::endl;
485  }
486 
487  // ==========================================================
488  //Vertex information
489 
490  bool bPrimaryVertex = true;
491  if(_doPVCheck){
492  bPrimaryVertex = false;
493  Handle<reco::VertexCollection> vertexHandle;
494 
495  iEvent.getByLabel(_theVertexLabel, vertexHandle);
496 
497  if (!vertexHandle.isValid()) {
498  LogInfo("JetMETAnalyzer") << "JetMETAnalyzer: Could not find vertex collection" << std::endl;
499  if (DEBUG) std::cout << "JetMETAnalyzer: Could not find vertex collection" << std::endl;
500  }
501 
502  if ( vertexHandle.isValid() ){
503  reco::VertexCollection vertexCollection = *(vertexHandle.product());
504  int vertex_number = vertexCollection.size();
505  reco::VertexCollection::const_iterator v = vertexCollection.begin();
506  double vertex_chi2 = v->normalizedChi2();
507  double vertex_ndof = v->ndof();
508  bool fakeVtx = v->isFake();
509  double vertex_Z = v->z();
510 
511  if ( !fakeVtx
512  && vertex_number>=_nvtx_min
513  && vertex_ndof >_vtxndof_min
514  && vertex_chi2 <_vtxchi2_max
515  && fabs(vertex_Z)<_vtxz_max ) bPrimaryVertex = true;
516  }
517  }
518  // ==========================================================
519 
520  edm::Handle< L1GlobalTriggerReadoutRecord > gtReadoutRecord;
521  iEvent.getByLabel( _theGTLabel, gtReadoutRecord);
522 
523  if (!gtReadoutRecord.isValid()) {
524  LogInfo("JetMETAnalyzer") << "JetMETAnalyzer: Could not find GT readout record" << std::endl;
525  if (DEBUG) std::cout << "JetMETAnalyzer: Could not find GT readout record product" << std::endl;
526  }
527 
528  bool bTechTriggers = true;
529  bool bTechTriggersAND = true;
530  bool bTechTriggersOR = false;
531  bool bTechTriggersNOT = false;
532 
533  if (gtReadoutRecord.isValid()) {
534  const TechnicalTriggerWord& technicalTriggerWordBeforeMask = gtReadoutRecord->technicalTriggerWord();
535 
536  if (_techTrigsAND.size() == 0)
537  bTechTriggersAND = true;
538  else
539  for (unsigned ttr = 0; ttr != _techTrigsAND.size(); ttr++) {
540  bTechTriggersAND = bTechTriggersAND && technicalTriggerWordBeforeMask.at(_techTrigsAND.at(ttr));
541  }
542 
543  if (_techTrigsAND.size() == 0)
544  bTechTriggersOR = true;
545  else
546  for (unsigned ttr = 0; ttr != _techTrigsOR.size(); ttr++) {
547  bTechTriggersOR = bTechTriggersOR || technicalTriggerWordBeforeMask.at(_techTrigsOR.at(ttr));
548  }
549  if (_techTrigsNOT.size() == 0)
550  bTechTriggersNOT = false;
551  else
552  for (unsigned ttr = 0; ttr != _techTrigsNOT.size(); ttr++) {
553  bTechTriggersNOT = bTechTriggersNOT || technicalTriggerWordBeforeMask.at(_techTrigsNOT.at(ttr));
554  }
555  }
556  else
557  {
558  bTechTriggersAND = true;
559  bTechTriggersOR = true;
560  bTechTriggersNOT = false;
561  }
562 
563  if (_techTrigsAND.size()==0)
564  bTechTriggersAND = true;
565  if (_techTrigsOR.size()==0)
566  bTechTriggersOR = true;
567  if (_techTrigsNOT.size()==0)
568  bTechTriggersNOT = false;
569 
570  bTechTriggers = bTechTriggersAND && bTechTriggersOR && !bTechTriggersNOT;
571 
572  bool bJetCleanup = bTechTriggers && bPrimaryVertex && bPhysicsDeclared;
573 
574 
575  // **** Get the Calo Jet container
576  edm::Handle<reco::CaloJetCollection> caloJets;
577 
578 
579  // **** Get the AntiKt Jet container
580  iEvent.getByLabel(theAKJetCollectionLabel, caloJets);
581  if(caloJets.isValid()) {
582 
583  if(theJetAnalyzerFlag){
584  theAKJetAnalyzer->setJetHiPass(JetHiPass);
585  theAKJetAnalyzer->setJetLoPass(JetLoPass);
586  theAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
587  }
588  if(theJetPtAnalyzerFlag){
589  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Jet Pt anti-Kt analyzer";
590  thePtAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
591  }
592 
593  }
594 
595  if(caloJets.isValid() && bJetCleanup) {
596  if(DCSFilterCalo->filter(iEvent, iSetup)){
597  if(theJetCleaningFlag){
598  theCleanedAKJetAnalyzer->setJetHiPass(JetHiPass);
599  theCleanedAKJetAnalyzer->setJetLoPass(JetLoPass);
600  theCleanedAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
601  }
602  if(theJetPtCleaningFlag){
603  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Cleaned Jet Pt anti-Kt analyzer";
604  theCleanedPtAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
605  }
606  } // DCS
607  } // caloJets.isValid()
608 
609  if(caloJets.isValid() && bJetCleanup){
610  if(DCSFilterCalo->filter(iEvent, iSetup)){
611  if(theDiJetSelectionFlag){
612  theDiJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
613  }
614  } // DCS
615  } // caloJets.isValid()
616 
617 
618  if(caloJets.isValid()){
619  if(theJetPtAnalyzerFlag){
620  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Jet Pt anti-Kt analyzer";
621  thePtAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
622  }
623  }
624 
625  if(caloJets.isValid() && bJetCleanup){
626  if(DCSFilterCalo->filter(iEvent, iSetup)){
627  if(theJetPtCleaningFlag){
628  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Cleaned Jet Pt anti-Kt analyzer";
629  theCleanedPtAKJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
630  }
631  } // DCS
632  } // caloJets.isValid()
633 
634  // **** Get the SISCone Jet container
635  iEvent.getByLabel(theSCJetCollectionLabel, caloJets);
636  if(theSConeJetAnalyzerFlag){
637  if(caloJets.isValid()){
638  if(theJetAnalyzerFlag){
639  theSCJetAnalyzer->setJetHiPass(JetHiPass);
640  theSCJetAnalyzer->setJetLoPass(JetLoPass);
641  theSCJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
642  }
643  if(theJetPtAnalyzerFlag){
644  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Jet Pt SisCone analyzer";
645  thePtSCJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
646  }
647  }
648 
649  if(caloJets.isValid() && bJetCleanup){
650  if(DCSFilterCalo->filter(iEvent, iSetup)){
651  if(theJetCleaningFlag){
652  theCleanedSCJetAnalyzer->setJetHiPass(JetHiPass);
653  theCleanedSCJetAnalyzer->setJetLoPass(JetLoPass);
654  theCleanedSCJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
655  }
656  if(theJetPtCleaningFlag){
657  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Cleaned Jet Pt SisCone analyzer";
658  theCleanedPtSCJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
659  }
660  } // DCS
661  } // caloJets.isValid()
662  }
663  // **** Get the Iterative Cone Jet container
664  iEvent.getByLabel(theICJetCollectionLabel, caloJets);
665  if(theIConeJetAnalyzerFlag) {
666  if(caloJets.isValid()){
667  if(theJetAnalyzerFlag){
668  theICJetAnalyzer->setJetHiPass(JetHiPass);
669  theICJetAnalyzer->setJetLoPass(JetLoPass);
670  theICJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
671  }
672  if(theJetPtAnalyzerFlag){
673  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Jet Pt ICone analyzer";
674  thePtICJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
675  }
676  }
677 
678  if(caloJets.isValid() && bJetCleanup){
679  if(DCSFilterCalo->filter(iEvent, iSetup)){
680  if(theJetCleaningFlag){
681  theCleanedICJetAnalyzer->setJetHiPass(JetHiPass);
682  theCleanedICJetAnalyzer->setJetLoPass(JetLoPass);
683  theCleanedICJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
684  }
685  if(theJetPtCleaningFlag){
686  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Cleaned Jet Pt ICone analyzer";
687  theCleanedPtICJetAnalyzer->analyze(iEvent, iSetup, *caloJets);
688  }
689  } // DCS
690  } // isValid
691  }
692 
693  // **** Get the JPT Jet container
694  edm::Handle<reco::JPTJetCollection> jptJets;
695  iEvent.getByLabel(theJPTJetCollectionLabel, jptJets);
696  if(jptJets.isValid() && theJPTJetAnalyzerFlag){
697  //theJPTJetAnalyzer->setJetHiPass(JetHiPass);
698  //theJPTJetAnalyzer->setJetLoPass(JetLoPass);
699  theJPTJetAnalyzer->analyze(iEvent, iSetup, *jptJets);
700  }
701 
702  if(jptJets.isValid() && bJetCleanup && theJPTJetCleaningFlag){
703  if(DCSFilterJPT->filter(iEvent, iSetup)){
704  //theCleanedJPTJetAnalyzer->setJetHiPass(JetHiPass);
705  //theCleanedJPTJetAnalyzer->setJetLoPass(JetLoPass);
706  theCleanedJPTJetAnalyzer->analyze(iEvent, iSetup, *jptJets);
707  }
708  }
709 
710  // **** Get the PFlow Jet container
711  edm::Handle<reco::PFJetCollection> pfJets;
712  iEvent.getByLabel(thePFJetCollectionLabel, pfJets);
713 
714  if(pfJets.isValid()){
715  if(thePFJetAnalyzerFlag){
716  thePFJetAnalyzer->setJetHiPass(JetHiPass);
717  thePFJetAnalyzer->setJetLoPass(JetLoPass);
718  LogTrace(metname)<<"[JetMETAnalyzer] Call to the PFJet analyzer";
719  thePFJetAnalyzer->analyze(iEvent, iSetup, *pfJets);
720  }
721  if(thePFJetCleaningFlag){
722  if(DCSFilterPF->filter(iEvent, iSetup)){
723  theCleanedPFJetAnalyzer->setJetHiPass(JetHiPass);
724  theCleanedPFJetAnalyzer->setJetLoPass(JetLoPass);
725  LogTrace(metname)<<"[JetMETAnalyzer] Call to the Cleaned PFJet analyzer";
726  theCleanedPFJetAnalyzer->analyze(iEvent, iSetup, *pfJets);
727  } // DCS
728  }
729  } else {
730  if (DEBUG) LogTrace(metname)<<"[JetMETAnalyzer] pfjets NOT VALID!!";
731  }
732 
733  //
734  // **** CaloMETAnalyzer **** //
735  //
736  if(theCaloMETAnalyzerFlag){
737 
738  theCaloMETAnalyzer->analyze(iEvent, iSetup, *triggerResults);
739  theCaloMETNoHFAnalyzer->analyze(iEvent, iSetup, *triggerResults);
740  theCaloMETHOAnalyzer->analyze(iEvent, iSetup, *triggerResults);
741  theCaloMETNoHFHOAnalyzer->analyze(iEvent, iSetup, *triggerResults);
742  }
743 
744  //
745  // **** TcMETAnalyzer **** //
746  //
747  if(theTcMETAnalyzerFlag){
748 
749  theTcMETAnalyzer->analyze(iEvent, iSetup, *triggerResults);
750 
751  }
752 
753  //
754  // **** MuCorrMETAnalyzer **** //
755  //
756  if(theMuCorrMETAnalyzerFlag){
757 
758  theMuCorrMETAnalyzer->analyze(iEvent, iSetup, *triggerResults);
759 
760  }
761 
762  //
763  // **** PfMETAnalyzer **** //
764  //
765  if(thePfMETAnalyzerFlag){
766 
767  thePfMETAnalyzer->analyze(iEvent, iSetup, *triggerResults);
768 
769  }
770 
771  //
772  // **** HTMHTAnalyzer **** //
773  //
774  if(theHTMHTAnalyzerFlag){
775 
776  theHTMHTAnalyzer->analyze(iEvent, iSetup, *triggerResults);
777 
778  }
779 
780 }
781 
782 // ***********************************************************
783 void JetMETAnalyzer::endJob(void) {
784  LogTrace(metname)<<"[JetMETAnalyzer] Saving the histos";
785  bool outputMEsInRootFile = parameters.getParameter<bool>("OutputMEsInRootFile");
786  std::string outputFileName = parameters.getParameter<std::string>("OutputFileName");
787 
788 
789  //--- MET
790  if(theCaloMETAnalyzerFlag){
791  theCaloMETAnalyzer->endJob();
792  theCaloMETNoHFAnalyzer->endJob();
793  theCaloMETHOAnalyzer->endJob();
794  theCaloMETNoHFHOAnalyzer->endJob();
795  }
796  if(theTcMETAnalyzerFlag) theTcMETAnalyzer->endJob();
797  if(theMuCorrMETAnalyzerFlag) theMuCorrMETAnalyzer->endJob();
798  if(thePfMETAnalyzerFlag) thePfMETAnalyzer->endJob();
799  //if(theHTMHTAnalyzerFlag) theHTMHTAnalyzer->endJob();
800 
801  //--- Jet
802  if(theJetAnalyzerFlag) {
803  theAKJetAnalyzer->endJob();
804  if(theSConeJetAnalyzerFlag) theSCJetAnalyzer->endJob();
805  if(theIConeJetAnalyzerFlag) theICJetAnalyzer->endJob();
806  }
807 
808  if(theJetCleaningFlag) {
809  theCleanedAKJetAnalyzer->endJob();
810  if(theSConeJetAnalyzerFlag) theCleanedSCJetAnalyzer->endJob();
811  if(theIConeJetAnalyzerFlag) theCleanedICJetAnalyzer->endJob();
812  }
813 
814  if(theDiJetSelectionFlag) theDiJetAnalyzer->endJob();
815 
816  if(theJetPtAnalyzerFlag ) {
817  thePtAKJetAnalyzer->endJob();
818  if(theSConeJetAnalyzerFlag) thePtSCJetAnalyzer->endJob();
819  if(theIConeJetAnalyzerFlag) thePtICJetAnalyzer->endJob();
820  }
821 
822  if(theJetPtCleaningFlag ) {
823  theCleanedPtAKJetAnalyzer->endJob();
824  if(theSConeJetAnalyzerFlag) theCleanedPtSCJetAnalyzer->endJob();
825  if(theIConeJetAnalyzerFlag) theCleanedPtICJetAnalyzer->endJob();
826  }
827 
828  if(theJPTJetAnalyzerFlag) theJPTJetAnalyzer->endJob();
829  if(theJPTJetCleaningFlag) theCleanedJPTJetAnalyzer->endJob();
830 
831  if(outputMEsInRootFile){
832  dbe->save(outputFileName);
833  }
834 
835 }
836 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:510
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::Event::triggerNames
virtual edm::TriggerNames const & triggerNames(edm::TriggerResults const &triggerResults) const
Definition: Event.cc:208
JetMETAnalyzer::endJob
void endJob(void)
Save the histos.
Definition: JetMETAnalyzer.cc:783
python.pfJets_cff.pfJets
tuple pfJets
Definition: pfJets_cff.py:8
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:47
JetMETAnalyzer::JetMETAnalyzer
JetMETAnalyzer(const edm::ParameterSet &)
Constructor.
Definition: JetMETAnalyzer.cc:38
JetMETAnalyzer::endRun
void endRun(const edm::Run &, const edm::EventSetup &)
Finish up a run.
Definition: JetMETAnalyzer.cc:385
ExpressReco_HICollisions_FallBack.vertexCollection
tuple vertexCollection
Definition: ExpressReco_HICollisions_FallBack.py:7595
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:35
edm::TriggerNames::size
Strings::size_type size() const
Definition: TriggerNames.cc:39
JetMETAnalyzer::beginRun
void beginRun(const edm::Run &, const edm::EventSetup &)
Initialize run-based parameters.
Definition: JetMETAnalyzer.cc:332
iEvent
int iEvent
Definition: GenABIO.cc:243
edm::TriggerNames::triggerIndex
unsigned int triggerIndex(std::string const &name) const
Definition: TriggerNames.cc:32
j
int j
Definition: DBlmapReader.cc:9
TechnicalTriggerWord
std::vector< bool > TechnicalTriggerWord
technical trigger bits (64 bits)
Definition: L1GlobalTriggerReadoutSetupFwd.h:39
JetMETAnalyzer::beginJob
void beginJob(void)
Inizialize parameters for histo binning.
Definition: JetMETAnalyzer.cc:276
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:359
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:511
ExpressReco_HICollisions_FallBack.outputFileName
tuple outputFileName
Definition: ExpressReco_HICollisions_FallBack.py:11511
DEBUG
#define DEBUG
Definition: JetMETAnalyzer.cc:35
edm::Handle::product
T const * product() const
Definition: Handle.h:74
ExpressReco_HICollisions_FallBack.parameters
tuple parameters
Definition: ExpressReco_HICollisions_FallBack.py:22416
JPTJetAnalyzer
JPT jet analyzer class definition.
Definition: JPTJetAnalyzer.h:42
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
JetMETAnalyzer::~JetMETAnalyzer
virtual ~JetMETAnalyzer()
Destructor.
Definition: JetMETAnalyzer.cc:222
v
mathSSE::Vec4< T > v
Definition: newBasic3DVector.h:210
edm::Run
Definition: Run.h:31
JetMETAnalyzer::analyze
void analyze(const edm::Event &, const edm::EventSetup &)
Get the analysis.
Definition: JetMETAnalyzer.cc:406
Generated for CMSSW Reference Manual by doxygen 1.8.5