CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
MuonTestSummary.cc
Go to the documentation of this file.
1 
2 /*
3  * See header file for a description of this class.
4  *
5  * $Date: 2010/02/25 19:57:02 $
6  * $Revision: 1.32 $
7  * \author G. Mila - INFN Torino
8  */
9 
10 
11 #include <DQMOffline/Muon/src/MuonTestSummary.h>
12 
13 // Framework
14 #include <FWCore/Framework/interface/Event.h>
15 #include <FWCore/Framework/interface/EventSetup.h>
16 #include <FWCore/ParameterSet/interface/ParameterSet.h>
17 
18 #include "DQMServices/Core/interface/DQMStore.h"
19 #include "DQMServices/Core/interface/MonitorElement.h"
20 #include "FWCore/MessageLogger/interface/MessageLogger.h"
21 #include "FWCore/Framework/interface/Run.h"
22 
23 #include "DQMOffline/Muon/test/langauFit.C"
24 #include <string>
25 
26 using namespace edm;
27 using namespace std;
28 
29 
30 MuonTestSummary::MuonTestSummary(const edm::ParameterSet& ps){
31 
32  dbe = Service<DQMStore>().operator->();
33 
34  // parameter initialization for kinematics test
35  etaExpected = ps.getParameter<double>("etaExpected");
36  phiExpected = ps.getParameter<double>("phiExpected");
37  chi2Fraction = ps.getParameter<double>("chi2Fraction");
38  chi2Spread = ps.getParameter<double>("chi2Spread");
39  resEtaSpread_tkGlb = ps.getParameter<double>("resEtaSpread_tkGlb");
40  resEtaSpread_glbSta = ps.getParameter<double>("resEtaSpread_glbSta");
41  resPhiSpread_tkGlb = ps.getParameter<double>("resPhiSpread_tkGlb");
42  resPhiSpread_glbSta = ps.getParameter<double>("resPhiSpread_glbSta");
43  resOneOvPSpread_tkGlb = ps.getParameter<double>("resOneOvPSpread_tkGlb");
44  resOneOvPSpread_glbSta = ps.getParameter<double>("resOneOvPSpread_glbSta");
45  pullEtaSpread = ps.getParameter<double>("pullEtaSpread");
46  pullPhiSpread = ps.getParameter<double>("pullPhiSpread");
47  pullOneOvPSpread = ps.getParameter<double>("pullOneOvPSpread");
48  resChargeLimit_tkGlb = ps.getParameter<double>("resChargeLimit_tkGlb");
49  resChargeLimit_glbSta = ps.getParameter<double>("resChargeLimit_glbSta");
50  resChargeLimit_tkSta = ps.getParameter<double>("resChargeLimit_tkSta");
51  numMatchedExpected_min = ps.getParameter<double>("numMatchedExpected_min");
52  numMatchedExpected_max = ps.getParameter<double>("numMatchedExpected_max");
53  matchesFractionDt_min = ps.getParameter<double>("matchesFractionDt_min");
54  matchesFractionDt_max = ps.getParameter<double>("matchesFractionDt_max");
55  matchesFractionCsc_min = ps.getParameter<double>("matchesFractionCsc_min");
56  matchesFractionCsc_max = ps.getParameter<double>("matchesFractionCsc_max");
57  resSegmTrack_rms_min = ps.getParameter<double>("resSegmTrack_rms_min");
58  resSegmTrack_rms_max = ps.getParameter<double>("resSegmTrack_rms_max");
59  resSegmTrack_mean_min = ps.getParameter<double>("resSegmTrack_mean_min");
60  resSegmTrack_mean_max = ps.getParameter<double>("resSegmTrack_mean_max");
61  expPeakEcalS9_min = ps.getParameter<double>("expPeakEcalS9_min");
62  expPeakEcalS9_max = ps.getParameter<double>("expPeakEcalS9_max");
63  expPeakHadS9_min = ps.getParameter<double>("expPeakHadS9_min");
64  expPeakHadS9_max = ps.getParameter<double>("expPeakHadS9_max");
65  expMultiplicityGlb_max = ps.getParameter<double>("expMultiplicityGlb_max");
66  expMultiplicityTk_max = ps.getParameter<double>("expMultiplicityTk_max");
67  expMultiplicitySta_max = ps.getParameter<double>("expMultiplicitySta_max");
68  expMultiplicityGlb_min = ps.getParameter<double>("expMultiplicityGlb_min");
69  expMultiplicityTk_min = ps.getParameter<double>("expMultiplicityTk_min");
70  expMultiplicitySta_min = ps.getParameter<double>("expMultiplicitySta_min");
71 
72 }
73 
74 MuonTestSummary::~MuonTestSummary(){}
75 
76 void MuonTestSummary::beginJob(void){
77 
78  metname = "muonTestSummary";
79  LogTrace(metname)<<"[MuonTestSummary] beginJob: Histo booking";
80 
81  // book the summary histos
82  dbe->setCurrentFolder("Muons/TestSummary");
83 
84  // kinematics test report
85  kinematicsSummaryMap = dbe->book2D("kinematicsSummaryMap","Kinematics test summary",5,1,6,3,1,4);
86  kinematicsSummaryMap->setAxisTitle("track monitored",1);
87  kinematicsSummaryMap->setBinLabel(1,"GLB",1);
88  kinematicsSummaryMap->setBinLabel(2,"TKfromGLB",1);
89  kinematicsSummaryMap->setBinLabel(3,"STAfromGLB",1);
90  kinematicsSummaryMap->setBinLabel(4,"TK",1);
91  kinematicsSummaryMap->setBinLabel(5,"STA",1);
92  kinematicsSummaryMap->setAxisTitle("parameter tested",2);
93  kinematicsSummaryMap->setBinLabel(1,"#chi^{2}",2);
94  kinematicsSummaryMap->setBinLabel(2,"#eta",2);
95  kinematicsSummaryMap->setBinLabel(3,"#phi",2);
96 
97  //chi2 kinematics quality test report
98  chi2TestSummaryMap = dbe->book2D("chi2TestSummaryMap","#chi2 quality test summary",5,1,6,5,1,6);
99  chi2TestSummaryMap->setAxisTitle("track monitored",1);
100  chi2TestSummaryMap->setBinLabel(1,"GLB",1);
101  chi2TestSummaryMap->setBinLabel(2,"TKfromGLB",1);
102  chi2TestSummaryMap->setBinLabel(3,"STAfromGLB",1);
103  chi2TestSummaryMap->setBinLabel(4,"TK",1);
104  chi2TestSummaryMap->setBinLabel(5,"STA",1);
105  chi2TestSummaryMap->setAxisTitle("parameter tested",2);
106  chi2TestSummaryMap->setBinLabel(1,"#chi^{2}",2);
107  chi2TestSummaryMap->setBinLabel(2,"#eta",2);
108  chi2TestSummaryMap->setBinLabel(3,"#phi",2);
109  chi2TestSummaryMap->setBinLabel(4,"#pt",2);
110  chi2TestSummaryMap->setBinLabel(5,"#q",2);
111 
112 //Kolmogorov kinematics quality test report
113  KolmogorovTestSummaryMap = dbe->book2D("KolmogorovTestSummaryMap","Kolmogorov quality test summary",5,1,6,5,1,6);
114  KolmogorovTestSummaryMap->setAxisTitle("track monitored",1);
115  KolmogorovTestSummaryMap->setBinLabel(1,"GLB",1);
116  KolmogorovTestSummaryMap->setBinLabel(2,"TKfromGLB",1);
117  KolmogorovTestSummaryMap->setBinLabel(3,"STAfromGLB",1);
118  KolmogorovTestSummaryMap->setBinLabel(4,"TK",1);
119  KolmogorovTestSummaryMap->setBinLabel(5,"STA",1);
120  KolmogorovTestSummaryMap->setAxisTitle("parameter tested",2);
121  KolmogorovTestSummaryMap->setBinLabel(1,"#chi^{2}",2);
122  KolmogorovTestSummaryMap->setBinLabel(2,"#eta",2);
123  KolmogorovTestSummaryMap->setBinLabel(3,"#phi",2);
124  KolmogorovTestSummaryMap->setBinLabel(4,"#pt",2);
125  KolmogorovTestSummaryMap->setBinLabel(5,"#q",2);
126 
127 
128  // residuals test report
129  residualsSummaryMap = dbe->book2D("residualsSummaryMap","Residuals test summary",4,1,5,4,1,5);
130  residualsSummaryMap->setAxisTitle("residuals",1);
131  residualsSummaryMap->setBinLabel(1,"TK-GLB",1);
132  residualsSummaryMap->setBinLabel(2,"GLB-STA",1);
133  residualsSummaryMap->setBinLabel(3,"TK-STA",1);
134  residualsSummaryMap->setBinLabel(4,"TK-STA Pull",1);
135  residualsSummaryMap->setAxisTitle("parameter tested",2);
136  residualsSummaryMap->setBinLabel(1,"#eta",2);
137  residualsSummaryMap->setBinLabel(2,"#phi",2);
138  residualsSummaryMap->setBinLabel(3,"1/p",2);
139  residualsSummaryMap->setBinLabel(4,"q",2);
140 
141  // muonId test report
142  muonIdSummaryMap = dbe->book2D("muonIdSummaryMap","muonId test summary",4,1,5, 5,1,6);
143  muonIdSummaryMap->setAxisTitle("muons",1);
144  muonIdSummaryMap->setBinLabel(1,"GLB DT",1);
145  muonIdSummaryMap->setBinLabel(2,"GLB CSC",1);
146  muonIdSummaryMap->setBinLabel(3,"TK DT",1);
147  muonIdSummaryMap->setBinLabel(4,"TK CSC",1);
148  muonIdSummaryMap->setAxisTitle("tests",2);
149  muonIdSummaryMap->setBinLabel(1,"#assSeg",2);
150  muonIdSummaryMap->setBinLabel(2,"x mean",2);
151  muonIdSummaryMap->setBinLabel(3,"x rms",2);
152  muonIdSummaryMap->setBinLabel(4,"y mean",2);
153  muonIdSummaryMap->setBinLabel(5,"y rms",2);
154 
155  // energy test report
156  energySummaryMap = dbe->book2D("energySummaryMap","Energy deposits test summary",3,1,4,3,1,4);
157  energySummaryMap->setAxisTitle("muons",1);
158  energySummaryMap->setBinLabel(1,"GLB",1);
159  energySummaryMap->setBinLabel(2,"TK",1);
160  energySummaryMap->setBinLabel(3,"STA",1);
161  energySummaryMap->setAxisTitle("calorimeter tested",2);
162  energySummaryMap->setBinLabel(1,"ECAL",2);
163  energySummaryMap->setBinLabel(2,"HAD",2);
164  energySummaryMap->setBinLabel(3,"H0",2);
165 
166  // multiplicity tests report
167  multiplicitySummaryMap = dbe->book1D("multiplicitySummaryMap","muon multiplicity test summary",3,1,4);
168  multiplicitySummaryMap->setAxisTitle("muon");
169  multiplicitySummaryMap->setBinLabel(1,"GLB");
170  multiplicitySummaryMap->setBinLabel(2,"TK");
171  multiplicitySummaryMap->setBinLabel(3,"STA");
172 
173 
174  // summary test report
175  dbe->setCurrentFolder("Muons/EventInfo");
176  summaryReport = dbe->bookFloat("reportSummary");
177 
178  summaryReportMap = dbe->book2D("reportSummaryMap","Muon Report Summary Map",3,1,4,7,1,8);
179  summaryReportMap->setAxisTitle("muons",1);
180  summaryReportMap->setBinLabel(1,"GLB",1);
181  summaryReportMap->setBinLabel(2,"TK",1);
182  summaryReportMap->setBinLabel(3,"STA",1);
183  summaryReportMap->setAxisTitle("test",2);
184  summaryReportMap->setBinLabel(1,"#chi^{2}/Df",2);
185  summaryReportMap->setBinLabel(2,"#eta",2);
186  summaryReportMap->setBinLabel(3,"#phi",2);
187  summaryReportMap->setBinLabel(4,"residuals",2);
188  summaryReportMap->setBinLabel(5,"muonId",2);
189  summaryReportMap->setBinLabel(6,"energyDeposits",2);
190  summaryReportMap->setBinLabel(7,"multiplicity",2);
191 
192  dbe->setCurrentFolder("Muons/EventInfo/reportSummaryContents");
193  theSummaryContents.push_back(dbe->bookFloat("kinematics_GLB"));
194  theSummaryContents.push_back(dbe->bookFloat("muonId_GLB"));
195  theSummaryContents.push_back(dbe->bookFloat("residuals_GLB"));
196  theSummaryContents.push_back(dbe->bookFloat("GLB"));
197  theSummaryContents.push_back(dbe->bookFloat("kinematics_TK"));
198  theSummaryContents.push_back(dbe->bookFloat("muonId_TK"));
199  theSummaryContents.push_back(dbe->bookFloat("residuals_TK"));
200  theSummaryContents.push_back(dbe->bookFloat("TK"));
201  theSummaryContents.push_back(dbe->bookFloat("kinematics_STA"));
202  theSummaryContents.push_back(dbe->bookFloat("residuals_STA"));
203  theSummaryContents.push_back(dbe->bookFloat("STA"));
204  theSummaryContents.push_back(dbe->bookFloat("energyDeposits"));
205  theSummaryContents.push_back(dbe->bookFloat("multiplicity"));
206 
207  // certification report
208  dbe->setCurrentFolder("Muons/EventInfo");
209  summaryCertification = dbe->bookFloat("CertificationSummary");
210  summaryCertification->Fill(-1);
211 
212  summaryCertificationMap = dbe->book2D("CertificationSummaryMap","Muon Certification Summary Map",9,1,10,7,1,8);
213  summaryCertificationMap->setAxisTitle("muons",1);
214  summaryCertificationMap->setBinLabel(1,"GLB_Tot",1);
215  summaryCertificationMap->setBinLabel(2,"TK_Tot",1);
216  summaryCertificationMap->setBinLabel(3,"STA_tot",1);
217  summaryCertificationMap->setBinLabel(4,"GLB_B",1);
218  summaryCertificationMap->setBinLabel(5,"TK_B",1);
219  summaryCertificationMap->setBinLabel(6,"STA_B",1);
220  summaryCertificationMap->setBinLabel(7,"GLB_EC",1);
221  summaryCertificationMap->setBinLabel(8,"TK_EC",1);
222  summaryCertificationMap->setBinLabel(9,"STA_EC",1);
223  summaryCertificationMap->setAxisTitle("test",2);
224  summaryCertificationMap->setBinLabel(1,"#chi^{2}/Df",2);
225  summaryCertificationMap->setBinLabel(2,"#eta",2);
226  summaryCertificationMap->setBinLabel(3,"#phi",2);
227  summaryCertificationMap->setBinLabel(4,"residuals",2);
228  summaryCertificationMap->setBinLabel(5,"muonId",2);
229  summaryCertificationMap->setBinLabel(6,"energyDeposits",2);
230  summaryCertificationMap->setBinLabel(7,"multiplicity",2);
231 
232  dbe->setCurrentFolder("Muons/EventInfo/CertificationContents");
233  theCertificationContents.push_back(dbe->bookFloat("GLB_Tot"));
234  theCertificationContents.push_back(dbe->bookFloat("STA_Tot"));
235  theCertificationContents.push_back(dbe->bookFloat("TK_Tot"));
236  theCertificationContents.push_back(dbe->bookFloat("GLB_B"));
237  theCertificationContents.push_back(dbe->bookFloat("STA_B"));
238  theCertificationContents.push_back(dbe->bookFloat("TK_B"));
239  theCertificationContents.push_back(dbe->bookFloat("GLB_EC"));
240  theCertificationContents.push_back(dbe->bookFloat("STA_EC"));
241  theCertificationContents.push_back(dbe->bookFloat("TK_EC"));
242 
243 
244  for (unsigned int icert=0;icert <theCertificationContents.size();icert++){
245  theCertificationContents[icert]->Fill(-1);
246  }
247 }
248 
249 
250 void MuonTestSummary::beginRun(Run const& run, EventSetup const& eSetup) {
251 
252  LogTrace(metname)<<"[MuonTestSummary]: beginRun";
253 
254  // initialisation of histo bins
255  for(int xBin=1; xBin<=5; xBin++){
256  for(int yBin=1; yBin<=3; yBin++){
257  kinematicsSummaryMap->Fill(xBin,yBin,1);
258  }
259  for(int yBin=1; yBin<=5; yBin++){
260  chi2TestSummaryMap->Fill(xBin,yBin,1);
261  KolmogorovTestSummaryMap->Fill(xBin,yBin,1);
262  }
263  }
264  for(int xBin=1; xBin<=residualsSummaryMap->getNbinsX(); xBin++){
265  for(int yBin=1; yBin<=residualsSummaryMap->getNbinsY(); yBin++){
266  residualsSummaryMap->Fill(xBin,yBin,1);
267  }
268  }
269  residualsSummaryMap->setBinContent(4, 4, 1); //not used for now
270 
271  for(int xBin=1; xBin<=muonIdSummaryMap->getNbinsX(); xBin++){
272  for(int yBin=1; yBin<=muonIdSummaryMap->getNbinsY(); yBin++){
273  muonIdSummaryMap->Fill(xBin,yBin,1);
274  }
275  }
276  for(int xBin=1; xBin<=3; xBin++){
277  for(int yBin=1; yBin<=3; yBin++){
278  energySummaryMap->Fill(xBin,yBin,1);
279  }
280  }
281  for(int xBin=1; xBin<=3; xBin++){
282  multiplicitySummaryMap->Fill(xBin,1);
283  }
284  for(int xBin=1; xBin<=3; xBin++){
285  for(int yBin=1; yBin<=7; yBin++){
286  summaryReportMap->Fill(xBin,yBin,1);
287  }
288  }
289  for(int xBin=1; xBin<=9; xBin++){
290  for(int yBin=1; yBin<=7; yBin++){
291  summaryCertificationMap->Fill(xBin,yBin,1);
292  }
293  }
294 }
295 
296 void MuonTestSummary::beginLuminosityBlock(LuminosityBlock const& lumiSeg, EventSetup const& context) {
297  // LogTrace(metname)<<"[MuonTestSummary]: beginLuminosityBlock";
298 }
299 
300 void MuonTestSummary::endLuminosityBlock(LuminosityBlock const& lumiSeg, EventSetup const& context) {
301 
302  // LogTrace(metname)<<"[MuonTestSummary]: endLuminosityBlock, performing the DQM LS client operation";
303 
304 }
305 
306 void MuonTestSummary::endRun(Run const& run, EventSetup const& eSetup) {
307 
308  LogTrace(metname)<<"[MuonTestSummary]: endRun, performing the DQM end of run client operation";
309 
310  // fill the kinematics report summary
311  doKinematicsTests("GlbMuon_Glb_", 1);
312  doKinematicsTests("GlbMuon_Tk_", 2);
313  doKinematicsTests("GlbMuon_Sta_",3);
314  doKinematicsTests("TkMuon_", 4);
315  doKinematicsTests("StaMuon_", 5);
316 
317  // fill the residuals report summary
318  doResidualsTests("TkGlb", "eta", 1);
319  doResidualsTests("GlbSta", "eta", 2);
320  doResidualsTests("TkSta", "eta", 3);
321  doResidualsTests("TkGlb", "phi", 1);
322  doResidualsTests("GlbSta", "phi", 2);
323  doResidualsTests("TkSta", "phi", 3);
324  doResidualsTests("TkGlb", "oneOverp", 1);
325  doResidualsTests("GlbSta", "oneOverp", 2);
326  doResidualsTests("TkSta", "oneOverp", 3);
327  doResidualsTests("GlbMuon", "qComparison", -1);
328 
329  // fill the muonID report summary
330  doMuonIDTests();
331 
332  // fill the energy report summary
333  doEnergyTests("ecalS9PointingMuDepositedEnergy_","Glb_muons", 1);
334  doEnergyTests("hadS9PointingMuDepositedEnergy_", "Glb_muons", 1);
335  doEnergyTests("hoS9PointingMuDepositedEnergy_", "Glb_muons", 1);
336  doEnergyTests("ecalS9PointingMuDepositedEnergy_", "Tk_muons", 2);
337  doEnergyTests("hadS9PointingMuDepositedEnergy_", "Tk_muons", 2);
338  doEnergyTests("hoS9PointingMuDepositedEnergy_", "Tk_muons", 2);
339  doEnergyTests("ecalS9PointingMuDepositedEnergy_", "Sta_muons", 3);
340  doEnergyTests("hadS9PointingMuDepositedEnergy_", "Sta_muons", 3);
341  doEnergyTests("hoS9PointingMuDepositedEnergy_", "Sta_muons", 3);
342 
343  // fill the multiplicity test summary
344  doMultiplicityTests();
345 
346  // fill the final report summary
347  /*
348  summaryReportMap->setBinContent(1,1,double(kinematicsSummaryMap->getBinContent(1,1)+kinematicsSummaryMap->getBinContent(2,1)+kinematicsSummaryMap->getBinContent(3,1))/3.0);
349  summaryReportMap->setBinContent(2,1,kinematicsSummaryMap->getBinContent(4,1));
350  summaryReportMap->setBinContent(3,1,kinematicsSummaryMap->getBinContent(5,1));
351  summaryReportMap->setBinContent(1,2,double(kinematicsSummaryMap->getBinContent(1,2)+kinematicsSummaryMap->getBinContent(2,2)+kinematicsSummaryMap->getBinContent(3,2))/3.0);
352  summaryReportMap->setBinContent(2,2,kinematicsSummaryMap->getBinContent(4,2));
353  summaryReportMap->setBinContent(3,2,kinematicsSummaryMap->getBinContent(5,2));
354  summaryReportMap->setBinContent(1,3,double(kinematicsSummaryMap->getBinContent(1,3)+kinematicsSummaryMap->getBinContent(2,3)+kinematicsSummaryMap->getBinContent(3,3))/3.0);
355  summaryReportMap->setBinContent(2,3,kinematicsSummaryMap->getBinContent(4,3));
356  summaryReportMap->setBinContent(3,3,kinematicsSummaryMap->getBinContent(5,3));
357  */
358  //Changed to KolmogorovQuality test--------------------------
359  summaryReportMap->setBinContent(1,1,double(KolmogorovTestSummaryMap->getBinContent(1,1)+KolmogorovTestSummaryMap->getBinContent(2,1)+KolmogorovTestSummaryMap->getBinContent(3,1))/3.0);
360  summaryReportMap->setBinContent(2,1,KolmogorovTestSummaryMap->getBinContent(4,1));
361  summaryReportMap->setBinContent(3,1,KolmogorovTestSummaryMap->getBinContent(5,1));
362  summaryReportMap->setBinContent(1,2,double(KolmogorovTestSummaryMap->getBinContent(1,2)+KolmogorovTestSummaryMap->getBinContent(2,2)+KolmogorovTestSummaryMap->getBinContent(3,2))/3.0);
363  summaryReportMap->setBinContent(2,2,KolmogorovTestSummaryMap->getBinContent(4,2));
364  summaryReportMap->setBinContent(3,2,KolmogorovTestSummaryMap->getBinContent(5,2));
365  summaryReportMap->setBinContent(1,3,double(KolmogorovTestSummaryMap->getBinContent(1,3)+KolmogorovTestSummaryMap->getBinContent(2,3)+KolmogorovTestSummaryMap->getBinContent(3,3))/3.0);
366  summaryReportMap->setBinContent(2,3,KolmogorovTestSummaryMap->getBinContent(4,3));
367  summaryReportMap->setBinContent(3,3,KolmogorovTestSummaryMap->getBinContent(5,3));
368 
369 
370 
371  //-- modified GH
372  double residualsSummary = 0;
373  //put the TRK-STA resid & pulls in the first bin ("GLB")
374  //then the GLB-TRK and GLB-STA residuals in the 2nd and 3rd
375  for(int i=3; i<=residualsSummaryMap->getNbinsX(); i++)
376  for (int j=1; j<=residualsSummaryMap->getNbinsY(); j++)
377  residualsSummary += residualsSummaryMap->getBinContent(i,j);
378  residualsSummary /=2*residualsSummaryMap->getNbinsY();
379  summaryReportMap->setBinContent(1,4, residualsSummary);
380 
381  residualsSummary=0;
382  for(int i=1; i<=1; i++)
383  for (int j=1; j<=residualsSummaryMap->getNbinsY(); j++)
384  residualsSummary += residualsSummaryMap->getBinContent(i,j);
385  residualsSummary /=1*residualsSummaryMap->getNbinsY();
386  summaryReportMap->setBinContent(2,4,residualsSummary);
387 
388  residualsSummary=0;
389  for(int i=2; i<=2; i++)
390  for (int j=1; j<=residualsSummaryMap->getNbinsY(); j++)
391  residualsSummary += residualsSummaryMap->getBinContent(i,j);
392  residualsSummary /=1*residualsSummaryMap->getNbinsY();
393  summaryReportMap->setBinContent(3,4,residualsSummary);
394 
395  //--
396 
397 
398 
399  //-- modified GH
400  float idtest=0;
401  for(int i=1; i<=2; i++)
402  for(int j=1; j<=5; j++) {
403  if(j==3 || j==5) continue; //ignore pull widths for now
404  idtest+=muonIdSummaryMap->getBinContent(i,j);
405  }
406  // idtest/=10.;
407  idtest/=6.;
408  summaryReportMap->setBinContent(1,5, idtest);
409  idtest=0;
410  for(int i=3; i<=4; i++)
411  for(int j=1; j<=5; j++) {
412  if(j==3 || j==5) continue; //ignore pull widths for now
413  idtest+=muonIdSummaryMap->getBinContent(i,j);
414  }
415  // idtest/=10.;
416  idtest/=6.;
417  summaryReportMap->setBinContent(2,5,idtest);
418  summaryReportMap->setBinContent(3,5,-1.0/6.0);
419  //--
420 
421 
422 
423  //summaryReportMap->setBinContent(1,6,double(energySummaryMap->getBinContent(1,1)+energySummaryMap->getBinContent(1,2)+energySummaryMap->getBinContent(1,3))/3.0);
424  //summaryReportMap->setBinContent(2,6,double(energySummaryMap->getBinContent(2,1)+energySummaryMap->getBinContent(2,2)+energySummaryMap->getBinContent(2,3))/3.0);
425  //summaryReportMap->setBinContent(3,6,double(energySummaryMap->getBinContent(3,1)+energySummaryMap->getBinContent(3,2)+energySummaryMap->getBinContent(3,3))/3.0);
426  summaryReportMap->setBinContent(1,6,double(energySummaryMap->getBinContent(1,1)+energySummaryMap->getBinContent(1,2))/2.0);
427  summaryReportMap->setBinContent(2,6,double(energySummaryMap->getBinContent(2,1)+energySummaryMap->getBinContent(2,2))/2.0);
428  summaryReportMap->setBinContent(3,6,double(energySummaryMap->getBinContent(3,1)+energySummaryMap->getBinContent(3,2))/2.0);
429  summaryReportMap->setBinContent(1,7,multiplicitySummaryMap->getBinContent(1));
430  summaryReportMap->setBinContent(2,7,multiplicitySummaryMap->getBinContent(2));
431  summaryReportMap->setBinContent(3,7,multiplicitySummaryMap->getBinContent(3));
432 
433 
434  double kinematics_GLB = double(summaryReportMap->getBinContent(1,1)+summaryReportMap->getBinContent(1,2)+summaryReportMap->getBinContent(1,3))/3.0;
435  theSummaryContents[0]->Fill(kinematics_GLB);
436  double muonId_GLB = double(summaryReportMap->getBinContent(1,5));
437  theSummaryContents[1]->Fill(muonId_GLB);
438  double residuals_GLB = double(summaryReportMap->getBinContent(1,4));
439  theSummaryContents[2]->Fill(residuals_GLB);
440  double GLB = (kinematics_GLB+muonId_GLB+residuals_GLB)/3.0;
441  theSummaryContents[3]->Fill(GLB);
442 
443  double kinematics_TK = double(summaryReportMap->getBinContent(2,1)+summaryReportMap->getBinContent(2,2)+summaryReportMap->getBinContent(2,3))/3.0;
444  theSummaryContents[4]->Fill(kinematics_TK);
445  double muonId_TK = double(summaryReportMap->getBinContent(2,5));
446  theSummaryContents[5]->Fill(muonId_TK);
447  double residuals_TK = double(summaryReportMap->getBinContent(2,4));
448  theSummaryContents[6]->Fill(residuals_TK);
449  double TK = double(kinematics_TK+muonId_TK+residuals_TK)/3.0;
450  theSummaryContents[7]->Fill(TK);
451 
452  double kinematics_STA = double(summaryReportMap->getBinContent(3,1)+summaryReportMap->getBinContent(3,2)+summaryReportMap->getBinContent(3,3))/3.0;
453  theSummaryContents[8]->Fill(kinematics_STA);
454  double residuals_STA = double(summaryReportMap->getBinContent(3,4));
455  theSummaryContents[9]->Fill(residuals_STA);
456  double STA = double(kinematics_STA+residuals_STA)/2.0;
457  theSummaryContents[10]->Fill(STA);
458  double energyDeposits = double(summaryReportMap->getBinContent(1,6)+summaryReportMap->getBinContent(2,6)+summaryReportMap->getBinContent(3,6))/3.0;
459  theSummaryContents[11]->Fill(energyDeposits);
460  double multiplicity = double(summaryReportMap->getBinContent(1,7)+summaryReportMap->getBinContent(2,7)+summaryReportMap->getBinContent(3,7))/3.0;
461  theSummaryContents[12]->Fill(multiplicity);
462 
463  summaryReport->Fill((GLB+TK+STA+energyDeposits+multiplicity)/5.0);
464 
465 
466  //global barrel:
467  float muonIDsummary=0;
468  // for(int i=2; i<=5; i++)
469  // muonIDsummary += muonIdSummaryMap->getBinContent(2, i);
470  // summaryCertificationMap->setBinContent(4, 5, muonIDsummary/4.);
471  //for now, just report the mean:
472  muonIDsummary += muonIdSummaryMap->getBinContent(1, 2);
473  muonIDsummary += muonIdSummaryMap->getBinContent(1, 4);
474  summaryCertificationMap->setBinContent(4, 5, muonIDsummary/2.);
475 
476  //global EC:
477  muonIDsummary=0;
478  // for(int i=2; i<=5; i++)
479  // muonIDsummary += muonIdSummaryMap->getBinContent(2, i);
480  // summaryCertificationMap->setBinContent(7, 5, muonIDsummary/4.);
481  muonIDsummary += muonIdSummaryMap->getBinContent(2, 2);
482  muonIDsummary += muonIdSummaryMap->getBinContent(2, 4);
483  summaryCertificationMap->setBinContent(7, 5, muonIDsummary/2.);
484 
485  //tracker barrel:
486  muonIDsummary=0;
487  // for(int i=2; i<=5; i++)
488  // muonIDsummary += muonIdSummaryMap->getBinContent(3, i);
489  // summaryCertificationMap->setBinContent(5, 5, muonIDsummary/4.);
490  muonIDsummary += muonIdSummaryMap->getBinContent(3, 2);
491  muonIDsummary += muonIdSummaryMap->getBinContent(3, 4);
492  summaryCertificationMap->setBinContent(5, 5, muonIDsummary/2.);
493 
494  //tracker EC:
495  muonIDsummary=0;
496  // for(int i=2; i<=5; i++)
497  // muonIDsummary += muonIdSummaryMap->getBinContent(4, i);
498  // summaryCertificationMap->setBinContent(8, 5, muonIDsummary/4.);
499  muonIDsummary += muonIdSummaryMap->getBinContent(4, 2);
500  muonIDsummary += muonIdSummaryMap->getBinContent(4, 4);
501  summaryCertificationMap->setBinContent(8, 5, muonIDsummary/2.);
502 
503 
504  double muonId_GLB_B = double(summaryCertificationMap->getBinContent(4,5));
505  theCertificationContents[3]->Fill(muonId_GLB_B);
506  double muonId_GLB_EC = double(summaryCertificationMap->getBinContent(7,5));
507  theCertificationContents[6]->Fill(muonId_GLB_EC);
508 
509  double muonId_TK_B = double(summaryCertificationMap->getBinContent(5,5));
510  theCertificationContents[5]->Fill(muonId_TK_B);
511  double muonId_TK_EC = double(summaryCertificationMap->getBinContent(8,5));
512  theCertificationContents[8]->Fill(muonId_TK_EC);
513 
514 
515 
516 
517 
518 
519 
520 }
521 
522 
523 void MuonTestSummary::doKinematicsTests(string muonType, int bin){
524 
525 
526  // chi2 test
527  string path = "Muons/MuonRecoAnalyzer/" + muonType + "chi2OverDf";
528  MonitorElement * chi2Histo = dbe->get(path);
529 
530  if(chi2Histo){
531  TH1F * chi2Histo_root = chi2Histo->getTH1F();
532  if(chi2Histo_root->GetEntries()>20){
533 
534  //Standard QT based on fraction of events below and above a cut
535  LogTrace(metname)<<"chi2 kin test based on fraction for "<<muonType<<endl;
536  int maxBin = chi2Histo_root->GetMaximumBin();
537  if(chi2Histo_root->Integral(maxBin+1,chi2Histo_root->GetNbinsX())!=0){
538  double fraction = double(chi2Histo_root->Integral(1,maxBin))/double(chi2Histo_root->Integral(maxBin+1,chi2Histo_root->GetNbinsX()));
539  LogTrace(metname)<<"chi2 fraction for "<<muonType<<" : "<<fraction<< " must be within "<< chi2Fraction-chi2Spread<<","<<chi2Fraction+chi2Spread<<endl;
540  if(fraction>(chi2Fraction-chi2Spread) && fraction<(chi2Fraction+chi2Spread))
541  kinematicsSummaryMap->setBinContent(bin,1,1);
542  else
543  kinematicsSummaryMap->setBinContent(bin,1,0);
544  }
545 
546  //QT based on comp wrt reference based on chi2
547  LogTrace(metname)<<"chi2 kin test based on comp wrt reference on terms of chi2 for "<<muonType<<endl;
548  const QReport * myQReport = chi2Histo->getQReport("Mu_Comp2RefChi2"); //get QReport associated to your ME
549  if(myQReport) {
550  LogTrace(metname) << "Chi2Report exists!!";
551  float qtresult = myQReport->getQTresult(); // get QT result value
552  int qtstatus = myQReport->getStatus() ; // get QT status value (see table below)
553  std::string qtmessage = myQReport->getMessage() ; // get the whole QT result message
554  LogTrace(metname) << "qtresult " <<qtresult << " qtstatus "<<qtstatus<<endl;
555  chi2TestSummaryMap->setBinContent(bin,1,qtresult);
556  }
557  //QT based on comp wrt reference based on kolmogorov test
558  LogTrace(metname)<<"chi2 kin test based on comp wrt reference using kolmogorov for "<<muonType<<endl;
559  const QReport * myQReportKolmo = chi2Histo->getQReport("Mu_Comp2RefKolmogorov");
560  if(myQReportKolmo) {
561  LogTrace(metname) << "Chi2Report Kolmogorov exists!!";
562  float qtresult = myQReportKolmo->getQTresult(); // get QT result value
563  int qtstatus = myQReportKolmo->getStatus() ; // get QT status value (see table below)
564  std::string qtmessage = myQReportKolmo->getMessage() ; // get the whole QT result message
565  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
566  KolmogorovTestSummaryMap->setBinContent(bin,1,qtresult);
567  }
568 
569  }
570  else{
571  LogTrace(metname) << "[MuonTestSummary]: Test of Chi2 Kin not performed for "<< muonType << " because # entries < 20 ";
572  }
573  }
574 
575 
576 
577  // pseudorapidity test
578  path = "Muons/MuonRecoAnalyzer/" + muonType + "eta";
579  MonitorElement * etaHisto = dbe->get(path);
580 
581  if(etaHisto){
582  TH1F * etaHisto_root = etaHisto->getTH1F();
583  if (etaHisto_root ->GetEntries()>20){
584 
585  //Standard QT based on fraction of events below and above a cut
586  LogTrace(metname)<<"eta kin test based on fraction for "<<muonType<<endl;
587  double binSize = (etaHisto_root->GetXaxis()->GetXmax()-etaHisto_root->GetXaxis()->GetXmin())/etaHisto_root->GetNbinsX();
588  int binZero = int((0-etaHisto_root->GetXaxis()->GetXmin())/binSize);
589  if(etaHisto_root->Integral(1,binZero-1)!=0 && etaHisto_root->Integral(binZero,etaHisto_root->GetNbinsX())!=0){
590  double symmetryFactor =
591  double(etaHisto_root->Integral(1,binZero-1)) / double(etaHisto_root->Integral(binZero,etaHisto_root->GetNbinsX()));
592  double errSymmetryFactor =
593  symmetryFactor*sqrt(1.0/double(etaHisto_root->Integral(1,binZero-1)) + 1.0/double(etaHisto_root->Integral(binZero,etaHisto_root->GetNbinsX())));
594  LogTrace(metname)<<"eta symmetryFactor for "<<muonType<<" : "<<symmetryFactor<< " (expected :" <<etaExpected <<")"<<endl;
595  LogTrace(metname)<<"eta errSymmetryFactor for "<<muonType<<" : "<<errSymmetryFactor<<endl;
596  double tParameter;
597  if((symmetryFactor-etaExpected)>0) tParameter=double(symmetryFactor-etaExpected)/errSymmetryFactor;
598  else tParameter=double(-symmetryFactor+etaExpected)/errSymmetryFactor;
599  LogTrace(metname)<<"eta tParameter for "<<muonType<<" : "<<tParameter<<" (expected < 1.95)" <<endl;
600  if (tParameter<1.95) //2sigma rejection
601  kinematicsSummaryMap->setBinContent(bin,2,1);
602  else
603  kinematicsSummaryMap->setBinContent(bin,2,0);
604  }
605 
606  //QT based on comp wrt reference based on chi2
607  LogTrace(metname)<<"eta kin test based on comp wrt reference on terms of chi2 for "<<muonType<<endl;
608  const QReport * myQReport = etaHisto->getQReport("Mu_Comp2RefChi2"); //get QReport associated to your ME
609  if(myQReport) {
610  LogTrace(metname) << "EtaReport exists!!";
611  float qtresult = myQReport->getQTresult(); // get QT result value
612  int qtstatus = myQReport->getStatus() ; // get QT status value (see table below)
613  std::string qtmessage = myQReport->getMessage() ; // get the whole QT result message
614  LogTrace(metname) << "qtresult " <<qtresult << " qtstatus "<<qtstatus<<endl;
615  chi2TestSummaryMap->setBinContent(bin,2,qtresult);
616  }
617 
618  //QT based on comp wrt reference based on kolmogorov test
619  LogTrace(metname)<<"eta kin test based on comp wrt reference using kolmogorov for "<<muonType<<endl;
620  const QReport * myQReportKolmo = etaHisto->getQReport("Mu_Comp2RefKolmogorov");
621  if(myQReportKolmo) {
622  LogTrace(metname) << "EtaReport Kolmogorov exists!!";
623  float qtresult = myQReportKolmo->getQTresult(); // get QT result value
624  int qtstatus = myQReportKolmo->getStatus() ; // get QT status value (see table below)
625  std::string qtmessage = myQReportKolmo->getMessage() ; // get the whole QT result message
626  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
627  KolmogorovTestSummaryMap->setBinContent(bin,2,qtresult);
628  }
629 
630  }
631  else{
632  LogTrace(metname) << "[MuonTestSummary]: Test of Eta Kin not performed for "<< muonType << " because # entries < 20 ";
633  }
634  }
635 
636 
637 
638  // phi test
639  path = "Muons/MuonRecoAnalyzer/" + muonType + "phi";
640  MonitorElement * phiHisto = dbe->get(path);
641 
642  if(phiHisto ){
643  TH1F * phiHisto_root = phiHisto->getTH1F();
644  if(phiHisto_root ->GetEntries()>20){
645 
646  //Standard QT based on fraction of events below and above a cut
647  LogTrace(metname)<<"phi kin test based on fraction for "<<muonType<<endl;
648  double binSize = (phiHisto_root->GetXaxis()->GetXmax()-phiHisto_root->GetXaxis()->GetXmin())/phiHisto_root->GetNbinsX();
649  int binZero = int((0-phiHisto_root->GetXaxis()->GetXmin())/binSize);
650  if(phiHisto_root->Integral(binZero+1,phiHisto_root->GetNbinsX())!=0 && phiHisto_root->Integral(1,binZero)!=0){
651  double symmetryFactor =
652  double(phiHisto_root->Integral(binZero+1,phiHisto_root->GetNbinsX())) / double(phiHisto_root->Integral(1,binZero));
653  double errSymmetryFactor =
654  symmetryFactor*sqrt(1.0/double(phiHisto_root->Integral(binZero+1,phiHisto_root->GetNbinsX())) + 1.0/double(phiHisto_root->Integral(1,binZero)));
655  LogTrace(metname)<<"phi symmetryFactor for "<<muonType<<" : "<<symmetryFactor<< "(phi expected :" <<phiExpected <<")"<<endl;
656  LogTrace(metname)<<"phi errSymmetryFactor for "<<muonType<<" : "<<errSymmetryFactor<<endl;
657  double tParameter;
658  if((symmetryFactor-phiExpected)>0) tParameter=double(symmetryFactor-phiExpected)/errSymmetryFactor;
659  else tParameter=double(-symmetryFactor+phiExpected)/errSymmetryFactor;
660  LogTrace(metname)<<"phi tParameter for "<<muonType<<" : "<<tParameter<<" (expected < 1.95)" <<endl;
661  if (tParameter<1.95) //2sigma rejection
662  kinematicsSummaryMap->setBinContent(bin,3,1);
663  else
664  kinematicsSummaryMap->setBinContent(bin,3,0);
665  }
666 
667  //QT based on comp wrt reference based on chi2
668  LogTrace(metname)<<"phi kin test based on comp wrt reference on terms of chi2 for "<<muonType<<endl;
669  const QReport * myQReport = phiHisto->getQReport("Mu_Comp2RefChi2"); //get QReport associated to your ME
670  if(myQReport) {
671  LogTrace(metname) << "PhiReport exists!!";
672  float qtresult = myQReport->getQTresult(); // get QT result value
673  int qtstatus = myQReport->getStatus() ; // get QT status value (see table below)
674  std::string qtmessage = myQReport->getMessage() ; // get the whole QT result message
675  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
676  chi2TestSummaryMap->setBinContent(bin,3,qtresult);
677  }
678 
679  //QT based on comp wrt reference based on kolmogorov test
680  LogTrace(metname)<<"phi kin test based on comp wrt reference using kolmogorov for "<<muonType<<endl;
681  const QReport * myQReportKolmo = phiHisto->getQReport("Mu_Comp2RefKolmogorov");
682  if(myQReportKolmo) {
683  LogTrace(metname) << "PhiReport Kolmogorov exists!!";
684  float qtresult = myQReportKolmo->getQTresult(); // get QT result value
685  int qtstatus = myQReportKolmo->getStatus() ; // get QT status value (see table below)
686  std::string qtmessage = myQReportKolmo->getMessage() ; // get the whole QT result message
687  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
688  KolmogorovTestSummaryMap->setBinContent(bin,3,qtresult);
689  }
690 
691  }
692  else{
693  LogTrace(metname) << "[MuonTestSummary]: Test of Phi Kin not performed for "<< muonType << " because # entries < 20 ";
694  }
695  }
696 
697  // pt test
698  path = "Muons/MuonRecoAnalyzer/" + muonType + "pt";
699  MonitorElement * ptHisto = dbe->get(path);
700 
701  if(ptHisto ){
702  TH1F * ptHisto_root = ptHisto->getTH1F();
703  if(ptHisto_root ->GetEntries()>20){
704 
705  //QT based on comp wrt reference based on chi2
706  LogTrace(metname)<<"pt kin test based on comp wrt reference on terms of chi2 for "<<muonType<<endl;
707  const QReport * myQReport = ptHisto->getQReport("Mu_Comp2RefChi2"); //get QReport associated to your ME
708  if(myQReport) {
709  LogTrace(metname) << "PtReport exists!!";
710  float qtresult = myQReport->getQTresult(); // get QT result value
711  int qtstatus = myQReport->getStatus() ; // get QT status value (see table below)
712  std::string qtmessage = myQReport->getMessage() ; // get the whole QT result message
713  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
714  chi2TestSummaryMap->setBinContent(bin,4,qtresult);
715  }
716 
717  //QT based on comp wrt reference based on kolmogorov test
718  LogTrace(metname)<<"pt kin test based on comp wrt reference using kolmogorov for "<<muonType<<endl;
719  const QReport * myQReportKolmo = ptHisto->getQReport("Mu_Comp2RefKolmogorov");
720  if(myQReportKolmo) {
721  LogTrace(metname) << "PtReport Kolmogorov exists!!";
722  float qtresult = myQReportKolmo->getQTresult(); // get QT result value
723  int qtstatus = myQReportKolmo->getStatus() ; // get QT status value (see table below)
724  std::string qtmessage = myQReportKolmo->getMessage() ; // get the whole QT result message
725  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
726  KolmogorovTestSummaryMap->setBinContent(bin,4,qtresult);
727  }
728  }
729  else{
730  LogTrace(metname) << "[MuonTestSummary]: Test of Pt Kin not performed for "<< muonType << " because # entries < 20 ";
731  }
732  }
733 
734  // q test
735  path = "Muons/MuonRecoAnalyzer/" + muonType + "q";
736  MonitorElement * qHisto = dbe->get(path);
737 
738  if(ptHisto ){
739  TH1F * qHisto_root = qHisto->getTH1F();
740  if(qHisto_root ->GetEntries()>20){
741 
742  //QT based on comp wrt reference based on chi2
743  LogTrace(metname)<<"q kin test based on comp wrt reference on terms of chi2 for "<<muonType<<endl;
744  const QReport * myQReport = qHisto->getQReport("Mu_Comp2RefChi2"); //get QReport associated to your ME
745  if(myQReport) {
746  LogTrace(metname) << "qReport exists!!";
747  float qtresult = myQReport->getQTresult(); // get QT result value
748  int qtstatus = myQReport->getStatus() ; // get QT status value (see table below)
749  std::string qtmessage = myQReport->getMessage() ; // get the whole QT result message
750  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
751  chi2TestSummaryMap->setBinContent(bin,5,qtresult);
752  }
753 
754  //QT based on comp wrt reference based on kolmogorov test
755  LogTrace(metname)<<"q kin test based on comp wrt reference using kolmogorov for "<<muonType<<endl;
756  const QReport * myQReportKolmo = qHisto->getQReport("Mu_Comp2RefKolmogorov");
757  if(myQReportKolmo) {
758  LogTrace(metname) << "qReport Kolmogorov exists!!";
759  float qtresult = myQReportKolmo->getQTresult(); // get QT result value
760  int qtstatus = myQReportKolmo->getStatus() ; // get QT status value (see table below)
761  std::string qtmessage = myQReportKolmo->getMessage() ; // get the whole QT result message
762  LogTrace(metname) << "qtresult " <<qtresult<< " qtstatus "<<qtstatus<<endl;
763  KolmogorovTestSummaryMap->setBinContent(bin,5,qtresult);
764  }
765  }
766  else{
767  LogTrace(metname) << "[MuonTestSummary]: Test of q Kin not performed for "<< muonType << " because # entries < 20 ";
768  }
769  }
770 
771 }
772 
773 
774 
775 
776 
777 
778 
779  //--GH new
780 void MuonTestSummary::GaussFit(string type, string parameter, MonitorElement * Histo, float &mean, float &mean_err, float &sigma, float &sigma_err) {
781 
782  // Gaussian Fit
783  float statMean = Histo->getMean(1);
784  float statSigma = Histo->getRMS(1);
785  TH1F * histo_root = Histo->getTH1F();
786  if(histo_root->GetEntries()>20){
787  TF1 *gfit = new TF1("Gaussian","gaus",(statMean-(2*statSigma)),(statMean+(2*statSigma)));
788  try {
789  histo_root->Fit(gfit, "Q0");
790  } catch (...) {
791  edm::LogError (metname)<< "[MuonTestSummary]: Exception when fitting Res_"<<type<<"_"<<parameter;
792  }
793  if(gfit){
794  mean = gfit->GetParameter(1);
795  mean_err = gfit->GetParErrors()[2];
796  sigma = gfit->GetParameter(2);
797  sigma_err = gfit->GetParErrors()[2];
798  LogTrace(metname)<<"Gaussian fit mean: "<<mean<<" +- "<<mean_err<<" for "<<type<<"_"<<parameter<<endl;
799  LogTrace(metname)<<"Gaussina fit sigma: "<<sigma<<" +- "<<sigma_err<<" for "<<type<<"_"<<parameter<<endl;
800  }
801  }
802  else{
803  LogTrace(metname) << "[MuonTestSummary]: Test of Res_"<<type<<"_"<<parameter<< " not performed because # entries < 20 ";
804  //auto-pass if not enough events.
805  mean=1;
806  mean_err=1;
807  sigma=1;
808  sigma_err=1;
809  }
810 }
811 
812 
813 
814 
815 
816 
817 void MuonTestSummary::doResidualsTests(string type, string parameter, int bin){
818 
819  // residuals test
820  if(type!="GlbMuon"){
821  string path = "Muons/MuonRecoAnalyzer/Res_" + type + "_" + parameter;
822  MonitorElement * residualsHisto = dbe->get(path);
823 
824  float mean = -1;
825  float mean_err = -1;
826  float sigma = -1;
827  float sigma_err = -1;
828 
829  if(residualsHisto){
830 
831  LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of Res_"<<type<<"_"<<parameter<< endl;
832  GaussFit( type, parameter, residualsHisto, mean, mean_err, sigma, sigma_err);
833 
834  if(sigma!=-1 && parameter=="eta" && type=="TkGlb"){
835  if(sigma-sigma_err<resEtaSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 1, 1);
836  else residualsSummaryMap->setBinContent(bin, 1, 0);
837  }
838  if(sigma!=-1 && parameter=="eta" && (type=="GlbSta" || type=="TkSta")) {
839  if(sigma-sigma_err<resEtaSpread_glbSta) residualsSummaryMap->setBinContent(bin, 1, 1);
840  else residualsSummaryMap->setBinContent(bin, 1, 0);
841  }
842  if(sigma!=-1 && parameter=="phi" && type=="TkGlb"){
843  if(sigma-sigma_err<resPhiSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 2, 1);
844  else residualsSummaryMap->setBinContent(bin, 2, 0);
845  }
846  if(sigma!=-1 && parameter=="phi" && (type=="GlbSta" || type=="TkSta")){
847  if(sigma-sigma_err<resPhiSpread_glbSta) residualsSummaryMap->setBinContent(bin, 2, 1);
848  else residualsSummaryMap->setBinContent(bin, 2, 0);
849  }
850  if(sigma!=-1 && parameter=="oneOverp" && type=="TkGlb"){
851  if(sigma-sigma_err<resOneOvPSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 3, 1);
852  else residualsSummaryMap->setBinContent(bin, 3, 0);
853  }
854  if(sigma!=-1 && parameter=="oneOverp" && (type=="GlbSta" || type=="TkSta")) {
855  if(sigma-sigma_err<resOneOvPSpread_glbSta) residualsSummaryMap->setBinContent(bin, 3, 1);
856  else residualsSummaryMap->setBinContent(bin, 3, 0);
857  }
858  }
859 
860 
861 
862  //--GH modified
863  if(type=="TkSta"){
864  //look at the pull:
865  string path = "Muons/MuonRecoAnalyzer/Pull_" + type + "_" + parameter;
866  MonitorElement * pullHisto = dbe->get(path);
867 
868  if(pullHisto){
869 
870  LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of Pull_"<<type<<"_"<<parameter<< endl;
871  GaussFit( type, parameter, pullHisto, mean, mean_err, sigma, sigma_err);
872 
873  if(sigma!=-1 && parameter=="eta" ){
874  if(sigma-sigma_err<pullEtaSpread) residualsSummaryMap->setBinContent(4, 1, 1);
875  else residualsSummaryMap->setBinContent(4, 1, 0);
876  }
877  if(sigma!=-1 && parameter=="phi"){
878  if(sigma-sigma_err<pullPhiSpread) residualsSummaryMap->setBinContent(4, 2, 1);
879  else residualsSummaryMap->setBinContent(4, 2, 0);
880  }
881  if(sigma!=-1 && parameter=="oneOverp"){
882  if(sigma-sigma_err<pullOneOvPSpread) residualsSummaryMap->setBinContent(4, 3, 1);
883  else residualsSummaryMap->setBinContent(4, 3, 0);
884  }
885 
886  }//have pull histo
887  } //TkSta muons
888  }
889 
890  //this part for Global Muons:
891  else{
892  string path = "Muons/MuonRecoAnalyzer/" + type + "_" + parameter;
893  MonitorElement * residualsHisto = dbe->get(path);
894 
895  if(residualsHisto){
896  LogTrace(metname) << "[MuonTestSummary]: Test of Charge Comparison "<<type<<"_"<<parameter<< endl;
897  if((residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4))!=0){
898  LogTrace(metname)<<"Charge comparison TkGlb: "<<residualsHisto->getBinContent(4)/double(residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4))<<endl;
899  if(residualsHisto->getBinContent(4)/double(residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4)) < resChargeLimit_tkGlb)
900  residualsSummaryMap->setBinContent(1, 4, 1);
901  else
902  residualsSummaryMap->setBinContent(1, 4, 0);
903  }
904  if((residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2))!=0){
905  LogTrace(metname)<<"charge comparison GlbSta: "<<residualsHisto->getBinContent(2)/double(residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2))<<endl;
906  if(residualsHisto->getBinContent(2)/double(residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2)) < resChargeLimit_glbSta)
907  residualsSummaryMap->setBinContent(2, 4, 1);
908  else
909  residualsSummaryMap->setBinContent(2, 4, 0);
910  }
911  if(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6)!=0){
912  LogTrace(metname)<<"charge comparison TkSta: "<<residualsHisto->getBinContent(6)/double(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6))<<endl;
913  if(residualsHisto->getBinContent(6)/double(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6)) < resChargeLimit_tkSta)
914  residualsSummaryMap->setBinContent(3, 4, 1);
915  else
916  residualsSummaryMap->setBinContent(3, 4, 0);
917  }
918  }
919  }
920 
921 }
922 
923 void MuonTestSummary::doMuonIDTests(){
924 
925  vector<string> muType;
926  muType.push_back("GlobalMuons");
927  muType.push_back("TrackerMuons");
928 
929  for(int i=0; i<=1; i++){
930 
931  // num matches test
932  string path = "Muons/MuonIdDQM/" + muType[i] + "/hNumMatches";
933  MonitorElement * matchesHisto = dbe->get(path);
934 
935  if(matchesHisto){
936  TH1F * matchesHisto_root = matchesHisto->getTH1F();
937  if(matchesHisto_root->GetMaximumBin() >= numMatchedExpected_min && matchesHisto_root->GetMaximumBin() <= numMatchedExpected_max)
938  muonIdSummaryMap->setBinContent(i+1,1,1);
939  else
940  muonIdSummaryMap->setBinContent(i+1,1,0);
941  }
942 
943 
944  // num of 0 associated segments
945  double numOneSegm_dt = 0;
946  int numHistos_dt=0;
947  int numHistos_csc=0;
948  MonitorElement * DT1Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT1NumSegments");
949  if(DT1Histo)
950  {numHistos_dt++;
951  if(DT1Histo->getEntries()!=0) numOneSegm_dt+=double(DT1Histo->getBinContent(2))/double(DT1Histo->getEntries());}
952  MonitorElement * DT2Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT2NumSegments");
953  if(DT2Histo)
954  {numHistos_dt++;
955  if(DT2Histo->getEntries()!=0) numOneSegm_dt+=double(DT2Histo->getBinContent(2))/double(DT2Histo->getEntries());}
956  MonitorElement * DT3Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT3NumSegments");
957  if(DT3Histo)
958  {numHistos_dt++;
959  if(DT3Histo->getEntries()!=0) numOneSegm_dt+=double(DT3Histo->getBinContent(2))/double(DT3Histo->getEntries());}
960  MonitorElement * DT4Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT4NumSegments");
961  if(DT4Histo)
962  {numHistos_dt++;
963  if(DT4Histo->getEntries()!=0) numOneSegm_dt+=double(DT4Histo->getBinContent(2))/double(DT4Histo->getEntries());}
964  double fraction_dt=0;
965  if(numOneSegm_dt!=0){
966  fraction_dt = numOneSegm_dt/double(numHistos_dt);
967  LogTrace(metname)<<"fraction_dt: "<<fraction_dt<<" for "<<muType[i]<<endl;
968  }
969 
970  double numOneSegm_csc = 0;
971  MonitorElement * CSC1Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC1NumSegments");
972  if(CSC1Histo)
973  {numHistos_csc++;
974  if(CSC1Histo->getEntries()!=0) numOneSegm_csc+=double(CSC1Histo->getBinContent(2))/double(CSC1Histo->getEntries());}
975  MonitorElement * CSC2Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC2NumSegments");
976  if(CSC2Histo)
977  {numHistos_csc++;
978  if(CSC2Histo->getEntries()!=0) numOneSegm_csc+=double(CSC2Histo->getBinContent(2))/double(CSC2Histo->getEntries());}
979  MonitorElement * CSC3Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC3NumSegments");
980  if(CSC3Histo)
981  {numHistos_csc++;
982  if(CSC3Histo->getEntries()!=0) numOneSegm_csc+=double(CSC3Histo->getBinContent(2))/double(CSC3Histo->getEntries());}
983  MonitorElement * CSC4Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC4NumSegments");
984  if(CSC4Histo)
985  {numHistos_csc++;
986  if(CSC4Histo->getEntries()!=0) numOneSegm_csc+=double(CSC4Histo->getBinContent(2))/double(CSC4Histo->getEntries());}
987  double fraction_csc=0;
988  if(numOneSegm_csc!=0){
989  fraction_csc = numOneSegm_csc/double(numHistos_csc);
990  LogTrace(metname)<<"fraction_csc: "<<fraction_csc<<" for "<<muType[i]<<endl;
991  }
992 
993 
994 
995  //--GH modified
996 
997  if(fraction_dt>matchesFractionDt_min && fraction_dt<matchesFractionDt_max)
998  muonIdSummaryMap->setBinContent(2*i+1,1,1);
999  else
1000  muonIdSummaryMap->setBinContent(2*i+1,1,0);
1001 
1002  if(fraction_csc>matchesFractionCsc_min && fraction_csc<matchesFractionCsc_max)
1003  muonIdSummaryMap->setBinContent(2*i+2,1,1);
1004  else
1005  muonIdSummaryMap->setBinContent(2*i+2,1,0);
1006 
1007 
1008 
1009  //--GH modified
1010 
1011  // residuals test
1012  vector<string> DTXresHistos, DTYresHistos, CSCXresHistos, CSCYresHistos;
1013  DTXresHistos.push_back("hDT1Pullx");
1014  DTXresHistos.push_back("hDT2Pullx");
1015  DTXresHistos.push_back("hDT3Pullx");
1016  DTXresHistos.push_back("hDT4Pullx");
1017 
1018  DTYresHistos.push_back("hDT1Pully");
1019  DTYresHistos.push_back("hDT2Pully");
1020  DTYresHistos.push_back("hDT3Pully");
1021 
1022  CSCXresHistos.push_back("hCSC1Pullx");
1023  CSCXresHistos.push_back("hCSC2Pullx");
1024  CSCXresHistos.push_back("hCSC3Pullx");
1025  CSCXresHistos.push_back("hCSC4Pullx");
1026 
1027  CSCYresHistos.push_back("hCSC1Pully");
1028  CSCYresHistos.push_back("hCSC2Pully");
1029  CSCYresHistos.push_back("hCSC3Pully");
1030  CSCYresHistos.push_back("hCSC4Pully");
1031 
1032  int numPlot_dtX, numPlot_dtY, numPlot_cscX, numPlot_cscY;
1033  double dtSigmaX, dtSigmaY, cscSigmaX, cscSigmaY;
1034  double dtSigmaX_err, dtSigmaY_err, cscSigmaX_err, cscSigmaY_err;
1035  double dtMeanX, dtMeanY, cscMeanX, cscMeanY;
1036  double dtMeanX_err, dtMeanY_err, cscMeanX_err, cscMeanY_err;
1037  MuonTestSummary::ResidualCheck(muType[i], DTXresHistos, numPlot_dtX, dtMeanX, dtMeanX_err, dtSigmaX, dtSigmaX_err);
1038  MuonTestSummary::ResidualCheck(muType[i], DTYresHistos, numPlot_dtY, dtMeanY, dtMeanY_err, dtSigmaY, dtSigmaY_err);
1039  MuonTestSummary::ResidualCheck(muType[i], CSCXresHistos, numPlot_cscX, cscMeanX, cscMeanX_err, cscSigmaX, cscSigmaX_err);
1040  MuonTestSummary::ResidualCheck(muType[i], CSCYresHistos, numPlot_cscY, cscMeanY, cscMeanY_err, cscSigmaY, cscSigmaY_err);
1041 
1042 
1043  LogTrace(metname)<<"DT mean must be between: "<<resSegmTrack_mean_min <<" and "<<resSegmTrack_mean_max<<endl;
1044  LogTrace(metname)<<"DT rms must be between: "<<resSegmTrack_rms_min <<" and "<<resSegmTrack_rms_max<<endl;
1045  LogTrace(metname)<<"DT X residual "<< muType[i]<<" mean: " << dtMeanX<<" +- "<< dtMeanX_err
1046  <<", sigma: "<< dtSigmaX <<" +- "<<dtSigmaX_err<< endl;
1047  LogTrace(metname)<<"DT Y residual "<< muType[i]<<" mean: " << dtMeanY<<" +- "<< dtMeanY_err
1048  <<", sigma: "<< dtSigmaY <<" +- "<<dtSigmaY_err<< endl;
1049  LogTrace(metname)<<"CSC X residual "<< muType[i]<<" mean: " << cscMeanX<<" +- "<< cscMeanX_err
1050  <<", sigma: "<< cscSigmaX <<" +- "<<cscSigmaX_err<< endl;
1051  LogTrace(metname)<<"CSC Y residual "<< muType[i]<<" mean: " << cscMeanY<<" +- "<< cscMeanY_err
1052  <<", sigma: "<< cscSigmaY <<" +- "<<cscSigmaY_err<< endl;
1053 
1054 
1055  //require the mean and rms to be within nsig sigma of preferred range;
1056  const int nsig=2;
1057  if(numPlot_dtX > 0 ) {
1058  if( dtMeanX + nsig*dtMeanX_err>resSegmTrack_mean_min &&
1059  dtMeanX - nsig*dtMeanX_err<resSegmTrack_mean_max)
1060  muonIdSummaryMap->setBinContent(2*i+1,2,1);
1061  else
1062  muonIdSummaryMap->setBinContent(2*i+1,2,0);
1063 
1064  if( dtSigmaX + nsig*dtSigmaX_err>resSegmTrack_rms_min &&
1065  dtSigmaX - nsig*dtSigmaX_err<resSegmTrack_rms_max)
1066  muonIdSummaryMap->setBinContent(2*i+1,3,1);
1067  else
1068  muonIdSummaryMap->setBinContent(2*i+1,3,0);
1069  }
1070  if(numPlot_dtY > 0 ){
1071  if( dtMeanY + nsig*dtMeanY_err>resSegmTrack_mean_min &&
1072  dtMeanY - nsig*dtMeanY_err<resSegmTrack_mean_max)
1073  muonIdSummaryMap->setBinContent(2*i+1,4,1);
1074  else
1075  muonIdSummaryMap->setBinContent(2*i+1,4,0);
1076 
1077  if( dtSigmaY + nsig*dtSigmaY_err>resSegmTrack_rms_min &&
1078  dtSigmaY - nsig*dtSigmaX_err<resSegmTrack_rms_max)
1079  muonIdSummaryMap->setBinContent(2*i+1,5,1);
1080  else
1081  muonIdSummaryMap->setBinContent(2*i+1,5,0);
1082  }
1083 
1084 
1085  if(numPlot_cscX > 0 ) {
1086  if( cscMeanX + nsig*cscMeanX_err>resSegmTrack_mean_min &&
1087  cscMeanX - nsig*cscMeanX_err<resSegmTrack_mean_max)
1088  muonIdSummaryMap->setBinContent(2*i+2,2,1);
1089  else
1090  muonIdSummaryMap->setBinContent(2*i+2,2,0);
1091 
1092  if( cscSigmaX + nsig*cscSigmaX_err>resSegmTrack_rms_min &&
1093  cscSigmaX - nsig*cscSigmaX_err<resSegmTrack_rms_max)
1094  muonIdSummaryMap->setBinContent(2*i+2,3,1);
1095  else
1096  muonIdSummaryMap->setBinContent(2*i+2,3,0);
1097  }
1098  if(numPlot_cscY > 0 ){
1099  if( cscMeanY + nsig*cscMeanY_err>resSegmTrack_mean_min &&
1100  cscMeanY - nsig*cscMeanY_err<resSegmTrack_mean_max)
1101  muonIdSummaryMap->setBinContent(2*i+2,4,1);
1102  else
1103  muonIdSummaryMap->setBinContent(2*i+2,4,0);
1104 
1105  if( cscSigmaY + nsig*cscSigmaY_err>resSegmTrack_rms_min &&
1106  cscSigmaY - nsig*cscSigmaY_err<resSegmTrack_rms_max)
1107  muonIdSummaryMap->setBinContent(2*i+2,5,1);
1108  else
1109  muonIdSummaryMap->setBinContent(2*i+2,5,0);
1110  }
1111 
1112  //---- end of modification
1113 
1114 
1115  }
1116 
1117 }
1118 
1119 void MuonTestSummary::ResidualCheck(std::string muType, std::vector<std::string> resHistos, int &numPlot, double &Mean, double &Mean_err, double &Sigma, double &Sigma_err){
1120 
1121  numPlot=0;
1122  Mean=0;
1123  Mean_err=0;
1124  Sigma=0;
1125  Sigma_err=0;
1126  for(uint name=0; name<resHistos.size(); name++){
1127  MonitorElement * resHisto = dbe->get("Muons/MuonIdDQM/" + muType + "/"+resHistos[name]);
1128 
1129  if(resHisto){
1130  TH1F * resHisto_root = resHisto->getTH1F();
1131  if(resHisto_root->GetEntries() < 20) {
1132  LogTrace(metname) << "[MuonTestSummary]: Test of "<< muType<<" for " <<resHistos[name]<< " not performed because # entries < 20 ";
1133  continue;
1134  }
1135 
1136  //we also want to check if the peak is away from zero.
1137  //so, try fitting in 3 sigma around the histogram mean.
1138  //alternatively, could use the maximum bin (less sensitive to 1-sided tails).
1139  // float mean = resHisto_root->GetMean();
1140  float mean = resHisto_root->GetBinLowEdge(resHisto_root->GetMaximumBin());
1141  TF1 *gfit = new TF1("Gaussian","gaus",mean-3,mean+3);
1142 
1143 
1144  try {
1145  resHisto_root->Fit(gfit, "Q0");
1146  } catch (...) {
1147  edm::LogError (metname)<< "[MuonTestSummary]: Exception when fitting "<<resHistos[name];
1148  }
1149  if(gfit){
1150  double mean = gfit->GetParameter(1);
1151  double mean_err = gfit->GetParError(1);
1152  double sigma = gfit->GetParameter(2);
1153  double sigma_err = gfit->GetParError(2);
1154  LogTrace(metname)<<"meanRes: "<<mean<<" +- "<<mean_err<<" for "<<resHistos[name]<<endl;
1155  LogTrace(metname)<<"sigmaRes: "<<sigma<<" +- "<<sigma_err<<" for "<<resHistos[name]<<endl;
1156 
1157  Mean+=mean;
1158  Mean_err +=mean_err * mean_err;
1159  Sigma+=sigma;
1160  Sigma_err +=sigma_err * sigma_err;
1161  numPlot++;
1162  } //if gfit? why would we not have gfit?
1163 
1164  }//histogram exists...
1165  } // loop over residuals histos
1166 
1167 
1168  if(numPlot==0){ //eg no stats
1169  Mean_err = 1;
1170  Mean=1;
1171  Sigma_err =1;
1172  Sigma = 1;
1173  }
1174  else{
1175  Mean_err = sqrt(Mean_err);
1176  Mean_err/=numPlot;
1177  Mean/=numPlot;
1178 
1179  Sigma_err = sqrt(Sigma_err);
1180  Sigma_err/=numPlot;
1181  Sigma/=numPlot;
1182  }
1183  return;
1184 
1185 }
1186 
1187 
1188 
1189 
1190 
1191 void MuonTestSummary::doEnergyTests(string histname, string muonType, int binNumber){
1192 
1193  // num matches test
1194  string path = "Muons/MuonEnergyDepositAnalyzer/"+histname+muonType;
1195  MonitorElement * energyHisto = dbe->get(path);
1196  Double_t hPeak=-1, hFWHM=-1;
1197  if(energyHisto){
1198  TH1F * energyHisto_root = energyHisto->getTH1F();
1199 
1200  // Setting fit range and start values
1201  Double_t fitRange[2];
1202  Double_t startValues[4], parlimitslo[4], parlimitshi[4], fitPar[4], fitParErr[4];
1203 
1204  if (energyHisto->getEntries()>20){
1205  if(histname=="ecalS9PointingMuDepositedEnergy_"){
1206  fitRange[0]=0.04;
1207  fitRange[1]=3.0;
1208 
1209  startValues[0]=0.036; startValues[1]=0.193; startValues[2]=110.0; startValues[3]=0.06;
1210  parlimitslo[0]=0.0; parlimitslo[1]=0.; parlimitslo[2]=1.0; parlimitslo[3]=0.;
1211  parlimitshi[0]=0.05; parlimitshi[1]=0.5; parlimitshi[2]=80000.0; parlimitshi[3]=0.1;
1212 
1213  Double_t chisqr;
1214  Int_t ndf;
1215  TF1 *fit = langaufit(energyHisto_root,fitRange,startValues,parlimitslo,parlimitshi,fitPar,fitParErr,&chisqr,&ndf);
1216  if(fit){
1217  langaupro(fitPar,hPeak,hFWHM);
1218  LogTrace(metname)<<"hPeak from langau fit: "<<hPeak<<" for: "<<histname+muonType<<endl;
1219  LogTrace(metname)<<"hFWHM from langau fit: "<<hFWHM<<" for: "<<histname+muonType<<endl;
1220  }
1221  }
1222 
1223  if(histname=="hadS9PointingMuDepositedEnergy_"){
1224  fitRange[0]=0.0;
1225  fitRange[1]=7.0;
1226 
1227  startValues[0]=2.0; startValues[1]=2.4; startValues[2]=110.0; startValues[3]=4.0;
1228  parlimitslo[0]=0.0; parlimitslo[1]=0.; parlimitslo[2]=1.0; parlimitslo[3]=0.;
1229  parlimitshi[0]=4.0; parlimitshi[1]=4.0; parlimitshi[2]=80000.0; parlimitshi[3]=8.0;
1230 
1231  Double_t chisqr;
1232  Int_t ndf;
1233  TF1 *fit = langaufit(energyHisto_root,fitRange,startValues,parlimitslo,parlimitshi,fitPar,fitParErr,&chisqr,&ndf);
1234  if(fit){
1235  langaupro(fitPar,hPeak,hFWHM);
1236  LogTrace(metname)<<"hPeak from langau fit: "<<hPeak<<" for: "<<histname+muonType<<endl;
1237  LogTrace(metname)<<"hFWHM from langau fit: "<<hFWHM<<" for: "<<histname+muonType<<endl;
1238  }
1239  }
1240  }
1241  else{
1242  LogTrace(metname) << "[MuonTestSummary]: Test of Energy for "<< histname+muonType << " not performed because # entries < 20 ";
1243  }
1244  }
1245 
1246  if(histname=="ecalS9PointingMuDepositedEnergy_" && hPeak>expPeakEcalS9_min && hPeak<expPeakEcalS9_max)
1247  energySummaryMap->setBinContent(binNumber,1, 1);
1248  if(histname=="ecalS9PointingMuDepositedEnergy_" && (hPeak!=-1) &&!(hPeak>expPeakEcalS9_min && hPeak<expPeakEcalS9_max))
1249  energySummaryMap->setBinContent(binNumber,1, 0);
1250 
1251  if(histname=="hadS9PointingMuDepositedEnergy_" && hPeak>expPeakHadS9_min && hPeak<expPeakHadS9_max)
1252  energySummaryMap->setBinContent(binNumber,2, 1);
1253  if(histname=="hadS9PointingMuDepositedEnergy_" && (hPeak!=-1) && !(hPeak>expPeakHadS9_min && hPeak<expPeakHadS9_max))
1254  energySummaryMap->setBinContent(binNumber,2, 0);
1255 
1256  //missing test on ho distributions
1257 }
1258 
1259 
1260 void MuonTestSummary::doMultiplicityTests(){
1261 
1262  MonitorElement* multiplicityHisto = dbe->get("Muons/MuonRecoAnalyzer/muReco");
1263 
1264  if(multiplicityHisto){
1265  if(multiplicityHisto->getEntries()>20){
1266  double multiplicity_GLB = double(multiplicityHisto->getBinContent(1)+multiplicityHisto->getBinContent(2))/double(multiplicityHisto->getEntries());
1267  LogTrace(metname)<<"multiplicity_GLB: "<<multiplicity_GLB<< " ExpMultiplicityGlb_min " <<expMultiplicityGlb_min <<" ExpMultiplicityGlb_max " <<expMultiplicityGlb_max<<endl;
1268  double multiplicity_TK = double(multiplicityHisto->getBinContent(3)+multiplicityHisto->getBinContent(4))/double(multiplicityHisto->getEntries());
1269  LogTrace(metname)<<"multiplicity_TK: "<<multiplicity_TK<< " ExpMultiplicityTk_min " <<expMultiplicityTk_min <<" ExpMultiplicityTk_max " <<expMultiplicityTk_max<<endl;
1270  double multiplicity_STA = double(multiplicityHisto->getBinContent(3)+multiplicityHisto->getBinContent(5))/double(multiplicityHisto->getEntries());
1271  LogTrace(metname)<<"multiplicity_STA: "<<multiplicity_STA<< " ExpMultiplicitySta_min " <<expMultiplicitySta_min <<" ExpMultiplicitySta_max " <<expMultiplicitySta_max<<endl;
1272 
1273  if(multiplicity_GLB>expMultiplicityGlb_min && multiplicity_GLB<expMultiplicityGlb_max)
1274  multiplicitySummaryMap->setBinContent(1,1);
1275  else
1276  multiplicitySummaryMap->setBinContent(1,0);
1277 
1278  if(multiplicity_TK>expMultiplicityTk_min && multiplicity_TK<expMultiplicityTk_max)
1279  multiplicitySummaryMap->setBinContent(2,1);
1280  else
1281  multiplicitySummaryMap->setBinContent(2,0);
1282 
1283  if(multiplicity_STA>expMultiplicitySta_min && multiplicity_STA<expMultiplicitySta_max)
1284  multiplicitySummaryMap->setBinContent(3,1);
1285  else
1286  multiplicitySummaryMap->setBinContent(3,0);
1287  }
1288  else{
1289  LogTrace(metname) << "[MuonTestSummary]: Test of Multiplicity not performed because # entries < 20 ";
1290  }
1291  }
1292 
1293 }
type
type
Definition: HCALResponse.h:22
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
i
int i
Definition: DBlmapReader.cc:9
MonitorElement::getQReport
const QReport * getQReport(const std::string &qtname) const
get QReport corresponding to &lt;qtname&gt; (null pointer if QReport does not exist)
Definition: MonitorElement.cc:545
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:47
MonitorElement::getEntries
double getEntries(void) const
get # of entries
Definition: MonitorElement.cc:748
MonitorElement::getMean
double getMean(int axis=1) const
get mean value of histogram along x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:669
QReport::getMessage
const std::string & getMessage(void) const
get message attached to test
Definition: QReport.h:24
MuonTestSummary::endLuminosityBlock
void endLuminosityBlock(edm::LuminosityBlock const &lumiSeg, edm::EventSetup const &c)
Diagnostic.
Definition: MuonTestSummary.cc:300
scaleCards.path
list path
Definition: scaleCards.py:51
MuonTestSummary::~MuonTestSummary
virtual ~MuonTestSummary()
Destructor.
Definition: MuonTestSummary.cc:74
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:46
j
int j
Definition: DBlmapReader.cc:9
QReport::getStatus
int getStatus(void) const
get test status (see Core/interface/QTestStatus.h)
Definition: QReport.h:16
MuonTestSummary::ResidualCheck
void ResidualCheck(std::string muType, std::vector< std::string > resHistos, int &numPlot, double &Mean, double &Mean_err, double &Sigma, double &Sigma_err)
Definition: MuonTestSummary.cc:1119
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
MuonTestSummary::beginRun
void beginRun(edm::Run const &run, edm::EventSetup const &eSetup)
Histograms initialisation.
Definition: MuonTestSummary.cc:250
RooFit::Sigma
Double_t Sigma(double mHreq, TString proc)
langaupro
int32_t langaupro(double *params, double &maxx, double &FWHM)
Definition: fitUtilities.h:120
MuonTestSummary::endRun
void endRun(edm::Run const &run, edm::EventSetup const &eSetup)
Definition: MuonTestSummary.cc:306
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1486
MuonTestSummary::doEnergyTests
void doEnergyTests(std::string nameHisto, std::string muonType, int bin)
Definition: MuonTestSummary.cc:1191
QReport::getQTresult
float getQTresult(void) const
get test result i.e. prob value
Definition: QReport.h:20
MuonTestSummary::doResidualsTests
void doResidualsTests(std::string type, std::string parameter, int bin)
Definition: MuonTestSummary.cc:817
MonitorElement::getBinContent
double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:712
MonitorElement::getRMS
double getRMS(int axis=1) const
get RMS of histogram along x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:682
MuonTestSummary::GaussFit
void GaussFit(std::string type, std::string parameter, MonitorElement *Histo, float &mean, float &mean_err, float &sigma, float &sigma_err)
Definition: MuonTestSummary.cc:780
MuonTestSummary::beginLuminosityBlock
void beginLuminosityBlock(edm::LuminosityBlock const &lumiSeg, edm::EventSetup const &c)
Definition: MuonTestSummary.cc:296
MuonTestSummary::beginJob
void beginJob(void)
BeginJob.
Definition: MuonTestSummary.cc:76
MuonTestSummary::MuonTestSummary
MuonTestSummary(const edm::ParameterSet &ps)
Constructor.
Definition: MuonTestSummary.cc:30
edm::Run
Definition: Run.h:33
MuonTestSummary::doKinematicsTests
void doKinematicsTests(std::string muonType, int bin)
test operations
Definition: MuonTestSummary.cc:523
Generated for CMSSW Reference Manual by doxygen 1.8.5