CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
METTester.cc
Go to the documentation of this file.
1 // author: Mike Schmitt, University of Florida
2 // first version 8/24/2006
3 // modification: Bobby Scurlock
4 // date: 03.11.2006
5 // note: added RMS(METx) vs SumET capability
6 // modification: Rick Cavanaugh
7 // date: 05.11.2006
8 // note: cleaned up constructor and beginJob, removed int conv. warning
9 // added configuration params
10 // modification: Mike Schmitt
11 // date: 02.28.2007
12 // note: code rewrite. Now uses STL map for monitoring element container.
13 // modification: Bobby Scurlock
14 // date: 04.03.2007
15 // note: Eliminated automated resolution fitting. This is now done in a ROOT script.
16 
17 // date: 02.04.2009
18 // note: Added option to use fine binning or course binning for histos
19 //
20 // modification: Samantha Hewamanage, Florida International University
21 // date: 01.30.2012
22 // note: Added few hists for various nvtx ranges to study PU effects.
23 // Cleaned up the code by making it readable and const'ing the
24 // variables that should be changed.
25 // Changed the number of bins from odd to even. Odd number of bins
26 // makes it impossible to rebin a hist.
27 #include "METTester.h"
28 using namespace reco;
29 using namespace std;
30 using namespace edm;
31 
32 METTester::METTester(const edm::ParameterSet& iConfig)
33 {
34 
35  inputMETLabel_ =iConfig.getParameter<edm::InputTag>("InputMETLabel");
36  METType_ =iConfig.getUntrackedParameter<std::string>("METType");
37  mOutputFile =iConfig.getUntrackedParameter<std::string>("OutputFile","");
38 
39  std::string inputMETCollectionLabel(inputMETLabel_.label());
40 
41  isCaloMET = (std::string("calo")==METType_);
42 // isCorMET = (std::string("cor") ==METType_);
43  isTcMET = (std::string("tc") ==METType_);
44  isPFMET = (std::string("pf") ==METType_);
45  isGenMET = (std::string("gen") ==METType_);
46 
47  if(isTcMET) {
48  inputCaloMETLabel_ =iConfig.getParameter<edm::InputTag>("InputCaloMETLabel");
49  inputTrackLabel_ =iConfig.getParameter<edm::InputTag>("InputTrackLabel");
50  inputMuonLabel_ =iConfig.getParameter<edm::InputTag>("InputMuonLabel");
51  inputElectronLabel_ =iConfig.getParameter<edm::InputTag>("InputElectronLabel");
52  inputBeamSpotLabel_ =iConfig.getParameter<edm::InputTag>("InputBeamSpotLabel");
53  minhits_ =iConfig.getParameter<int>("minhits");
54  maxd0_ =iConfig.getParameter<double>("maxd0");
55  maxchi2_ =iConfig.getParameter<double>("maxchi2");
56  maxeta_ =iConfig.getParameter<double>("maxeta");
57  maxpt_ =iConfig.getParameter<double>("maxpt");
58  maxPtErr_ =iConfig.getParameter<double>("maxPtErr");
59  trkQuality_ =iConfig.getParameter<std::vector<int> >("trkQuality");
60  trkAlgos_ =iConfig.getParameter<std::vector<int> >("trkAlgos");
61  sample_ =iConfig.getUntrackedParameter<std::string>("sample");
62  }
63 
64  pvToken_ = consumes<std::vector<reco::Vertex> >(edm::InputTag("offlinePrimaryVertices"));
65  if (isCaloMET) caloMETsToken_ = consumes<reco::CaloMETCollection> (inputMETLabel_);
66  if (isTcMET) tcMETsToken_ = consumes<reco::METCollection> (inputMETLabel_);
67  if (isPFMET) pfMETsToken_ = consumes<reco::PFMETCollection> (inputMETLabel_);
68  if (isGenMET) genMETsToken_ = consumes<reco::GenMETCollection> (inputMETLabel_);
69  if (isTcMET) {
70  caloMETsToken_ = consumes<reco::CaloMETCollection> (inputCaloMETLabel_);
71  muonToken_ = consumes<reco::MuonCollection>(inputMuonLabel_);
72  trackToken_ = consumes<reco::TrackCollection>(inputTrackLabel_);
73  electronToken_ = consumes<edm::View<reco::GsfElectron > >(inputElectronLabel_);
74  beamSpotToken_ = consumes<reco::BeamSpot>(inputBeamSpotLabel_);
75  tcMet_ValueMap_Token_ = consumes<edm::ValueMap<reco::MuonMETCorrectionData> >(edm::InputTag("muonTCMETValueMapProducer" , "muCorrData"));
76  met_ValueMap_Token_ = consumes<edm::ValueMap<reco::MuonMETCorrectionData> >(edm::InputTag("muonMETValueMapProducer" , "muCorrData"));
77  }
78  genMETsTrueToken_ = consumes<reco::GenMETCollection> (edm::InputTag("genMetTrue"));
79  genMETsCaloToken_ = consumes<reco::GenMETCollection> (edm::InputTag("genMetCalo"));
80  //Events variables
81  mNvertex = 0;
82 
83  //Common variables
84  mMEx = 0;
85  mMEy = 0;
86  mMETSig = 0;
87  mMET = 0;
88  mMETFine = 0;
89  mMET_Nvtx = 0;
90  mMETPhi = 0;
91  mSumET = 0;
92  mMETDifference_GenMETTrue = 0;
93  mMETDeltaPhi_GenMETTrue = 0;
94  mMETDifference_GenMETCalo = 0;
95  mMETDeltaPhi_GenMETCalo = 0;
96 
97  //CaloMET variables
98  mCaloMaxEtInEmTowers = 0;
99  mCaloMaxEtInHadTowers = 0;
100  mCaloEtFractionHadronic = 0;
101  mCaloEmEtFraction = 0;
102  mCaloHadEtInHB = 0;
103  mCaloHadEtInHO = 0;
104  mCaloHadEtInHE = 0;
105  mCaloHadEtInHF = 0;
106  mCaloEmEtInHF = 0;
107  mCaloSETInpHF = 0;
108  mCaloSETInmHF = 0;
109  mCaloEmEtInEE = 0;
110  mCaloEmEtInEB = 0;
111 
112 
113  //GenMET variables
114  mNeutralEMEtFraction=0;
115  mNeutralHadEtFraction=0;
116  mChargedEMEtFraction=0;
117  mChargedHadEtFraction=0;
118  mMuonEtFraction=0;
119  mInvisibleEtFraction=0;
120 
121  //MET variables
122 
123  //PFMET variables
124  mMETDifference_GenMETTrue_MET0to20=0;
125  mMETDifference_GenMETTrue_MET20to40=0;
126  mMETDifference_GenMETTrue_MET40to60=0;
127  mMETDifference_GenMETTrue_MET60to80=0;
128  mMETDifference_GenMETTrue_MET80to100=0;
129  mMETDifference_GenMETTrue_MET100to150=0;
130  mMETDifference_GenMETTrue_MET150to200=0;
131  mMETDifference_GenMETTrue_MET200to300=0;
132  mMETDifference_GenMETTrue_MET300to400=0;
133  mMETDifference_GenMETTrue_MET400to500=0;
134  mMETDifference_GenMETTrue_METResolution=0;
135 
136  //TCMET specific variables
137  mMExCorrection=0;
138  mMEyCorrection=0;
139  mMuonCorrectionFlag=0;
140  mtrkPt=0;
141  mtrkEta=0;
142  mtrkNhits=0;
143  mtrkChi2=0;
144  mtrkD0=0;
145  mtrkQuality=0;
146  mtrkAlgo=0;
147  mtrkPtErr=0;
148  melePt=0;
149  meleEta=0;
150  meleHoE=0;
151 
152  mmuPt=0;
153  mmuEta=0;
154  mmuNhits=0;
155  mmuChi2=0;
156  mmuD0=0;
157  mnMus=0;
158  mnMusPis=0;
159  mnEls=0;
160  mfracTrks=0;
161  mdMET=0;
162  mdMETx=0;
163  mdMETy=0;
164  mdMEy=0;
165  mdMUx=0;
166  mdMUy=0;
167 
168  // get ahold of back-end interface
169  DQMStore* dbe_ = &*edm::Service<DQMStore>();
170 
171  if (dbe_) {
172 
173  dbe_->setCurrentFolder("JetMET/METValidation/"+inputMETLabel_.label());
174 
175  mNvertex = dbe_->book1D("Nvertex","Nvertex",80,0,80);
176  mMEx = dbe_->book1D("MEx","MEx",160,-800,800);
177  mMEy = dbe_->book1D("MEy","MEy",160,-800,800);
178  mMETSig = dbe_->book1D("METSig","METSig",25,0,24.5);
179  mMET = dbe_->book1D("MET", "MET (20 GeV binning)" , 100,0,2000);
180  mMETFine = dbe_->book1D("METFine", "MET (2 GeV binning)" , 1000,0,2000);
181  mMET_Nvtx = dbe_->bookProfile("MET_Nvtx", "MET vs. nvtx", 60, 0., 60., 0., 2000., " ");
182  mMETPhi = dbe_->book1D("METPhi","METPhi",80,-4,4);
183  mSumET = dbe_->book1D("SumET" , "SumET" , 200,0,4000); //10GeV
184  mMETDifference_GenMETTrue = dbe_->book1D("METDifference_GenMETTrue","METDifference_GenMETTrue", 500,-500,500);
185  mMETDeltaPhi_GenMETTrue = dbe_->book1D("METDeltaPhi_GenMETTrue","METDeltaPhi_GenMETTrue", 80,0,4);
186  mMETDifference_GenMETCalo = dbe_->book1D("METDifference_GenMETCalo","METDifference_GenMETCalo", 500,-500,500);
187  mMETDeltaPhi_GenMETCalo = dbe_->book1D("METDeltaPhi_GenMETCalo","METDeltaPhi_GenMETCalo", 80,0,4);
188 
189  mMETDifference_GenMETTrue_MET0to20 = dbe_->book1D("METResolution_GenMETTrue_MET0to20" , "METResolution_GenMETTrue_MET0to20" , 500,-500,500);
190  mMETDifference_GenMETTrue_MET20to40 = dbe_->book1D("METResolution_GenMETTrue_MET20to40" , "METResolution_GenMETTrue_MET20to40" , 500,-500,500);
191  mMETDifference_GenMETTrue_MET40to60 = dbe_->book1D("METResolution_GenMETTrue_MET40to60" , "METResolution_GenMETTrue_MET40to60" , 500,-500,500);
192  mMETDifference_GenMETTrue_MET60to80 = dbe_->book1D("METResolution_GenMETTrue_MET60to80" , "METResolution_GenMETTrue_MET60to80" , 500,-500,500);
193  mMETDifference_GenMETTrue_MET80to100 = dbe_->book1D("METResolution_GenMETTrue_MET80to100" , "METResolution_GenMETTrue_MET80to100" , 500,-500,500);
194  mMETDifference_GenMETTrue_MET100to150 = dbe_->book1D("METResolution_GenMETTrue_MET100to150", "METResolution_GenMETTrue_MET100to150", 500,-500,500);
195  mMETDifference_GenMETTrue_MET150to200 = dbe_->book1D("METResolution_GenMETTrue_MET150to200", "METResolution_GenMETTrue_MET150to200", 500,-500,500);
196  mMETDifference_GenMETTrue_MET200to300 = dbe_->book1D("METResolution_GenMETTrue_MET200to300", "METResolution_GenMETTrue_MET200to300", 500,-500,500);
197  mMETDifference_GenMETTrue_MET300to400 = dbe_->book1D("METResolution_GenMETTrue_MET300to400", "METResolution_GenMETTrue_MET300to400", 500,-500,500);
198  mMETDifference_GenMETTrue_MET400to500 = dbe_->book1D("METResolution_GenMETTrue_MET400to500", "METResolution_GenMETTrue_MET400to500", 500,-500,500);
199  //this will be filled at the end of the job using info from above hists
200  int nBins = 10;
201  float bins[] = {0.,20.,40.,60.,80.,100.,150.,200.,300.,400.,500.};
202  mMETDifference_GenMETTrue_METResolution = dbe_->book1D("METResolution_GenMETTrue_InMETBins","METResolution_GenMETTrue_InMETBins",nBins, bins);
203 
204  if ( isCaloMET) {
205  mCaloMaxEtInEmTowers = dbe_->book1D("CaloMaxEtInEmTowers","CaloMaxEtInEmTowers",300,0,1500); //5GeV
206  mCaloMaxEtInHadTowers = dbe_->book1D("CaloMaxEtInHadTowers","CaloMaxEtInHadTowers",300,0,1500); //5GeV
207  mCaloEtFractionHadronic = dbe_->book1D("CaloEtFractionHadronic","CaloEtFractionHadronic",100,0,1);
208  mCaloEmEtFraction = dbe_->book1D("CaloEmEtFraction","CaloEmEtFraction",100,0,1);
209  mCaloHadEtInHB = dbe_->book1D("CaloHadEtInHB","CaloHadEtInHB", 200, 0, 2000); //5GeV
210  mCaloHadEtInHE = dbe_->book1D("CaloHadEtInHE","CaloHadEtInHE", 100, 0, 500); //5GeV
211  mCaloHadEtInHO = dbe_->book1D("CaloHadEtInHO","CaloHadEtInHO", 100, 0, 200); //5GeV
212  mCaloHadEtInHF = dbe_->book1D("CaloHadEtInHF","CaloHadEtInHF", 100, 0, 200); //5GeV
213  mCaloSETInpHF = dbe_->book1D("CaloSETInpHF","CaloSETInpHF",100, 0, 500);
214  mCaloSETInmHF = dbe_->book1D("CaloSETInmHF","CaloSETInmHF",100, 0, 500);
215  mCaloEmEtInEE = dbe_->book1D("CaloEmEtInEE","CaloEmEtInEE",100, 0, 500); //5GeV
216  mCaloEmEtInEB = dbe_->book1D("CaloEmEtInEB","CaloEmEtInEB",100, 0, 500); //5GeV
217  mCaloEmEtInHF = dbe_->book1D("CaloEmEtInHF","CaloEmEtInHF",100, 0, 500); //5GeV
218  }
219 
220  if(isGenMET){
221  mNeutralEMEtFraction = dbe_->book1D("GenNeutralEMEtFraction", "GenNeutralEMEtFraction", 120, 0.0, 1.2 );
222  mNeutralHadEtFraction = dbe_->book1D("GenNeutralHadEtFraction", "GenNeutralHadEtFraction", 120, 0.0, 1.2 );
223  mChargedEMEtFraction = dbe_->book1D("GenChargedEMEtFraction", "GenChargedEMEtFraction", 120, 0.0, 1.2);
224  mChargedHadEtFraction = dbe_->book1D("GenChargedHadEtFraction", "GenChargedHadEtFraction", 120, 0.0,1.2);
225  mMuonEtFraction = dbe_->book1D("GenMuonEtFraction", "GenMuonEtFraction", 120, 0.0, 1.2 );
226  mInvisibleEtFraction = dbe_->book1D("GenInvisibleEtFraction", "GenInvisibleEtFraction", 120, 0.0, 1.2 );
227  }
228 
229  if (isPFMET){
230  mPFphotonEtFraction = dbe_->book1D("photonEtFraction", "photonEtFraction", 100, 0, 1);
231  mPFphotonEt = dbe_->book1D("photonEt", "photonEt", 100, 0, 1000);
232  mPFneutralHadronEtFraction = dbe_->book1D("neutralHadronEtFraction", "neutralHadronEtFraction", 100, 0, 1);
233  mPFneutralHadronEt = dbe_->book1D("neutralHadronEt", "neutralHadronEt", 100, 0, 1000);
234  mPFelectronEtFraction = dbe_->book1D("electronEtFraction", "electronEtFraction", 100, 0, 1);
235  mPFelectronEt = dbe_->book1D("electronEt", "electronEt", 100, 0, 1000);
236  mPFchargedHadronEtFraction = dbe_->book1D("chargedHadronEtFraction", "chargedHadronEtFraction", 100, 0, 1);
237  mPFchargedHadronEt = dbe_->book1D("chargedHadronEt", "chargedHadronEt", 100, 0, 1000);
238  mPFmuonEtFraction = dbe_->book1D("muonEtFraction", "muonEtFraction", 100, 0, 1);
239  mPFmuonEt = dbe_->book1D("muonEt", "muonEt", 100, 0, 1000);
240  mPFHFHadronEtFraction = dbe_->book1D("HFHadronEtFraction", "HFHadronEtFraction", 100, 0, 1);
241  mPFHFHadronEt = dbe_->book1D("HFHadronEt", "HFHadronEt", 100, 0, 500);
242  mPFHFEMEtFraction = dbe_->book1D("HFEMEtFraction", "HFEMEtFraction", 100, 0, 1);
243  mPFHFEMEt = dbe_->book1D("HFEMEt", "HFEMEt", 100, 0, 300);
244 
245  }
246 
247  if ( isTcMET){
248  //TCMET or MuonCorrectedCaloMET Histograms
249 
250  mMExCorrection = dbe_->book1D("MExCorrection","MExCorrection", 1000, -500.0,500.0);
251  mMEyCorrection = dbe_->book1D("MEyCorrection","MEyCorrection", 1000, -500.0,500.0);
252  mMuonCorrectionFlag = dbe_->book1D("CorrectionFlag", "CorrectionFlag", 6, -0.5, 5.5);
253 
254  if(isTcMET) {//TCMET only histograms
255  mtrkPt = dbe_->book1D("trackPt", "trackPt", 50, 0, 500);
256  mtrkEta = dbe_->book1D("trackEta", "trackEta", 50, -2.5, 2.5);
257  mtrkNhits = dbe_->book1D("trackNhits", "trackNhits", 50, 0, 50);
258  mtrkChi2 = dbe_->book1D("trackNormalizedChi2", "trackNormalizedChi2", 20, 0, 20);
259  mtrkD0 = dbe_->book1D("trackD0", "trackd0", 50, -1, 1);
260  mtrkQuality = dbe_->book1D("trackQuality", "trackQuality", 30, -0.5, 29.5);
261  mtrkAlgo = dbe_->book1D("trackAlgo", "trackAlgo", 6, 3.5, 9.5);
262  mtrkPtErr = dbe_->book1D("trackPtErr", "trackPtErr", 200, 0, 2);
263  melePt = dbe_->book1D("electronPt", "electronPt", 50, 0, 500);
264  meleEta = dbe_->book1D("electronEta", "electronEta", 50, -2.5, 2.5);
265  meleHoE = dbe_->book1D("electronHoverE", "electronHoverE", 25, 0, 0.5);
266  mmuPt = dbe_->book1D("muonPt", "muonPt", 50, 0, 500);
267  mmuEta = dbe_->book1D("muonEta", "muonEta", 50, -2.5, 2.5);
268  mmuNhits = dbe_->book1D("muonNhits", "muonNhits", 50, 0, 50);
269  mmuChi2 = dbe_->book1D("muonNormalizedChi2", "muonNormalizedChi2", 20, 0, 20);
270  mmuD0 = dbe_->book1D("muonD0", "muonD0", 50, -1, 1);
271  mnMus = dbe_->book1D("nMus", "nMus", 5, -0.5, 4.5);
272  mnMusPis = dbe_->book1D("nMusAsPis", "nMusAsPis", 5, -0.5, 4.5);
273  mnEls = dbe_->book1D("nEls", "nEls", 5, -0.5, 4.5);
274  mfracTrks = dbe_->book1D("fracTracks", "fracTracks", 100, 0, 1);
275  mdMETx = dbe_->book1D("dMETx", "difference to caloMETx", 500, -250, 250);
276  mdMETy = dbe_->book1D("dMETy", "difference to caloMETy", 500, -250, 250);
277  mdMET = dbe_->book1D("dMET", "difference to caloMET", 500, -250, 250);
278  mdMUx = dbe_->book1D("dMUx", "dMUx", 500, -250, 250);
279  mdMUy = dbe_->book1D("dMUy", "dMUy", 500, -250, 250);
280  mMuonCorrectionFlag->setBinLabel(1,"Not Corrected");
281  mMuonCorrectionFlag->setBinLabel(2,"Global Fit");
282  mMuonCorrectionFlag->setBinLabel(3,"Tracker Fit");
283  mMuonCorrectionFlag->setBinLabel(4,"SA Fit");
284  mMuonCorrectionFlag->setBinLabel(5,"Treated as Pion");
285  mMuonCorrectionFlag->setBinLabel(6,"Default fit");
286  }
287 // if(isCorMET) {
288 // mmuPt = dbe_->book1D("muonPt", "muonPt", 50, 0, 500);
289 // mmuEta = dbe_->book1D("muonEta", "muonEta", 50, -2.5, 2.5);
290 // mmuNhits = dbe_->book1D("muonNhits", "muonNhits", 50, 0, 50);
291 // mmuChi2 = dbe_->book1D("muonNormalizedChi2", "muonNormalizedChi2", 20, 0, 20);
292 // mmuD0 = dbe_->book1D("muonD0", "muonD0", 50, -1, 1);
293 // mMuonCorrectionFlag->setBinLabel(1,"Not Corrected");
294 // mMuonCorrectionFlag->setBinLabel(2,"Global Fit");
295 // mMuonCorrectionFlag->setBinLabel(3,"Tracker Fit");
296 // mMuonCorrectionFlag->setBinLabel(4,"SA Fit");
297 // mMuonCorrectionFlag->setBinLabel(5,"Treated as Pion");
298 // mMuonCorrectionFlag->setBinLabel(6,"Default fit");
299 // }
300  }
301 
302  else {
303  edm::LogInfo("OutputInfo") << " METType not correctly specified!'";// << outputFile_.c_str();
304  }
305  }
306  if (mOutputFile.empty ())
307  {
308  LogInfo("OutputInfo") << " Histograms will NOT be saved";
309  }
310  else
311  {
312  LogInfo("OutputInfo") << " Histograms will be saved to file:" << mOutputFile;
313  }
314 }
315 
316 
317 void METTester::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
318 {
319 
320 }
321 
322 void METTester::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
323 { //int counter(0);
324  edm::Handle<reco::VertexCollection> pvHandle;
325  iEvent.getByToken(pvToken_, pvHandle);
326  if (! pvHandle.isValid())
327  {
328  std::cout << __FUNCTION__ << ":" << __LINE__ << ":pvHandle handle not found!" << std::endl;
329  assert(false);
330  }
331  const int nvtx = pvHandle->size();
332  mNvertex->Fill(nvtx);
333  //Collections for all MET collections
334 
335  edm::Handle<CaloMETCollection> caloMETs;
336  edm::Handle<METCollection> tcMETs;
337 // edm::Handle<CaloMETCollection> corMETs;
338  edm::Handle<PFMETCollection> pfMETs;
339  edm::Handle<GenMETCollection> genMETs;
340 
341  if (isCaloMET or isTcMET) iEvent.getByToken(caloMETsToken_, caloMETs);
342  if (isTcMET) iEvent.getByToken(tcMETsToken_, tcMETs);
343  if (isPFMET) iEvent.getByToken(pfMETsToken_, pfMETs);
344  if (isGenMET) iEvent.getByToken(genMETsToken_, genMETs);
345  if ((isCaloMET or isTcMET) and !caloMETs.isValid()) return;
346  if ((isTcMET) and !tcMETs.isValid()) return;
347 // if ((isCorMET) and !caloMETs.isValid()) return;
348  if ((isPFMET) and !pfMETs.isValid()) return;
349  if ((isGenMET) and !genMETs.isValid()) return;
350 
351  reco::MET met;
352  if (isCaloMET) { met = caloMETs->front();}
353  if (isTcMET) { met = tcMETs->front() ;}
354 // if (isCorMET) { met = caloMETs->front();}
355  if (isPFMET) { met = pfMETs->front() ;}
356  if (isGenMET) { met = genMETs->front() ;}
357 
358  const double SumET = met.sumEt();
359  const double METSig = met.mEtSig();
360  const double MET = met.pt();
361  const double MEx = met.px();
362  const double MEy = met.py();
363  const double METPhi = met.phi();
364  mMEx->Fill(MEx);
365  mMEy->Fill(MEy);
366  mMET->Fill(MET);
367  mMETFine->Fill(MET);
368  mMET_Nvtx->Fill((double)nvtx, MET);
369  mMETPhi->Fill(METPhi);
370  mSumET->Fill(SumET);
371  mMETSig->Fill(METSig);
372 // cout<<"isCaloMET "<<boolalpha<<isCaloMET<<" isGenMET "<<isPFMET<<" isTcMET "<<isTcMET<<" isPFMET "<<isPFMET<<" met:"<<MET<<endl;
373  // Get Generated MET for Resolution plots
374  edm::Handle<GenMETCollection> genTrue;
375  iEvent.getByToken(genMETsTrueToken_, genTrue);
376  if (genTrue.isValid()) {
377  const GenMETCollection *genmetcol = genTrue.product();
378  const GenMET *genMetTrue = &(genmetcol->front());
379  double genMET = genMetTrue->pt();
380  double genMETPhi = genMetTrue->phi();
381 
382  mMETDifference_GenMETTrue->Fill( MET - genMET );
383  mMETDeltaPhi_GenMETTrue->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
384 
385  //pfMET resolution in pfMET bins : Sam, Feb, 2012
386  if (MET > 0 && MET < 20) mMETDifference_GenMETTrue_MET0to20->Fill( MET - genMET );
387  else if (MET > 20 && MET < 40) mMETDifference_GenMETTrue_MET20to40->Fill( MET - genMET );
388  else if (MET > 40 && MET < 60) mMETDifference_GenMETTrue_MET40to60->Fill( MET - genMET );
389  else if (MET > 60 && MET < 80) mMETDifference_GenMETTrue_MET60to80->Fill( MET - genMET );
390  else if (MET > 80 && MET <100) mMETDifference_GenMETTrue_MET80to100->Fill( MET - genMET );
391  else if (MET >100 && MET <150) mMETDifference_GenMETTrue_MET100to150->Fill( MET - genMET );
392  else if (MET >150 && MET <200) mMETDifference_GenMETTrue_MET150to200->Fill( MET - genMET );
393  else if (MET >200 && MET <300) mMETDifference_GenMETTrue_MET200to300->Fill( MET - genMET );
394  else if (MET >300 && MET <400) mMETDifference_GenMETTrue_MET300to400->Fill( MET - genMET );
395  else if (MET >400 && MET <500) mMETDifference_GenMETTrue_MET400to500->Fill( MET - genMET );
396 
397  } else {
398  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetTrue";
399  }
400  edm::Handle<GenMETCollection> genCalo;
401  iEvent.getByToken(genMETsCaloToken_, genCalo);
402  if (genCalo.isValid()) {
403  const GenMETCollection *genmetcol = genCalo.product();
404  const GenMET *genMetCalo = &(genmetcol->front());
405  const double genMET = genMetCalo->pt();
406  const double genMETPhi = genMetCalo->phi();
407 
408  mMETDifference_GenMETCalo->Fill( MET - genMET );
409  mMETDeltaPhi_GenMETCalo->Fill( TMath::ACos( TMath::Cos( METPhi - genMETPhi ) ) );
410  } else {
411  edm::LogInfo("OutputInfo") << " failed to retrieve data required by MET Task: genMetCalo";
412  }
413 
414  if ( isCaloMET) {
415  const reco::CaloMET * calomet = &(caloMETs->front());
416  // ==========================================================
417  // Reconstructed MET Information
418  const double caloMaxEtInEMTowers = calomet->maxEtInEmTowers();
419  const double caloMaxEtInHadTowers = calomet->maxEtInHadTowers();
420  const double caloEtFractionHadronic = calomet->etFractionHadronic();
421  const double caloEmEtFraction = calomet->emEtFraction();
422  const double caloHadEtInHB = calomet->hadEtInHB();
423  const double caloHadEtInHO = calomet->hadEtInHO();
424  const double caloHadEtInHE = calomet->hadEtInHE();
425  const double caloHadEtInHF = calomet->hadEtInHF();
426  const double caloEmEtInEB = calomet->emEtInEB();
427  const double caloEmEtInEE = calomet->emEtInEE();
428  const double caloEmEtInHF = calomet->emEtInHF();
429  const double caloSETInpHF = calomet->CaloSETInpHF();
430  const double caloSETInmHF = calomet->CaloSETInmHF();
431 
432  mCaloMaxEtInEmTowers->Fill(caloMaxEtInEMTowers);
433  mCaloMaxEtInHadTowers->Fill(caloMaxEtInHadTowers);
434  mCaloEtFractionHadronic->Fill(caloEtFractionHadronic);
435  mCaloEmEtFraction->Fill(caloEmEtFraction);
436  mCaloHadEtInHB->Fill(caloHadEtInHB);
437  mCaloHadEtInHO->Fill(caloHadEtInHO);
438  mCaloHadEtInHE->Fill(caloHadEtInHE);
439  mCaloHadEtInHF->Fill(caloHadEtInHF);
440  mCaloEmEtInEB->Fill(caloEmEtInEB);
441  mCaloEmEtInEE->Fill(caloEmEtInEE);
442  mCaloEmEtInHF->Fill(caloEmEtInHF);
443  mCaloSETInpHF->Fill(caloSETInpHF);
444  mCaloSETInmHF->Fill(caloSETInmHF);
445  }
446  if (isGenMET)
447  {
448  const GenMET *genmet;
449  // Get Generated MET
450  genmet = &(genMETs->front());
451 
452  const double NeutralEMEtFraction = genmet->NeutralEMEtFraction() ;
453  const double NeutralHadEtFraction = genmet->NeutralHadEtFraction() ;
454  const double ChargedEMEtFraction = genmet->ChargedEMEtFraction () ;
455  const double ChargedHadEtFraction = genmet->ChargedHadEtFraction();
456  const double MuonEtFraction = genmet->MuonEtFraction() ;
457  const double InvisibleEtFraction = genmet->InvisibleEtFraction() ;
458 
459  mNeutralEMEtFraction->Fill( NeutralEMEtFraction );
460  mNeutralHadEtFraction->Fill( NeutralHadEtFraction );
461  mChargedEMEtFraction->Fill( ChargedEMEtFraction );
462  mChargedHadEtFraction->Fill( ChargedHadEtFraction );
463  mMuonEtFraction->Fill( MuonEtFraction );
464  mInvisibleEtFraction->Fill( InvisibleEtFraction );
465  }
466  if(isPFMET)
467  {
468  const reco::PFMET * pfmet = &(pfMETs->front());
469  mPFphotonEtFraction->Fill(pfmet->photonEtFraction());
470  mPFphotonEt->Fill(pfmet->photonEt());
471  mPFneutralHadronEtFraction->Fill(pfmet->neutralHadronEtFraction());
472  mPFneutralHadronEt->Fill(pfmet->neutralHadronEt());
473  mPFelectronEtFraction->Fill(pfmet->electronEtFraction());
474  mPFelectronEt->Fill(pfmet->electronEt());
475  mPFchargedHadronEtFraction->Fill(pfmet->chargedHadronEtFraction());
476  mPFchargedHadronEt->Fill(pfmet->chargedHadronEt());
477  mPFmuonEtFraction->Fill(pfmet->muonEtFraction());
478  mPFmuonEt->Fill(pfmet->muonEt());
479  mPFHFHadronEtFraction->Fill(pfmet->HFHadronEtFraction());
480  mPFHFHadronEt->Fill(pfmet->HFHadronEt());
481  mPFHFEMEtFraction->Fill(pfmet->HFEMEtFraction());
482  mPFHFEMEt->Fill(pfmet->HFEMEt());
483  // Reconstructed MET Information
484 
485  }
486  if(isTcMET)
487  {
488 
489  const CaloMET *caloMet;
490  edm::Handle<CaloMETCollection> hcaloMetcol;
491  iEvent.getByToken(caloMETsToken_, hcaloMetcol);
492 
493  edm::Handle< reco::MuonCollection > muon_h;
494  iEvent.getByToken(muonToken_, muon_h);
495 
496  // edm::Handle< edm::View<reco::Track> > track_h;
497  edm::Handle<reco::TrackCollection> track_h;
498  iEvent.getByToken(trackToken_, track_h);
499 
500  edm::Handle< edm::View<reco::GsfElectron > > electron_h;
501  iEvent.getByToken(electronToken_, electron_h);
502 
503  edm::Handle< reco::BeamSpot > beamSpot_h;
504  iEvent.getByToken(beamSpotToken_, beamSpot_h);
505 
506  const reco::MET * tcMet = &(tcMETs->front());
507 
508  if(!hcaloMetcol.isValid()){
509  edm::LogInfo("OutputInfo") << "falied to retrieve data require by MET Task";
510  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
511  return;
512  }
513  else
514  {
515  const CaloMETCollection *caloMetcol = hcaloMetcol.product();
516  caloMet = &(caloMetcol->front());
517  }
518 
519  if(!muon_h.isValid()){
520  edm::LogInfo("OutputInfo") << "falied to retrieve muon data require by MET Task";
521  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
522  return;
523  }
524 
525  if(!electron_h.isValid()){
526  edm::LogInfo("OutputInfo") << "falied to retrieve electron data require by MET Task";
527  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
528  return;
529  }
530 
531  if(!beamSpot_h.isValid()){
532  edm::LogInfo("OutputInfo") << "falied to retrieve beam spot data require by MET Task";
533  edm::LogInfo("OutputInfo") << "MET Taks cannot continue...!";
534  return;
535  }
536 
537  math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
538 
539  //Event selection-----------------------------------------------------------------------
540 
541  edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > tcMet_ValueMap_Handle;
542  iEvent.getByToken(tcMet_ValueMap_Token_, tcMet_ValueMap_Handle);
543 
544  //count muons
545  int nM = 0;
546 
547  for( unsigned int mus = 0; mus < muon_h->size() ; mus++ ) {
548 
549  reco::MuonRef muref( muon_h, mus);
550  if( muref->pt() < 20 ) continue;
551 
552  reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
553  int type = muCorrData.type();
554 
555  if( type == 1 || type == 2 || type == 5 ) ++nM;
556  }
557 
558  //count electrons
559  int nE = 0;
560 
561  for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
562  if( eleit->p4().pt() < 20 ) continue;
563  ++nE;
564  }
565 
566  if( strcmp( sample_.c_str() , "zmm" ) == 0 && nM != 2 ) return;
567 
568  if( strcmp( sample_.c_str() , "zee" ) == 0 && nE != 2 ) return;
569 
570  if( strcmp( sample_.c_str() , "ttbar" ) == 0 && ( nE + nM ) == 0 ) return;
571 
572  const double caloMET = caloMet->pt();
573  const double caloMEx = caloMet->px();
574  const double caloMEy = caloMet->py();
575 
576  mdMETx->Fill(caloMEx-tcMet->px());
577  mdMETy->Fill(caloMEy-tcMet->py());
578  mdMET->Fill(caloMET-tcMet->pt());
579 
580  const unsigned int nTracks = track_h->size();
581  unsigned int nCorrTracks = 0;
582  unsigned int trackCount = 0;
583  for( reco::TrackCollection::const_iterator trkit = track_h->begin(); trkit != track_h->end(); trkit++ ) {
584  mtrkPt->Fill( trkit->pt() );
585  mtrkEta->Fill( trkit->eta() );
586  mtrkNhits->Fill( trkit->numberOfValidHits() );
587  mtrkChi2->Fill( trkit->chi2() / trkit->ndof() );
588 
589  double d0 = -1 * trkit->dxy( bspot );
590 
591  mtrkD0->Fill( d0 );
592 
593  mtrkQuality->Fill( trkit->qualityMask() );
594  mtrkAlgo->Fill( trkit->algo() );
595  mtrkPtErr->Fill( trkit->ptError() / trkit->pt() );
596 
597  reco::TrackRef trkref( track_h, trackCount );
598 
599  if( isGoodTrack( trkref, d0) ) ++nCorrTracks;
600  ++trackCount;
601  }
602 
603  const float frac = (float)nCorrTracks / (float)nTracks;
604  mfracTrks->Fill(frac);
605 
606  int nEls = 0;
607 
608  for( edm::View<reco::GsfElectron>::const_iterator eleit = electron_h->begin(); eleit != electron_h->end(); eleit++ ) {
609  melePt->Fill( eleit->p4().pt() );
610  meleEta->Fill( eleit->p4().eta() );
611  meleHoE->Fill( eleit->hadronicOverEm() );
612 
613  reco::TrackRef el_track = eleit->closestCtfTrackRef();
614 
615  unsigned int ele_idx = el_track.isNonnull() ? el_track.key() : 99999;
616 
617  if( eleit->hadronicOverEm() < 0.1 && ele_idx < nTracks )
618  ++nEls;
619  }
620 
621  mnEls->Fill(nEls);
622 
623  for( reco::MuonCollection::const_iterator muonit = muon_h->begin(); muonit != muon_h->end(); muonit++ ) {
624 
625  const reco::TrackRef siTrack = muonit->innerTrack();
626 
627  mmuPt->Fill( muonit->p4().pt() );
628  mmuEta->Fill( muonit->p4().eta() );
629  mmuNhits->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
630  mmuChi2->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
631 
632  double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
633 
634  mmuD0->Fill( d0 );
635  }
636 
637  //edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > tcMet_ValueMap_Handle;
638  //iEvent.getByToken("muonTCMETValueMapProducer" , "muCorrData", tcMet_ValueMap_Handle);
639 
640  edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > muon_ValueMap_Handle;
641  iEvent.getByToken(met_ValueMap_Token_, muon_ValueMap_Handle);
642 
643  const unsigned int nMuons = muon_h->size();
644 
645  int nMus = 0;
646  int nMusPis = 0;
647  double muDx = 0;
648  double muDy = 0;
649  for( unsigned int mus = 0; mus < nMuons; mus++ )
650  {
651  reco::MuonRef muref( muon_h, mus);
652  reco::MuonMETCorrectionData muCorrData = (*tcMet_ValueMap_Handle)[muref];
653  reco::MuonMETCorrectionData muonCorrData = (*muon_ValueMap_Handle)[muref];
654 
655  mMExCorrection -> Fill(muCorrData.corrX());
656  mMEyCorrection -> Fill(muCorrData.corrY());
657 
658  int type = muCorrData.type();
659  mMuonCorrectionFlag-> Fill(type);
660 
661  if( type == 1 || type == 2 || type == 5 ) {
662  ++nMus;
663 
664  if( type == 1 ) {
665  muDx += muonCorrData.corrX() - muref->globalTrack()->px();
666  muDy += muonCorrData.corrY() - muref->globalTrack()->py();
667  }
668  else if( type == 2 ) {
669  muDx += muonCorrData.corrX() - muref->innerTrack()->px();
670  muDy += muonCorrData.corrY() - muref->innerTrack()->py();
671  }
672  else if( type == 5 ) {
673  muDx += muonCorrData.corrX() - muref->px();
674  muDy += muonCorrData.corrY() - muref->py();
675  }
676  }
677  else if( type == 4 )
678  ++nMusPis;
679  }
680 
681  mnMus->Fill(nMus);
682  mnMusPis->Fill(nMusPis);
683  mdMUx->Fill(muDx);
684  mdMUy->Fill(muDy);
685  }
686 
687 // if(isCorMET )
688 // {
701 //
702 // edm::Handle< edm::ValueMap<reco::MuonMETCorrectionData> > corMetGlobalMuons_ValueMap_Handle;
703 // iEvent.getByToken("muonMETValueMapProducer" , "muCorrData", corMetGlobalMuons_ValueMap_Handle);
704 //
705 // edm::Handle< reco::MuonCollection > muon_Handle;
706 // iEvent.getByToken("muons", muon_Handle);
707 //
708 // edm::Handle< reco::BeamSpot > beamSpot_h;
709 // iEvent.getByToken(inputBeamSpotLabel_, beamSpot_h);
710 //
711 // if(!beamSpot_h.isValid()){
712 // edm::LogInfo("OutputInfo") << "beamSpot is NOT Valid";
713 // edm::LogInfo("OutputInfo") << "MET Taks continues anyway...!";
714 // }
715 //
716 // math::XYZPoint bspot = ( beamSpot_h.isValid() ) ? beamSpot_h->position() : math::XYZPoint(0, 0, 0);
717 //
718 // for( reco::MuonCollection::const_iterator muonit = muon_Handle->begin(); muonit != muon_Handle->end(); muonit++ ) {
719 //
720 // const reco::TrackRef siTrack = muonit->innerTrack();
721 // const reco::TrackRef globalTrack = muonit->globalTrack();
722 //
723 // mmuPt->Fill( muonit->p4().pt() );
724 // mmuEta->Fill( muonit->p4().eta() );
725 // mmuNhits->Fill( siTrack.isNonnull() ? siTrack->numberOfValidHits() : -999 );
726 // mmuChi2->Fill( siTrack.isNonnull() ? siTrack->chi2()/siTrack->ndof() : -999 );
727 //
728 // double d0 = siTrack.isNonnull() ? -1 * siTrack->dxy( bspot) : -999;
729 //
730 // mmuD0->Fill( d0 );
731 //
732 // int nHits = globalTrack.isNonnull() ? globalTrack->hitPattern().numberOfValidMuonHits() : -999;
733 // mmuSAhits->Fill( nHits );
734 // }
735 //
736 // const unsigned int nMuons = muon_Handle->size();
737 // for( unsigned int mus = 0; mus < nMuons; mus++ )
738 // {
739 // reco::MuonRef muref( muon_Handle, mus);
740 // reco::MuonMETCorrectionData muCorrData = (*corMetGlobalMuons_ValueMap_Handle)[muref];
741 //
742 // mMExCorrection -> Fill(muCorrData.corrY());
743 // mMEyCorrection -> Fill(muCorrData.corrX());
744 // mMuonCorrectionFlag-> Fill(muCorrData.type());
745 // }
746 // }
747 
748  //This is so dirty I could cry. It should be called only ONCE in endJob. But the MonitorElements don't exist then any more.
749  FillMETRes();
750 }
751 
752 void METTester::endJob()
753 {
754  if (!mOutputFile.empty() && &*edm::Service<DQMStore>())
755  {
756  edm::Service<DQMStore>()->save(mOutputFile);
757  }
758 
759 }
760 
761 //void METTester::endRun(const edm::Run& iRun, const edm::EventSetup& iSetup)
762 void METTester::FillMETRes()
763 {
764  mMETDifference_GenMETTrue_METResolution->setBinContent(1, mMETDifference_GenMETTrue_MET0to20->getMean());
765  mMETDifference_GenMETTrue_METResolution->setBinContent(2, mMETDifference_GenMETTrue_MET20to40->getMean());
766  mMETDifference_GenMETTrue_METResolution->setBinContent(3, mMETDifference_GenMETTrue_MET40to60->getMean());
767  mMETDifference_GenMETTrue_METResolution->setBinContent(4, mMETDifference_GenMETTrue_MET60to80->getMean());
768  mMETDifference_GenMETTrue_METResolution->setBinContent(5, mMETDifference_GenMETTrue_MET80to100->getMean());
769  mMETDifference_GenMETTrue_METResolution->setBinContent(6, mMETDifference_GenMETTrue_MET100to150->getMean());
770  mMETDifference_GenMETTrue_METResolution->setBinContent(7, mMETDifference_GenMETTrue_MET150to200->getMean());
771  mMETDifference_GenMETTrue_METResolution->setBinContent(8, mMETDifference_GenMETTrue_MET200to300->getMean());
772  mMETDifference_GenMETTrue_METResolution->setBinContent(9, mMETDifference_GenMETTrue_MET300to400->getMean());
773  mMETDifference_GenMETTrue_METResolution->setBinContent(10, mMETDifference_GenMETTrue_MET400to500->getMean());
774  mMETDifference_GenMETTrue_METResolution->setBinError(1, mMETDifference_GenMETTrue_MET0to20->getRMS());
775  mMETDifference_GenMETTrue_METResolution->setBinError(2, mMETDifference_GenMETTrue_MET20to40->getRMS());
776  mMETDifference_GenMETTrue_METResolution->setBinError(3, mMETDifference_GenMETTrue_MET40to60->getRMS());
777  mMETDifference_GenMETTrue_METResolution->setBinError(4, mMETDifference_GenMETTrue_MET60to80->getRMS());
778  mMETDifference_GenMETTrue_METResolution->setBinError(5, mMETDifference_GenMETTrue_MET80to100->getRMS());
779  mMETDifference_GenMETTrue_METResolution->setBinError(6, mMETDifference_GenMETTrue_MET100to150->getRMS());
780  mMETDifference_GenMETTrue_METResolution->setBinError(7, mMETDifference_GenMETTrue_MET150to200->getRMS());
781  mMETDifference_GenMETTrue_METResolution->setBinError(8, mMETDifference_GenMETTrue_MET200to300->getRMS());
782  mMETDifference_GenMETTrue_METResolution->setBinError(9, mMETDifference_GenMETTrue_MET300to400->getRMS());
783  mMETDifference_GenMETTrue_METResolution->setBinError(10, mMETDifference_GenMETTrue_MET400to500->getRMS());
784 
785 }
786 
787 //determines if track is "good" - i.e. passes quality and kinematic cuts
788 bool METTester::isGoodTrack( const reco::TrackRef track, float d0corr ) {
789 
790  if( fabs( d0corr ) > maxd0_ ) return false;
791  if( track->numberOfValidHits() < minhits_ ) return false;
792  if( track->normalizedChi2() > maxchi2_ ) return false;
793  if( fabs( track->eta() ) > maxeta_ ) return false;
794  if( track->pt() > maxpt_ ) return false;
795  if( (track->ptError() / track->pt()) > maxPtErr_ ) return false;
796 
797  int cut = 0;
798  for( unsigned int i = 0; i < trkQuality_.size(); i++ ) {
799 
800  cut |= (1 << trkQuality_.at(i));
801  }
802 
803  if( !( ( track->qualityMask() & cut ) == cut ) ) return false;
804 
805  bool isGoodAlgo = false;
806  if( trkAlgos_.size() == 0 ) isGoodAlgo = true;
807  for( unsigned int i = 0; i < trkAlgos_.size(); i++ ) {
808 
809  if( track->algo() == trkAlgos_.at(i) ) isGoodAlgo = true;
810  }
811 
812  if( !isGoodAlgo ) return false;
813 
814  return true;
815  }
816 
817 
type
type
Definition: HCALResponse.h:21
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
i
int i
Definition: DBlmapReader.cc:9
reco::CaloMET::hadEtInHE
double hadEtInHE() const
Definition: CaloMET.h:51
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:81
GenMETCollection
Collection of Gen MET.
CaloMET_cfi.met
tuple met
____________________________________________________________________________||
Definition: CaloMET_cfi.py:7
reco::PFMET::HFEMEtFraction
double HFEMEtFraction() const
Definition: PFMET.h:47
reco::CaloMET::hadEtInHF
double hadEtInHF() const
Definition: CaloMET.h:53
METTester::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: METTester.cc:322
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
reco::CaloMET::CaloSETInmHF
double CaloSETInmHF() const
Definition: CaloMET.h:65
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventIDconst &, edm::Timestampconst & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
METTester::FillMETRes
void FillMETRes()
Definition: METTester.cc:762
reco::CaloMET::maxEtInHadTowers
double maxEtInHadTowers() const
Definition: CaloMET.h:40
reco::PFMET::neutralHadronEtFraction
double neutralHadronEtFraction() const
Definition: PFMET.h:32
reco::PFMET::muonEt
double muonEt() const
Definition: PFMET.h:42
METTester::beginRun
virtual void beginRun(const edm::Run &, const edm::EventSetup &)
Definition: METTester.cc:317
genMetCalo_cfi.genMetCalo
tuple genMetCalo
____________________________________________________________________________||
Definition: genMetCalo_cfi.py:4
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:901
reco::GenMET::MuonEtFraction
double MuonEtFraction() const
Definition: GenMET.h:57
reco::CaloMET::maxEtInEmTowers
double maxEtInEmTowers() const
Definition: CaloMET.h:38
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:105
reco::LeafCandidate::py
virtual double py() const GCC11_FINAL
y coordinate of momentum vector
Definition: LeafCandidate.h:149
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
CaloMETCollection
Collection of Calo MET.
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:250
reco::LeafCandidate::phi
virtual float phi() const GCC11_FINAL
momentum azimuthal angle
Definition: LeafCandidate.h:155
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
reco::PFMET::HFHadronEt
double HFHadronEt() const
Definition: PFMET.h:45
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
reco::MET
Definition: MET.h:32
reco::PFMET::photonEtFraction
double photonEtFraction() const
Definition: PFMET.h:29
reco::GenMET::ChargedEMEtFraction
double ChargedEMEtFraction() const
Definition: GenMET.h:39
genMetTrue_cff.genMetTrue
tuple genMetTrue
Definition: genMetTrue_cff.py:21
reco::LeafCandidate::px
virtual double px() const GCC11_FINAL
x coordinate of momentum vector
Definition: LeafCandidate.h:147
reco::CaloMET::emEtInEB
double emEtInEB() const
Definition: CaloMET.h:55
DQMStore::bookProfile
MonitorElement * bookProfile(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY, const char *option="s")
Definition: DQMStore.cc:1186
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:76
reco::CaloMET::CaloSETInpHF
double CaloSETInpHF() const
Definition: CaloMET.h:63
reco::GenMET::InvisibleEtFraction
double InvisibleEtFraction() const
Definition: GenMET.h:63
reco::PFMET::HFEMEt
double HFEMEt() const
Definition: PFMET.h:48
dbe_
DQMStore * dbe_
Definition: PFJetBenchmarkAnalyzer.cc:79
reco::CaloMET::hadEtInHO
double hadEtInHO() const
Definition: CaloMET.h:49
reco::PFMET::electronEt
double electronEt() const
Definition: PFMET.h:36
reco::CaloMET::etFractionHadronic
double etFractionHadronic() const
Definition: CaloMET.h:42
reco::PFMET::photonEt
double photonEt() const
Definition: PFMET.h:30
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
TCMET_cfi.tcMet
tuple tcMet
____________________________________________________________________________||
Definition: TCMET_cfi.py:4
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:266
edm::Handle::product
T const * product() const
Definition: Handle.h:81
reco::GenMET::NeutralEMEtFraction
double NeutralEMEtFraction() const
Definition: GenMET.h:33
reco::CaloMET::emEtInEE
double emEtInEE() const
Definition: CaloMET.h:57
reco::PFMET::electronEtFraction
double electronEtFraction() const
Definition: PFMET.h:35
reco::PFMET::chargedHadronEtFraction
double chargedHadronEtFraction() const
Definition: PFMET.h:38
cuy.save
list save
Definition: cuy.py:1163
METTester::endJob
virtual void endJob()
Definition: METTester.cc:752
METTester::METTester
METTester(const edm::ParameterSet &)
Definition: METTester.cc:32
reco::GenMET::NeutralHadEtFraction
double NeutralHadEtFraction() const
Definition: GenMET.h:45
METTester::isGoodTrack
bool isGoodTrack(const reco::TrackRef, float d0corr)
Definition: METTester.cc:788
reco::CaloMET::emEtInHF
double emEtInHF() const
Definition: CaloMET.h:59
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
reco::PFMET::neutralHadronEt
double neutralHadronEt() const
Definition: PFMET.h:33
reco::GenMET::ChargedHadEtFraction
double ChargedHadEtFraction() const
Definition: GenMET.h:51
reco::LeafCandidate::pt
virtual float pt() const GCC11_FINAL
transverse momentum
Definition: LeafCandidate.h:153
reco::CaloMET::hadEtInHB
double hadEtInHB() const
Definition: CaloMET.h:47
reco::CaloMET::emEtFraction
double emEtFraction() const
Definition: CaloMET.h:45
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
reco::PFMET::chargedHadronEt
double chargedHadronEt() const
Definition: PFMET.h:39
edm::Run
Definition: Run.h:41
GOODCOLL_filter_cfg.cut
tuple cut
Definition: GOODCOLL_filter_cfg.py:65
Generated for CMSSW Reference Manual by doxygen 1.8.5