CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PlotMakerReco.cc
Go to the documentation of this file.
1 /* \class PlotMakerReco
2 *
3 * Class to produce some plots of Off-line variables in the TriggerValidation Code
4 *
5 * Author: Massimiliano Chiorboli Date: September 2007
6 // Maurizio Pierini
7 // Maria Spiropulu
8 *
9 */
10 #include "HLTriggerOffline/SUSYBSM/interface/PlotMakerReco.h"
11 #include "FWCore/MessageLogger/interface/MessageLogger.h"
12 
13 
14 #include "FWCore/ParameterSet/interface/ParameterSet.h"
15 #include "TDirectory.h"
16 
17 #include "HLTriggerOffline/SUSYBSM/interface/PtSorter.h"
18 
19 
20 using namespace edm;
21 using namespace reco;
22 using namespace std;
23 using namespace l1extra;
24 
25 PlotMakerReco::PlotMakerReco(const edm::ParameterSet& PlotMakerRecoInput, edm::ConsumesCollector&& iC)
26 {
27  m_electronSrc = iC.consumes<GsfElectronCollection>(PlotMakerRecoInput.getParameter<string>("electrons"));
28  m_muonSrc = iC.consumes<MuonCollection>(PlotMakerRecoInput.getParameter<string>("muons"));
29  m_jetsSrc = iC.consumes<CaloJetCollection>(PlotMakerRecoInput.getParameter<string>("jets"));
30  m_photonProducerSrc = PlotMakerRecoInput.getParameter<string>("photonProducer");
31  m_photonSrc = PlotMakerRecoInput.getParameter<string>("photons");
32  m_photon_token_ = iC.consumes<PhotonCollection>(edm::InputTag(m_photonProducerSrc,m_photonSrc));
33  m_calometSrc = iC.consumes<CaloMETCollection>(PlotMakerRecoInput.getParameter<string>("calomet"));
34 
35  def_electronPtMin = PlotMakerRecoInput.getParameter<double>("def_electronPtMin");
36  def_muonPtMin = PlotMakerRecoInput.getParameter<double>("def_muonPtMin");
37  def_jetPtMin = PlotMakerRecoInput.getParameter<double>("def_jetPtMin");
38  def_photonPtMin = PlotMakerRecoInput.getParameter<double>("def_photonPtMin");
39 
40  binFactor = PlotMakerRecoInput.getParameter<int>("BinFactor");
41 
42  dirname_ = PlotMakerRecoInput.getParameter<std::string>("dirname");
43 
44  edm::LogInfo("PlotMakerRecoObjects") << endl;
45  edm::LogInfo("PlotMakerRecoObjects") << "Object definition cuts:" << endl;
46  edm::LogInfo("PlotMakerRecoObjects") << " def_electronPtMin " << def_electronPtMin << endl;
47  edm::LogInfo("PlotMakerRecoObjects") << " def_muonPtMin " << def_muonPtMin << endl;
48  edm::LogInfo("PlotMakerRecoObjects") << " def_jetPtMin " << def_jetPtMin << endl;
49  edm::LogInfo("PlotMakerRecoObjects") << " def_photonPtMin " << def_photonPtMin << endl;
50 
51 
52 }
53 
54 void PlotMakerReco::fillPlots(const edm::Event& iEvent)
55 {
56  this->handleObjects(iEvent);
57 
58 
59 
60  //**********************
61  // Fill the Reco Object Histos
62  //**********************
63  //**********************
64  // Fill the Jet Histos
65  //**********************
66 
67  int nJets = 0;
68  std::vector<double> diJetInvMass;
69  for(unsigned int i=0; i<theCaloJetCollection.size(); i++) {
70  if(theCaloJetCollection[i].pt() > def_jetPtMin ) {
71  nJets++;
72  for(unsigned int j=i+1; j<theCaloJetCollection.size(); j++) {
73  if(theCaloJetCollection[j].pt() > def_jetPtMin ) {
74  diJetInvMass.push_back(invariantMass(&theCaloJetCollection[i],&theCaloJetCollection[j]));
75  }
76  }
77  }
78  }
79 
80  hJetMult->Fill(nJets);
81  for(unsigned int j=0; j<diJetInvMass.size(); j++) {hDiJetInvMass->Fill(diJetInvMass[j]);}
82  if(theCaloJetCollection.size()>0) {
83  hJet1Pt->Fill(theCaloJetCollection[0].pt());
84  hJet1Eta->Fill(theCaloJetCollection[0].eta());
85  hJet1Phi->Fill(theCaloJetCollection[0].phi());
86  }
87  if(theCaloJetCollection.size()>1) {
88  hJet2Pt->Fill(theCaloJetCollection[1].pt());
89  hJet2Eta->Fill(theCaloJetCollection[1].eta());
90  hJet2Phi->Fill(theCaloJetCollection[1].phi());
91  }
92 
93  for(unsigned int i=0; i<l1bits_->size(); i++) {
94  if(l1bits_->at(i)) {
95  hJetMultAfterL1[i]->Fill(nJets);
96  for(unsigned int j=0; j<diJetInvMass.size(); j++) {hDiJetInvMassAfterL1[i]->Fill(diJetInvMass[j]);}
97  if(theCaloJetCollection.size()>0) {
98  hJet1PtAfterL1[i]->Fill(theCaloJetCollection[0].pt());
99  hJet1EtaAfterL1[i]->Fill(theCaloJetCollection[0].eta());
100  hJet1PhiAfterL1[i]->Fill(theCaloJetCollection[0].phi());
101  }
102  if(theCaloJetCollection.size()>1) {
103  hJet2PtAfterL1[i]->Fill(theCaloJetCollection[1].pt());
104  hJet2EtaAfterL1[i]->Fill(theCaloJetCollection[1].eta());
105  hJet2PhiAfterL1[i]->Fill(theCaloJetCollection[1].phi());
106  }
107  }
108  }
109  for(unsigned int i=0; i<hltbits_->size(); i++) {
110  if(hltbits_->at(i)) {
111  hJetMultAfterHLT[i]->Fill(nJets);
112  for(unsigned int j=0; j<diJetInvMass.size(); j++) {hDiJetInvMassAfterHLT[i]->Fill(diJetInvMass[j]);}
113  if(theCaloJetCollection.size()>0) {
114  hJet1PtAfterHLT[i]->Fill(theCaloJetCollection[0].pt());
115  hJet1EtaAfterHLT[i]->Fill(theCaloJetCollection[0].eta());
116  hJet1PhiAfterHLT[i]->Fill(theCaloJetCollection[0].phi());
117  }
118  if(theCaloJetCollection.size()>1) {
119  hJet2PtAfterHLT[i]->Fill(theCaloJetCollection[1].pt());
120  hJet2EtaAfterHLT[i]->Fill(theCaloJetCollection[1].eta());
121  hJet2PhiAfterHLT[i]->Fill(theCaloJetCollection[1].phi());
122  }
123  }
124  }
125 
126 
127  //**********************
128  // Fill the Electron Histos
129  //**********************
130 
131  int nElectrons = 0;
132  std::vector<double> diElecInvMass;
133  for(unsigned int i=0; i<theElectronCollection.size(); i++) {
134  if(theElectronCollection[i].pt() > def_electronPtMin ) {
135  nElectrons++;
136  for(unsigned int j=i+1; j<theElectronCollection.size(); j++) {
137  if(theElectronCollection[j].pt() > def_electronPtMin ) {
138  if(theElectronCollection[i].charge()*theElectronCollection[j].charge() < 0)
139  diElecInvMass.push_back(invariantMass(&theElectronCollection[i],&theElectronCollection[j]));
140  }
141  }
142  }
143  }
144 
145  hElecMult->Fill(nElectrons);
146  for(unsigned int j=0; j<diElecInvMass.size(); j++) {hDiElecInvMass->Fill(diElecInvMass[j]);}
147  if(theElectronCollection.size()>0) {
148  hElec1Pt->Fill(theElectronCollection[0].pt());
149  hElec1Eta->Fill(theElectronCollection[0].eta());
150  hElec1Phi->Fill(theElectronCollection[0].phi());
151  }
152  if(theElectronCollection.size()>1) {
153  hElec2Pt->Fill(theElectronCollection[1].pt());
154  hElec2Eta->Fill(theElectronCollection[1].eta());
155  hElec2Phi->Fill(theElectronCollection[1].phi());
156  }
157 
158  for(unsigned int i=0; i<l1bits_->size(); i++) {
159  if(l1bits_->at(i)) {
160  hElecMultAfterL1[i]->Fill(nElectrons);
161  for(unsigned int j=0; j<diElecInvMass.size(); j++) {hDiElecInvMassAfterL1[i]->Fill(diElecInvMass[j]);}
162  if(theElectronCollection.size()>0) {
163  hElec1PtAfterL1[i]->Fill(theElectronCollection[0].pt());
164  hElec1EtaAfterL1[i]->Fill(theElectronCollection[0].eta());
165  hElec1PhiAfterL1[i]->Fill(theElectronCollection[0].phi());
166  }
167  if(theElectronCollection.size()>1) {
168  hElec2PtAfterL1[i]->Fill(theElectronCollection[1].pt());
169  hElec2EtaAfterL1[i]->Fill(theElectronCollection[1].eta());
170  hElec2PhiAfterL1[i]->Fill(theElectronCollection[1].phi());
171  }
172  }
173  }
174  for(unsigned int i=0; i<hltbits_->size(); i++) {
175  if(hltbits_->at(i)) {
176  hElecMultAfterHLT[i]->Fill(nElectrons);
177  for(unsigned int j=0; j<diElecInvMass.size(); j++) {hDiElecInvMassAfterHLT[i]->Fill(diElecInvMass[j]);}
178  if(theElectronCollection.size()>0) {
179  hElec1PtAfterHLT[i]->Fill(theElectronCollection[0].pt());
180  hElec1EtaAfterHLT[i]->Fill(theElectronCollection[0].eta());
181  hElec1PhiAfterHLT[i]->Fill(theElectronCollection[0].phi());
182  }
183  if(theElectronCollection.size()>1) {
184  hElec2PtAfterHLT[i]->Fill(theElectronCollection[1].pt());
185  hElec2EtaAfterHLT[i]->Fill(theElectronCollection[1].eta());
186  hElec2PhiAfterHLT[i]->Fill(theElectronCollection[1].phi());
187  }
188  }
189  }
190 
191 
192  //**********************
193  // Fill the Muon Histos
194  //**********************
195 
196  int nMuons = 0;
197  std::vector<double> diMuonInvMass;
198  for(unsigned int i=0; i<theMuonCollection.size(); i++) {
199  if(theMuonCollection[i].pt() > def_muonPtMin ) {
200  nMuons++;
201  for(unsigned int j=i+1; j<theMuonCollection.size(); j++) {
202  if(theMuonCollection[j].pt() > def_muonPtMin ) {
203  if(theMuonCollection[i].charge()*theMuonCollection[j].charge() < 0)
204  diMuonInvMass.push_back(invariantMass(&theMuonCollection[i],&theMuonCollection[j]));
205  }
206  }
207  }
208  }
209 
210 
211  hMuonMult->Fill(nMuons);
212  for(unsigned int j=0; j<diMuonInvMass.size(); j++) {hDiMuonInvMass->Fill(diMuonInvMass[j]);}
213  if(theMuonCollection.size()>0) {
214  hMuon1Pt->Fill(theMuonCollection[0].pt());
215  hMuon1Eta->Fill(theMuonCollection[0].eta());
216  hMuon1Phi->Fill(theMuonCollection[0].phi());
217  }
218  if(theMuonCollection.size()>1) {
219  hMuon2Pt->Fill(theMuonCollection[1].pt());
220  hMuon2Eta->Fill(theMuonCollection[1].eta());
221  hMuon2Phi->Fill(theMuonCollection[1].phi());
222  }
223 
224  for(unsigned int i=0; i<l1bits_->size(); i++) {
225  if(l1bits_->at(i)) {
226  hMuonMultAfterL1[i]->Fill(nMuons);
227  for(unsigned int j=0; j<diMuonInvMass.size(); j++) {hDiMuonInvMassAfterL1[i]->Fill(diMuonInvMass[j]);}
228  if(theMuonCollection.size()>0) {
229  hMuon1PtAfterL1[i]->Fill(theMuonCollection[0].pt());
230  hMuon1EtaAfterL1[i]->Fill(theMuonCollection[0].eta());
231  hMuon1PhiAfterL1[i]->Fill(theMuonCollection[0].phi());
232  }
233  if(theMuonCollection.size()>1) {
234  hMuon2PtAfterL1[i]->Fill(theMuonCollection[1].pt());
235  hMuon2EtaAfterL1[i]->Fill(theMuonCollection[1].eta());
236  hMuon2PhiAfterL1[i]->Fill(theMuonCollection[1].phi());
237  }
238  }
239  }
240  for(unsigned int i=0; i<hltbits_->size(); i++) {
241  if(hltbits_->at(i)) {
242  hMuonMultAfterHLT[i]->Fill(nMuons);
243  for(unsigned int j=0; j<diMuonInvMass.size(); j++) {hDiMuonInvMassAfterHLT[i]->Fill(diMuonInvMass[j]);}
244  if(theMuonCollection.size()>0) {
245  hMuon1PtAfterHLT[i]->Fill(theMuonCollection[0].pt());
246  hMuon1EtaAfterHLT[i]->Fill(theMuonCollection[0].eta());
247  hMuon1PhiAfterHLT[i]->Fill(theMuonCollection[0].phi());
248  }
249  if(theMuonCollection.size()>1) {
250  hMuon2PtAfterHLT[i]->Fill(theMuonCollection[1].pt());
251  hMuon2EtaAfterHLT[i]->Fill(theMuonCollection[1].eta());
252  hMuon2PhiAfterHLT[i]->Fill(theMuonCollection[1].phi());
253  }
254  }
255  }
256 
257  //**********************
258  // Fill the Photon Histos
259  //**********************
260 
261  int nPhotons = 0;
262  std::vector<double> diPhotonInvMass;
263  for(unsigned int i=0; i<thePhotonCollection.size(); i++) {
264  if(thePhotonCollection[i].pt() > def_photonPtMin ) {
265  nPhotons++;
266  for(unsigned int j=i+1; j<thePhotonCollection.size(); j++) {
267  if(thePhotonCollection[j].pt() > def_photonPtMin ) {
268  diPhotonInvMass.push_back(invariantMass(&thePhotonCollection[i],&thePhotonCollection[j]));
269  }
270  }
271  }
272  }
273 
274  hPhotonMult->Fill(nPhotons);
275  for(unsigned int j=0; j<diPhotonInvMass.size(); j++) {hDiPhotonInvMass->Fill(diPhotonInvMass[j]);}
276  if(thePhotonCollection.size()>0) {
277  hPhoton1Pt->Fill(thePhotonCollection[0].et());
278  hPhoton1Eta->Fill(thePhotonCollection[0].eta());
279  hPhoton1Phi->Fill(thePhotonCollection[0].phi());
280  }
281  if(thePhotonCollection.size()>1) {
282  hPhoton2Pt->Fill(thePhotonCollection[1].et());
283  hPhoton2Eta->Fill(thePhotonCollection[1].eta());
284  hPhoton2Phi->Fill(thePhotonCollection[1].phi());
285  }
286  for(unsigned int i=0; i<l1bits_->size(); i++) {
287  if(l1bits_->at(i)) {
288  hPhotonMultAfterL1[i]->Fill(nPhotons);
289  for(unsigned int j=0; j<diPhotonInvMass.size(); j++) {hDiPhotonInvMassAfterL1[i]->Fill(diPhotonInvMass[j]);}
290  if(thePhotonCollection.size()>0) {
291  hPhoton1PtAfterL1[i]->Fill(thePhotonCollection[0].et());
292  hPhoton1EtaAfterL1[i]->Fill(thePhotonCollection[0].eta());
293  hPhoton1PhiAfterL1[i]->Fill(thePhotonCollection[0].phi());
294  }
295  if(thePhotonCollection.size()>1) {
296  hPhoton2PtAfterL1[i]->Fill(thePhotonCollection[1].et());
297  hPhoton2EtaAfterL1[i]->Fill(thePhotonCollection[1].eta());
298  hPhoton2PhiAfterL1[i]->Fill(thePhotonCollection[1].phi());
299  }
300  }
301  }
302  for(unsigned int i=0; i<hltbits_->size(); i++) {
303  if(hltbits_->at(i)) {
304  hPhotonMultAfterHLT[i]->Fill(nPhotons);
305  for(unsigned int j=0; j<diPhotonInvMass.size(); j++) {hDiPhotonInvMassAfterHLT[i]->Fill(diPhotonInvMass[j]);}
306  if(thePhotonCollection.size()>0) {
307  hPhoton1PtAfterHLT[i]->Fill(thePhotonCollection[0].et());
308  hPhoton1EtaAfterHLT[i]->Fill(thePhotonCollection[0].eta());
309  hPhoton1PhiAfterHLT[i]->Fill(thePhotonCollection[0].phi());
310  }
311  if(thePhotonCollection.size()>1) {
312  hPhoton2PtAfterHLT[i]->Fill(thePhotonCollection[1].et());
313  hPhoton2EtaAfterHLT[i]->Fill(thePhotonCollection[1].eta());
314  hPhoton2PhiAfterHLT[i]->Fill(thePhotonCollection[1].phi());
315  }
316  }
317  }
318 
319 
320  //**********************
321  // Fill the MET Histos
322  //**********************
323 
324  hMET->Fill((theCaloMETCollection.front()).pt());
325  hMETx->Fill((theCaloMETCollection.front()).px());
326  hMETy->Fill((theCaloMETCollection.front()).py());
327  hMETphi->Fill((theCaloMETCollection.front()).phi());
328  hSumEt->Fill((theCaloMETCollection.front()).sumEt());
329  double RecoMetSig = (theCaloMETCollection.front()).pt() / sqrt( (theCaloMETCollection.front()).sumEt() );
330  hMETSignificance->Fill(RecoMetSig);
331  for(unsigned int i=0; i<l1bits_->size(); i++) {
332  if(l1bits_->at(i)) {
333  hMETAfterL1[i]->Fill((theCaloMETCollection.front()).pt());
334  hMETxAfterL1[i]->Fill((theCaloMETCollection.front()).px());
335  hMETyAfterL1[i]->Fill((theCaloMETCollection.front()).py());
336  hMETphiAfterL1[i]->Fill((theCaloMETCollection.front()).phi());
337  hSumEtAfterL1[i]->Fill((theCaloMETCollection.front()).sumEt());
338  hMETSignificanceAfterL1[i]->Fill(RecoMetSig);
339  }
340  }
341  for(unsigned int i=0; i<hltbits_->size(); i++) {
342  if(hltbits_->at(i)) {
343  hMETAfterHLT[i]->Fill((theCaloMETCollection.front()).pt());
344  hMETxAfterHLT[i]->Fill((theCaloMETCollection.front()).px());
345  hMETyAfterHLT[i]->Fill((theCaloMETCollection.front()).py());
346  hMETphiAfterHLT[i]->Fill((theCaloMETCollection.front()).phi());
347  hSumEtAfterHLT[i]->Fill((theCaloMETCollection.front()).sumEt());
348  hMETSignificanceAfterHLT[i]->Fill(RecoMetSig);
349  }
350  }
351 
352 
353 }
354 
355 
356 
357 
358 void PlotMakerReco::bookHistos(DQMStore * dbe_, std::vector<int>* l1bits, std::vector<int>* hltbits,
359  std::vector<std::string>* l1Names_, std::vector<std::string>* hlNames_)
360 {
361 
362  this->setBits(l1bits, hltbits);
363 
364 
365  //******************
366  //Book histos Reco Objects
367  //******************
368 
369  //******************
370  //Book Jets
371  //******************
372 
373  dbe_->setCurrentFolder(dirname_+"/RecoJets/General");
374  hJetMult = dbe_->book1D("JetMult", "Jet Multiplicity", 10, 0, 10);
375  hJet1Pt = dbe_->book1D("Jet1Pt", "Jet 1 Pt ", 100, 0, 1000);
376  hJet2Pt = dbe_->book1D("Jet2Pt", "Jet 2 Pt ", 100, 0, 1000);
377  hJet1Eta = dbe_->book1D("Jet1Eta", "Jet 1 Eta ", 10*binFactor, -3 , 3 );
378  hJet2Eta = dbe_->book1D("Jet2Eta", "Jet 2 Eta ", 10*binFactor, -3 , 3 );
379  hJet1Phi = dbe_->book1D("Jet1Phi", "Jet 1 Phi ", 10*binFactor, -3.2 , 3.2 );
380  hJet2Phi = dbe_->book1D("Jet2Phi", "Jet 2 Phi ", 10*binFactor, -3.2 , 3.2 );
381 
382  hDiJetInvMass = dbe_->book1D("DiJetInvMass", "DiJet Invariant Mass", 100*binFactor, 0, 1000);
383 
384 
385  dbe_->setCurrentFolder(dirname_+"/RecoJets/L1");
386  for(unsigned int i=0; i<l1bits_->size(); i++){
387  myHistoName = "JetMult_" + (*l1Names_)[i];
388  myHistoTitle = "Jet Multiplicity for L1 path " + (*l1Names_)[i];
389  hJetMultAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
390  myHistoName = "Jet1Pt_" + (*l1Names_)[i];
391  myHistoTitle = "Jet 1 Pt for L1 path " + (*l1Names_)[i];
392  hJet1PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 1000));
393  myHistoName = "Jet2Pt_" + (*l1Names_)[i];
394  myHistoTitle = "Jet 2 Pt for L1 path " + (*l1Names_)[i];
395  hJet2PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 1000));
396  myHistoName = "Jet1Eta_" + (*l1Names_)[i];
397  myHistoTitle = "Jet 1 Eta for L1 path " + (*l1Names_)[i];
398  hJet1EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
399  myHistoName = "Jet2Eta_" + (*l1Names_)[i];
400  myHistoTitle = "Jet 2 Eta for L1 path " + (*l1Names_)[i];
401  hJet2EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
402  myHistoName = "Jet1Phi_" + (*l1Names_)[i];
403  myHistoTitle = "Jet 1 Phi for L1 path " + (*l1Names_)[i];
404  hJet1PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
405  myHistoName = "Jet2Phi_" + (*l1Names_)[i];
406  myHistoTitle = "Jet 2 Phi for L1 path " + (*l1Names_)[i];
407  hJet2PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
408 
409  myHistoName = "DiJetInvMass_" + (*l1Names_)[i];
410  myHistoTitle = "DiJet Invariant Mass for L1 path " + (*l1Names_)[i];
411  hDiJetInvMassAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
412 
413  }
414 
415  dbe_->setCurrentFolder(dirname_+"/RecoJets/HLT");
416  for(unsigned int i=0; i<hltbits_->size(); i++){
417  myHistoName = "JetMult_" + (*hlNames_)[i];
418  myHistoTitle = "Jet Multiplicity for HLT path " + (*hlNames_)[i];
419  hJetMultAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
420  myHistoName = "Jet1Pt_" + (*hlNames_)[i];
421  myHistoTitle = "Jet 1 Pt for HLT path " + (*hlNames_)[i];
422  hJet1PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 1000));
423  myHistoName = "Jet2Pt_" + (*hlNames_)[i];
424  myHistoTitle = "Jet 2 Pt for HLT path " + (*hlNames_)[i];
425  hJet2PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 1000));
426  myHistoName = "Jet1Eta_" + (*hlNames_)[i];
427  myHistoTitle = "Jet 1 Eta for HLT path " + (*hlNames_)[i];
428  hJet1EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
429  myHistoName = "Jet2Eta_" + (*hlNames_)[i];
430  myHistoTitle = "Jet 2 Eta for HLT path " + (*hlNames_)[i];
431  hJet2EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
432  myHistoName = "Jet1Phi_" + (*hlNames_)[i];
433  myHistoTitle = "Jet 1 Phi for HLT path " + (*hlNames_)[i];
434  hJet1PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
435  myHistoName = "Jet2Phi_" + (*hlNames_)[i];
436  myHistoTitle = "Jet 2 Phi for HLT path " + (*hlNames_)[i];
437  hJet2PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
438 
439  myHistoName = "DiJetInvMass_" + (*hlNames_)[i];
440  myHistoTitle = "DiJet Invariant Mass for HLT path " + (*hlNames_)[i];
441  hDiJetInvMassAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
442 
443  }
444  dbe_->setCurrentFolder(dirname_);
445 
446 
447 
448 
449  //******************
450  //Book Electrons
451  //******************
452 
453  dbe_->setCurrentFolder(dirname_+"/RecoElectrons/General");
454  hElecMult = dbe_->book1D("ElecMult", "Elec Multiplicity", 10, 0, 10);
455  hElec1Pt = dbe_->book1D("Elec1Pt", "Elec 1 Pt ", 100, 0, 100);
456  hElec2Pt = dbe_->book1D("Elec2Pt", "Elec 2 Pt ", 100, 0, 100);
457  hElec1Eta = dbe_->book1D("Elec1Eta", "Elec 1 Eta ", 10*binFactor, -3, 3);
458  hElec2Eta = dbe_->book1D("Elec2Eta", "Elec 2 Eta ", 10*binFactor, -3, 3);
459  hElec1Phi = dbe_->book1D("Elec1Phi", "Elec 1 Phi ", 10*binFactor, -3.2, 3.2);
460  hElec2Phi = dbe_->book1D("Elec2Phi", "Elec 2 Phi ", 10*binFactor, -3.2, 3.2);
461 
462  hDiElecInvMass = dbe_->book1D("DiElecInvMass", "DiElec Invariant Mass", 100*binFactor, 0, 1000);
463 
464  dbe_->setCurrentFolder(dirname_+"/RecoElectrons/L1");
465  for(unsigned int i=0; i<l1bits_->size(); i++){
466  myHistoName = "ElecMult_" + (*l1Names_)[i];
467  myHistoTitle = "Elec Multiplicity for L1 path " + (*l1Names_)[i];
468  hElecMultAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
469  myHistoName = "Elec1Pt_" + (*l1Names_)[i];
470  myHistoTitle = "Elec 1 Pt for L1 path " + (*l1Names_)[i];
471  hElec1PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
472  myHistoName = "Elec2Pt_" + (*l1Names_)[i];
473  myHistoTitle = "Elec 2 Pt for L1 path " + (*l1Names_)[i];
474  hElec2PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
475  myHistoName = "Elec1Eta_" + (*l1Names_)[i];
476  myHistoTitle = "Elec 1 Eta for L1 path " + (*l1Names_)[i];
477  hElec1EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
478  myHistoName = "Elec2Eta_" + (*l1Names_)[i];
479  myHistoTitle = "Elec 2 Eta for L1 path " + (*l1Names_)[i];
480  hElec2EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
481  myHistoName = "Elec1Phi_" + (*l1Names_)[i];
482  myHistoTitle = "Elec 1 Phi for L1 path " + (*l1Names_)[i];
483  hElec1PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
484  myHistoName = "Elec2Phi_" + (*l1Names_)[i];
485  myHistoTitle = "Elec 2 Phi for L1 path " + (*l1Names_)[i];
486  hElec2PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
487 
488  myHistoName = "DiElecInvMass_" + (*l1Names_)[i];
489  myHistoTitle = "DiElec Invariant Mass for L1 path " + (*l1Names_)[i];
490  hDiElecInvMassAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
491 
492  }
493 
494  dbe_->setCurrentFolder(dirname_+"/RecoElectrons/HLT");
495  for(unsigned int i=0; i<hltbits_->size(); i++){
496  myHistoName = "ElecMult_" + (*hlNames_)[i];
497  myHistoTitle = "Elec Multiplicity for HLT path " + (*hlNames_)[i];
498  hElecMultAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
499  myHistoName = "Elec1Pt_" + (*hlNames_)[i];
500  myHistoTitle = "Elec 1 Pt for HLT path " + (*hlNames_)[i];
501  hElec1PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
502  myHistoName = "Elec2Pt_" + (*hlNames_)[i];
503  myHistoTitle = "Elec 2 Pt for HLT path " + (*hlNames_)[i];
504  hElec2PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
505  myHistoName = "Elec1Eta_" + (*hlNames_)[i];
506  myHistoTitle = "Elec 1 Eta for HLT path " + (*hlNames_)[i];
507  hElec1EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
508  myHistoName = "Elec2Eta_" + (*hlNames_)[i];
509  myHistoTitle = "Elec 2 Eta for HLT path " + (*hlNames_)[i];
510  hElec2EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
511  myHistoName = "Elec1Phi_" + (*hlNames_)[i];
512  myHistoTitle = "Elec 1 Phi for HLT path " + (*hlNames_)[i];
513  hElec1PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
514  myHistoName = "Elec2Phi_" + (*hlNames_)[i];
515  myHistoTitle = "Elec 2 Phi for HLT path " + (*hlNames_)[i];
516  hElec2PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
517 
518  myHistoName = "DiElecInvMass_" + (*hlNames_)[i];
519  myHistoTitle = "DiElec Invariant Mass for HLT path " + (*hlNames_)[i];
520  hDiElecInvMassAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
521 
522  }
523  dbe_->setCurrentFolder(dirname_);
524 
525 
526  //******************
527  //Book Muons
528  //******************
529 
530  dbe_->setCurrentFolder(dirname_+"/RecoMuons/General");
531  hMuonMult = dbe_->book1D("MuonMult", "Muon Multiplicity", 10, 0, 10);
532  hMuon1Pt = dbe_->book1D("Muon1Pt", "Muon 1 Pt ", 100, 0, 100);
533  hMuon2Pt = dbe_->book1D("Muon2Pt", "Muon 2 Pt ", 100, 0, 100);
534  hMuon1Eta = dbe_->book1D("Muon1Eta", "Muon 1 Eta ", 10*binFactor, -3, 3);
535  hMuon2Eta = dbe_->book1D("Muon2Eta", "Muon 2 Eta ", 10*binFactor, -3, 3);
536  hMuon1Phi = dbe_->book1D("Muon1Phi", "Muon 1 Phi ", 10*binFactor, -3.2, 3.2);
537  hMuon2Phi = dbe_->book1D("Muon2Phi", "Muon 2 Phi ", 10*binFactor, -3.2, 3.2);
538 
539  hDiMuonInvMass = dbe_->book1D("DiMuonInvMass", "DiMuon Invariant Mass", 100*binFactor, 0, 1000);
540 
541  dbe_->setCurrentFolder(dirname_+"/RecoMuons/L1");
542  for(unsigned int i=0; i<l1bits_->size(); i++){
543  myHistoName = "MuonMult_" + (*l1Names_)[i];
544  myHistoTitle = "Muon Multiplicity for L1 path " + (*l1Names_)[i];
545  hMuonMultAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
546  myHistoName = "Muon1Pt_" + (*l1Names_)[i];
547  myHistoTitle = "Muon 1 Pt for L1 path " + (*l1Names_)[i];
548  hMuon1PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
549  myHistoName = "Muon2Pt_" + (*l1Names_)[i];
550  myHistoTitle = "Muon 2 Pt for L1 path " + (*l1Names_)[i];
551  hMuon2PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
552  myHistoName = "Muon1Eta_" + (*l1Names_)[i];
553  myHistoTitle = "Muon 1 Eta for L1 path " + (*l1Names_)[i];
554  hMuon1EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
555  myHistoName = "Muon2Eta_" + (*l1Names_)[i];
556  myHistoTitle = "Muon 2 Eta for L1 path " + (*l1Names_)[i];
557  hMuon2EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
558  myHistoName = "Muon1Phi_" + (*l1Names_)[i];
559  myHistoTitle = "Muon 1 Phi for L1 path " + (*l1Names_)[i];
560  hMuon1PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
561  myHistoName = "Muon2Phi_" + (*l1Names_)[i];
562  myHistoTitle = "Muon 2 Phi for L1 path " + (*l1Names_)[i];
563  hMuon2PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
564 
565  myHistoName = "DiMuonInvMass_" + (*l1Names_)[i];
566  myHistoTitle = "DiMuon Invariant Mass for L1 path " + (*l1Names_)[i];
567  hDiMuonInvMassAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
568 
569  }
570 
571  dbe_->setCurrentFolder(dirname_+"/RecoMuons/HLT");
572  for(unsigned int i=0; i<hltbits_->size(); i++){
573  myHistoName = "MuonMult_" + (*hlNames_)[i];
574  myHistoTitle = "Muon Multiplicity for HLT path " + (*hlNames_)[i];
575  hMuonMultAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
576  myHistoName = "Muon1Pt_" + (*hlNames_)[i];
577  myHistoTitle = "Muon 1 Pt for HLT path " + (*hlNames_)[i];
578  hMuon1PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
579  myHistoName = "Muon2Pt_" + (*hlNames_)[i];
580  myHistoTitle = "Muon 2 Pt for HLT path " + (*hlNames_)[i];
581  hMuon2PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
582  myHistoName = "Muon1Eta_" + (*hlNames_)[i];
583  myHistoTitle = "Muon 1 Eta for HLT path " + (*hlNames_)[i];
584  hMuon1EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
585  myHistoName = "Muon2Eta_" + (*hlNames_)[i];
586  myHistoTitle = "Muon 2 Eta for HLT path " + (*hlNames_)[i];
587  hMuon2EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
588  myHistoName = "Muon1Phi_" + (*hlNames_)[i];
589  myHistoTitle = "Muon 1 Phi for HLT path " + (*hlNames_)[i];
590  hMuon1PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
591  myHistoName = "Muon2Phi_" + (*hlNames_)[i];
592  myHistoTitle = "Muon 2 Phi for HLT path " + (*hlNames_)[i];
593  hMuon2PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
594 
595  myHistoName = "DiMuonInvMass_" + (*hlNames_)[i];
596  myHistoTitle = "DiMuon Invariant Mass for HLT path " + (*hlNames_)[i];
597  hDiMuonInvMassAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
598 
599  }
600  dbe_->setCurrentFolder(dirname_);
601 
602 
603 
604  //******************
605  //Book Photons
606  //******************
607 
608  dbe_->setCurrentFolder(dirname_+"/RecoPhotons/General");
609  hPhotonMult = dbe_->book1D("PhotonMult", "Photon Multiplicity", 10, 0, 10);
610  hPhoton1Pt = dbe_->book1D("Photon1Pt", "Photon 1 Pt ", 100, 0, 100);
611  hPhoton2Pt = dbe_->book1D("Photon2Pt", "Photon 2 Pt ", 100, 0, 100);
612  hPhoton1Eta = dbe_->book1D("Photon1Eta", "Photon 1 Eta ", 10*binFactor, -3, 3);
613  hPhoton2Eta = dbe_->book1D("Photon2Eta", "Photon 2 Eta ", 10*binFactor, -3, 3);
614  hPhoton1Phi = dbe_->book1D("Photon1Phi", "Photon 1 Phi ", 10*binFactor, -3.2, 3.2);
615  hPhoton2Phi = dbe_->book1D("Photon2Phi", "Photon 2 Phi ", 10*binFactor, -3.2, 3.2);
616 
617  hDiPhotonInvMass = dbe_->book1D("DiPhotonInvMass", "DiPhoton Invariant Mass", 100*binFactor, 0, 1000);
618 
619  dbe_->setCurrentFolder(dirname_+"/RecoPhotons/L1");
620  for(unsigned int i=0; i<l1bits_->size(); i++){
621  myHistoName = "PhotonMult_" + (*l1Names_)[i];
622  myHistoTitle = "Photon Multiplicity for L1 path " + (*l1Names_)[i];
623  hPhotonMultAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
624  myHistoName = "Photon1Pt_" + (*l1Names_)[i];
625  myHistoTitle = "Photon 1 Pt for L1 path " + (*l1Names_)[i];
626  hPhoton1PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
627  myHistoName = "Photon2Pt_" + (*l1Names_)[i];
628  myHistoTitle = "Photon 2 Pt for L1 path " + (*l1Names_)[i];
629  hPhoton2PtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
630  myHistoName = "Photon1Eta_" + (*l1Names_)[i];
631  myHistoTitle = "Photon 1 Eta for L1 path " + (*l1Names_)[i];
632  hPhoton1EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
633  myHistoName = "Photon2Eta_" + (*l1Names_)[i];
634  myHistoTitle = "Photon 2 Eta for L1 path " + (*l1Names_)[i];
635  hPhoton2EtaAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
636  myHistoName = "Photon1Phi_" + (*l1Names_)[i];
637  myHistoTitle = "Photon 1 Phi for L1 path " + (*l1Names_)[i];
638  hPhoton1PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
639  myHistoName = "Photon2Phi_" + (*l1Names_)[i];
640  myHistoTitle = "Photon 2 Phi for L1 path " + (*l1Names_)[i];
641  hPhoton2PhiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
642 
643  myHistoName = "DiPhotonInvMass_" + (*l1Names_)[i];
644  myHistoTitle = "DiPhoton Invariant Mass for L1 path " + (*l1Names_)[i];
645  hDiPhotonInvMassAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
646 
647  }
648 
649  dbe_->setCurrentFolder(dirname_+"/RecoPhotons/HLT");
650  for(unsigned int i=0; i<hltbits_->size(); i++){
651  myHistoName = "PhotonMult_" + (*hlNames_)[i];
652  myHistoTitle = "Photon Multiplicity for HLT path " + (*hlNames_)[i];
653  hPhotonMultAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10, 0, 10));
654  myHistoName = "Photon1Pt_" + (*hlNames_)[i];
655  myHistoTitle = "Photon 1 Pt for HLT path " + (*hlNames_)[i];
656  hPhoton1PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
657  myHistoName = "Photon2Pt_" + (*hlNames_)[i];
658  myHistoTitle = "Photon 2 Pt for HLT path " + (*hlNames_)[i];
659  hPhoton2PtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100, 0, 100));
660  myHistoName = "Photon1Eta_" + (*hlNames_)[i];
661  myHistoTitle = "Photon 1 Eta for HLT path " + (*hlNames_)[i];
662  hPhoton1EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
663  myHistoName = "Photon2Eta_" + (*hlNames_)[i];
664  myHistoTitle = "Photon 2 Eta for HLT path " + (*hlNames_)[i];
665  hPhoton2EtaAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3, 3));
666  myHistoName = "Photon1Phi_" + (*hlNames_)[i];
667  myHistoTitle = "Photon 1 Phi for HLT path " + (*hlNames_)[i];
668  hPhoton1PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
669  myHistoName = "Photon2Phi_" + (*hlNames_)[i];
670  myHistoTitle = "Photon 2 Phi for HLT path " + (*hlNames_)[i];
671  hPhoton2PhiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
672 
673  myHistoName = "DiPhotonInvMass_" + (*hlNames_)[i];
674  myHistoTitle = "DiPhoton Invariant Mass for HLT path " + (*hlNames_)[i];
675  hDiPhotonInvMassAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 100*binFactor, 0, 1000));
676 
677  }
678  dbe_->setCurrentFolder(dirname_);
679 
680 
681 
682  //******************
683  //Book MET
684  //******************
685 
686  dbe_->setCurrentFolder(dirname_+"/RecoMET/General");
687  hMET = dbe_->book1D("MET", "MET", 35, 0, 1050);
688  hMETx = dbe_->book1D("METx", "METx", 35, 0, 1050);
689  hMETy = dbe_->book1D("METy", "METy", 35, 0, 1050);
690  hMETphi = dbe_->book1D("METphi", "METphi", 10*binFactor, -3.2, 3.2);
691  hSumEt = dbe_->book1D("SumEt" , "SumEt", 35, 0, 1050);
692  hMETSignificance = dbe_->book1D("METSignificance", "METSignificance", 100, 0, 100);
693  dbe_->setCurrentFolder(dirname_+"/RecoMET/L1");
694  for(unsigned int i=0; i<l1bits_->size(); i++){
695  myHistoName = "MET_" + (*l1Names_)[i];
696  myHistoTitle = "MET for L1 path " + (*l1Names_)[i];
697  hMETAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
698  myHistoName = "METx_" + (*l1Names_)[i];
699  myHistoTitle = "METx for L1 path " + (*l1Names_)[i];
700  hMETxAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
701  myHistoName = "METy_" + (*l1Names_)[i];
702  myHistoTitle = "METy for L1 path " + (*l1Names_)[i];
703  hMETyAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
704  myHistoName = "METPhi_" + (*l1Names_)[i];
705  myHistoTitle = "METPhi for L1 path " + (*l1Names_)[i];
706  hMETphiAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2));
707  myHistoName = "SumEt_" + (*l1Names_)[i];
708  myHistoTitle = "SumEt for L1 path " + (*l1Names_)[i];
709  hSumEtAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
710  myHistoName = "METSignificance_" + (*l1Names_)[i];
711  myHistoTitle = "METSignificance for L1 path " + (*l1Names_)[i];
712  hMETSignificanceAfterL1.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, 0, 100));
713  }
714 
715  dbe_->setCurrentFolder(dirname_+"/RecoMET/HLT");
716  for(unsigned int i=0; i<hltbits_->size(); i++){
717  myHistoName = "MET_" + (*hlNames_)[i];
718  myHistoTitle = "MET for HLT path " + (*hlNames_)[i];
719  hMETAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
720  myHistoName = "METx_" + (*hlNames_)[i];
721  myHistoTitle = "METx for HLT path " + (*hlNames_)[i];
722  hMETxAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
723  myHistoName = "METy_" + (*hlNames_)[i];
724  myHistoTitle = "METy for HLT path " + (*hlNames_)[i];
725  hMETyAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
726  myHistoName = "METPhi_" + (*hlNames_)[i];
727  myHistoTitle = "METPhi for HLT path " + (*hlNames_)[i];
728  hMETphiAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, -3.2, 3.2 ));
729  myHistoName = "SumEt_" + (*hlNames_)[i];
730  myHistoTitle = "SumEt for HLT path " + (*hlNames_)[i];
731  hSumEtAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 35, 0, 1050));
732  myHistoName = "METSignificance_" + (*hlNames_)[i];
733  myHistoTitle = "METSignificance for HLT path " + (*hlNames_)[i];
734  hMETSignificanceAfterHLT.push_back(dbe_->book1D(myHistoName.c_str(), myHistoTitle.c_str() , 10*binFactor, 0, 100));
735  }
736  dbe_->setCurrentFolder(dirname_);
737 
738 
739 
740 
741 }
742 
743 
744 
745 
746 
747 
748 void PlotMakerReco::handleObjects(const edm::Event& iEvent)
749 {
750 
751 
752  //***********************************************
753  // Get the RECO Objects
754  //***********************************************
755 
756 
757  //Get the electrons
758  Handle<GsfElectronCollection> theElectronCollectionHandle;
759  iEvent.getByToken(m_electronSrc, theElectronCollectionHandle);
760  theElectronCollection = *theElectronCollectionHandle;
761  std::sort(theElectronCollection.begin(), theElectronCollection.end(), PtSorter());
762 
763  //Get the Muons
764  Handle<MuonCollection> theMuonCollectionHandle;
765  iEvent.getByToken(m_muonSrc, theMuonCollectionHandle);
766  theMuonCollection = *theMuonCollectionHandle;
767  std::sort(theMuonCollection.begin(), theMuonCollection.end(), PtSorter());
768 
769  //Get the Photons
770  Handle<PhotonCollection> thePhotonCollectionHandle;
771  iEvent.getByToken(m_photon_token_, thePhotonCollectionHandle);
772  thePhotonCollection = *thePhotonCollectionHandle;
773  std::sort(thePhotonCollection.begin(), thePhotonCollection.end(), PtSorter());
774 
775  //Get the CaloJets
776  Handle<CaloJetCollection> theCaloJetCollectionHandle;
777  iEvent.getByToken(m_jetsSrc, theCaloJetCollectionHandle);
778  theCaloJetCollection = *theCaloJetCollectionHandle;
779  std::sort(theCaloJetCollection.begin(), theCaloJetCollection.end(), PtSorter());
780 
781  //Get the CaloMET
782  Handle<CaloMETCollection> theCaloMETCollectionHandle;
783  iEvent.getByToken(m_calometSrc, theCaloMETCollectionHandle);
784  theCaloMETCollection = *theCaloMETCollectionHandle;
785 }
786 
787 double PlotMakerReco::invariantMass(reco::Candidate* p1, reco::Candidate* p2) {
788  double mass = sqrt( (p1->energy() + p2->energy())*(p1->energy() + p2->energy()) -
789  (p1->px() + p2->px())*(p1->px() + p2->px()) -
790  (p1->py() + p2->py())*(p1->py() + p2->py()) -
791  (p1->pz() + p2->pz())*(p1->pz() + p2->pz()) );
792 
793 
794 // cout << "p1->energy() = " << p1->energy() << " p2->energy() = " << p2->energy() << endl;
795 // cout << "p1->px() = " << p1->px() << " p2->px() = " << p2->px() << endl;
796 // cout << "p1->py() = " << p1->py() << " p2->py() = " << p2->py() << endl;
797 // cout << "p1->pz() = " << p1->pz() << " p2->pz() = " << p2->pz() << endl;
798 // cout << "invmass = " << mass << endl;
799 
800 
801  return mass;
802 }
803 
PlotMakerReco::invariantMass
double invariantMass(reco::Candidate *, reco::Candidate *)
Definition: PlotMakerReco.cc:787
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
i
int i
Definition: DBlmapReader.cc:9
reco::Candidate::energy
virtual double energy() const =0
energy
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:954
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
reco::Candidate::pz
virtual double pz() const =0
z coordinate of momentum vector
eta
T eta() const
Definition: Basic3DVectorLD.h:177
dt_dqm_sourceclient_common_cff.reco
tuple reco
Definition: dt_dqm_sourceclient_common_cff.py:107
DeDxDiscriminatorTools::charge
double charge(const std::vector< uint8_t > &Ampls)
Definition: DeDxDiscriminatorTools.cc:43
reco::GsfElectronCollection
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
Definition: GsfElectronFwd.h:14
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
reco::MuonCollection
std::vector< Muon > MuonCollection
collection of Muon objects
Definition: MuonFwd.h:9
CaloMETCollection
Collection of Calo MET.
iEvent
int iEvent
Definition: GenABIO.cc:230
PlotMakerReco::handleObjects
void handleObjects(const edm::Event &)
Definition: PlotMakerReco.cc:748
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
PlotMakerReco::fillPlots
void fillPlots(const edm::Event &)
Definition: PlotMakerReco.cc:54
j
int j
Definition: DBlmapReader.cc:9
reco::Candidate::py
virtual double py() const =0
y coordinate of momentum vector
p2
double p2[4]
Definition: TauolaWrapper.h:90
dbe_
DQMStore * dbe_
Definition: PFJetBenchmarkAnalyzer.cc:79
reco::Candidate::px
virtual double px() const =0
x coordinate of momentum vector
PlotMakerReco::bookHistos
void bookHistos(DQMStore *, std::vector< int > *, std::vector< int > *, std::vector< std::string > *, std::vector< std::string > *)
Definition: PlotMakerReco.cc:358
reco::PhotonCollection
std::vector< Photon > PhotonCollection
collectin of Photon objects
Definition: PhotonFwd.h:9
p1
double p1[4]
Definition: TauolaWrapper.h:89
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:667
reco::CaloJetCollection
std::vector< CaloJet > CaloJetCollection
collection of CaloJet objects
Definition: CaloJetCollection.h:15
PlotMakerReco::PlotMakerReco
PlotMakerReco(const edm::ParameterSet &objectList, edm::ConsumesCollector &&iC)
Definition: PlotMakerReco.cc:25
phi
Definition: DDAxes.h:10
Generated for CMSSW Reference Manual by doxygen 1.8.5