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: 2013/05/30 22:14:15 $
6  * $Revision: 1.34 $
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 (cms::Exception& iException) {
791  edm::LogError (metname)<< "[MuonTestSummary]: Exception when fitting Res_"<<type<<"_"<<parameter;
792  mean=1;
793  mean_err=1;
794  sigma=1;
795  sigma_err=1;
796  return;
797  }
798  if(gfit){
799  mean = gfit->GetParameter(1);
800  mean_err = gfit->GetParErrors()[2];
801  sigma = gfit->GetParameter(2);
802  sigma_err = gfit->GetParErrors()[2];
803  LogTrace(metname)<<"Gaussian fit mean: "<<mean<<" +- "<<mean_err<<" for "<<type<<"_"<<parameter<<endl;
804  LogTrace(metname)<<"Gaussina fit sigma: "<<sigma<<" +- "<<sigma_err<<" for "<<type<<"_"<<parameter<<endl;
805  }
806  }
807  else{
808  LogTrace(metname) << "[MuonTestSummary]: Test of Res_"<<type<<"_"<<parameter<< " not performed because # entries < 20 ";
809  //auto-pass if not enough events.
810  mean=1;
811  mean_err=1;
812  sigma=1;
813  sigma_err=1;
814  }
815 }
816 
817 
818 
819 
820 
821 
822 void MuonTestSummary::doResidualsTests(string type, string parameter, int bin){
823 
824  // residuals test
825  if(type!="GlbMuon"){
826  string path = "Muons/MuonRecoAnalyzer/Res_" + type + "_" + parameter;
827  MonitorElement * residualsHisto = dbe->get(path);
828 
829  float mean = -1;
830  float mean_err = -1;
831  float sigma = -1;
832  float sigma_err = -1;
833 
834  if(residualsHisto){
835 
836  LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of Res_"<<type<<"_"<<parameter<< endl;
837  GaussFit( type, parameter, residualsHisto, mean, mean_err, sigma, sigma_err);
838 
839  if(sigma!=-1 && parameter=="eta" && type=="TkGlb"){
840  if(sigma-sigma_err<resEtaSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 1, 1);
841  else residualsSummaryMap->setBinContent(bin, 1, 0);
842  }
843  if(sigma!=-1 && parameter=="eta" && (type=="GlbSta" || type=="TkSta")) {
844  if(sigma-sigma_err<resEtaSpread_glbSta) residualsSummaryMap->setBinContent(bin, 1, 1);
845  else residualsSummaryMap->setBinContent(bin, 1, 0);
846  }
847  if(sigma!=-1 && parameter=="phi" && type=="TkGlb"){
848  if(sigma-sigma_err<resPhiSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 2, 1);
849  else residualsSummaryMap->setBinContent(bin, 2, 0);
850  }
851  if(sigma!=-1 && parameter=="phi" && (type=="GlbSta" || type=="TkSta")){
852  if(sigma-sigma_err<resPhiSpread_glbSta) residualsSummaryMap->setBinContent(bin, 2, 1);
853  else residualsSummaryMap->setBinContent(bin, 2, 0);
854  }
855  if(sigma!=-1 && parameter=="oneOverp" && type=="TkGlb"){
856  if(sigma-sigma_err<resOneOvPSpread_tkGlb) residualsSummaryMap->setBinContent(bin, 3, 1);
857  else residualsSummaryMap->setBinContent(bin, 3, 0);
858  }
859  if(sigma!=-1 && parameter=="oneOverp" && (type=="GlbSta" || type=="TkSta")) {
860  if(sigma-sigma_err<resOneOvPSpread_glbSta) residualsSummaryMap->setBinContent(bin, 3, 1);
861  else residualsSummaryMap->setBinContent(bin, 3, 0);
862  }
863  }
864 
865 
866 
867  //--GH modified
868  if(type=="TkSta"){
869  //look at the pull:
870  string path = "Muons/MuonRecoAnalyzer/Pull_" + type + "_" + parameter;
871  MonitorElement * pullHisto = dbe->get(path);
872 
873  if(pullHisto){
874 
875  LogTrace(metname) << "[MuonTestSummary]: Starting Gaussian fit for Test of Pull_"<<type<<"_"<<parameter<< endl;
876  GaussFit( type, parameter, pullHisto, mean, mean_err, sigma, sigma_err);
877 
878  if(sigma!=-1 && parameter=="eta" ){
879  if(sigma-sigma_err<pullEtaSpread) residualsSummaryMap->setBinContent(4, 1, 1);
880  else residualsSummaryMap->setBinContent(4, 1, 0);
881  }
882  if(sigma!=-1 && parameter=="phi"){
883  if(sigma-sigma_err<pullPhiSpread) residualsSummaryMap->setBinContent(4, 2, 1);
884  else residualsSummaryMap->setBinContent(4, 2, 0);
885  }
886  if(sigma!=-1 && parameter=="oneOverp"){
887  if(sigma-sigma_err<pullOneOvPSpread) residualsSummaryMap->setBinContent(4, 3, 1);
888  else residualsSummaryMap->setBinContent(4, 3, 0);
889  }
890 
891  }//have pull histo
892  } //TkSta muons
893  }
894 
895  //this part for Global Muons:
896  else{
897  string path = "Muons/MuonRecoAnalyzer/" + type + "_" + parameter;
898  MonitorElement * residualsHisto = dbe->get(path);
899 
900  if(residualsHisto){
901  LogTrace(metname) << "[MuonTestSummary]: Test of Charge Comparison "<<type<<"_"<<parameter<< endl;
902  if((residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4))!=0){
903  LogTrace(metname)<<"Charge comparison TkGlb: "<<residualsHisto->getBinContent(4)/double(residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4))<<endl;
904  if(residualsHisto->getBinContent(4)/double(residualsHisto->getBinContent(3)+residualsHisto->getBinContent(4)) < resChargeLimit_tkGlb)
905  residualsSummaryMap->setBinContent(1, 4, 1);
906  else
907  residualsSummaryMap->setBinContent(1, 4, 0);
908  }
909  if((residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2))!=0){
910  LogTrace(metname)<<"charge comparison GlbSta: "<<residualsHisto->getBinContent(2)/double(residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2))<<endl;
911  if(residualsHisto->getBinContent(2)/double(residualsHisto->getBinContent(1)+residualsHisto->getBinContent(2)) < resChargeLimit_glbSta)
912  residualsSummaryMap->setBinContent(2, 4, 1);
913  else
914  residualsSummaryMap->setBinContent(2, 4, 0);
915  }
916  if(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6)!=0){
917  LogTrace(metname)<<"charge comparison TkSta: "<<residualsHisto->getBinContent(6)/double(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6))<<endl;
918  if(residualsHisto->getBinContent(6)/double(residualsHisto->getBinContent(5)+residualsHisto->getBinContent(6)) < resChargeLimit_tkSta)
919  residualsSummaryMap->setBinContent(3, 4, 1);
920  else
921  residualsSummaryMap->setBinContent(3, 4, 0);
922  }
923  }
924  }
925 
926 }
927 
928 void MuonTestSummary::doMuonIDTests(){
929 
930  vector<string> muType;
931  muType.push_back("GlobalMuons");
932  muType.push_back("TrackerMuons");
933 
934  for(int i=0; i<=1; i++){
935 
936  // num matches test
937  string path = "Muons/MuonIdDQM/" + muType[i] + "/hNumMatches";
938  MonitorElement * matchesHisto = dbe->get(path);
939 
940  if(matchesHisto){
941  TH1F * matchesHisto_root = matchesHisto->getTH1F();
942  if(matchesHisto_root->GetMaximumBin() >= numMatchedExpected_min && matchesHisto_root->GetMaximumBin() <= numMatchedExpected_max)
943  muonIdSummaryMap->setBinContent(i+1,1,1);
944  else
945  muonIdSummaryMap->setBinContent(i+1,1,0);
946  }
947 
948 
949  // num of 0 associated segments
950  double numOneSegm_dt = 0;
951  int numHistos_dt=0;
952  int numHistos_csc=0;
953  MonitorElement * DT1Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT1NumSegments");
954  if(DT1Histo)
955  {numHistos_dt++;
956  if(DT1Histo->getEntries()!=0) numOneSegm_dt+=double(DT1Histo->getBinContent(2))/double(DT1Histo->getEntries());}
957  MonitorElement * DT2Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT2NumSegments");
958  if(DT2Histo)
959  {numHistos_dt++;
960  if(DT2Histo->getEntries()!=0) numOneSegm_dt+=double(DT2Histo->getBinContent(2))/double(DT2Histo->getEntries());}
961  MonitorElement * DT3Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT3NumSegments");
962  if(DT3Histo)
963  {numHistos_dt++;
964  if(DT3Histo->getEntries()!=0) numOneSegm_dt+=double(DT3Histo->getBinContent(2))/double(DT3Histo->getEntries());}
965  MonitorElement * DT4Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hDT4NumSegments");
966  if(DT4Histo)
967  {numHistos_dt++;
968  if(DT4Histo->getEntries()!=0) numOneSegm_dt+=double(DT4Histo->getBinContent(2))/double(DT4Histo->getEntries());}
969  double fraction_dt=0;
970  if(numOneSegm_dt!=0){
971  fraction_dt = numOneSegm_dt/double(numHistos_dt);
972  LogTrace(metname)<<"fraction_dt: "<<fraction_dt<<" for "<<muType[i]<<endl;
973  }
974 
975  double numOneSegm_csc = 0;
976  MonitorElement * CSC1Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC1NumSegments");
977  if(CSC1Histo)
978  {numHistos_csc++;
979  if(CSC1Histo->getEntries()!=0) numOneSegm_csc+=double(CSC1Histo->getBinContent(2))/double(CSC1Histo->getEntries());}
980  MonitorElement * CSC2Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC2NumSegments");
981  if(CSC2Histo)
982  {numHistos_csc++;
983  if(CSC2Histo->getEntries()!=0) numOneSegm_csc+=double(CSC2Histo->getBinContent(2))/double(CSC2Histo->getEntries());}
984  MonitorElement * CSC3Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC3NumSegments");
985  if(CSC3Histo)
986  {numHistos_csc++;
987  if(CSC3Histo->getEntries()!=0) numOneSegm_csc+=double(CSC3Histo->getBinContent(2))/double(CSC3Histo->getEntries());}
988  MonitorElement * CSC4Histo = dbe->get("Muons/MuonIdDQM/" + muType[i] + "/hCSC4NumSegments");
989  if(CSC4Histo)
990  {numHistos_csc++;
991  if(CSC4Histo->getEntries()!=0) numOneSegm_csc+=double(CSC4Histo->getBinContent(2))/double(CSC4Histo->getEntries());}
992  double fraction_csc=0;
993  if(numOneSegm_csc!=0){
994  fraction_csc = numOneSegm_csc/double(numHistos_csc);
995  LogTrace(metname)<<"fraction_csc: "<<fraction_csc<<" for "<<muType[i]<<endl;
996  }
997 
998 
999 
1000  //--GH modified
1001 
1002  if(fraction_dt>matchesFractionDt_min && fraction_dt<matchesFractionDt_max)
1003  muonIdSummaryMap->setBinContent(2*i+1,1,1);
1004  else
1005  muonIdSummaryMap->setBinContent(2*i+1,1,0);
1006 
1007  if(fraction_csc>matchesFractionCsc_min && fraction_csc<matchesFractionCsc_max)
1008  muonIdSummaryMap->setBinContent(2*i+2,1,1);
1009  else
1010  muonIdSummaryMap->setBinContent(2*i+2,1,0);
1011 
1012 
1013 
1014  //--GH modified
1015 
1016  // residuals test
1017  vector<string> DTXresHistos, DTYresHistos, CSCXresHistos, CSCYresHistos;
1018  DTXresHistos.push_back("hDT1Pullx");
1019  DTXresHistos.push_back("hDT2Pullx");
1020  DTXresHistos.push_back("hDT3Pullx");
1021  DTXresHistos.push_back("hDT4Pullx");
1022 
1023  DTYresHistos.push_back("hDT1Pully");
1024  DTYresHistos.push_back("hDT2Pully");
1025  DTYresHistos.push_back("hDT3Pully");
1026 
1027  CSCXresHistos.push_back("hCSC1Pullx");
1028  CSCXresHistos.push_back("hCSC2Pullx");
1029  CSCXresHistos.push_back("hCSC3Pullx");
1030  CSCXresHistos.push_back("hCSC4Pullx");
1031 
1032  CSCYresHistos.push_back("hCSC1Pully");
1033  CSCYresHistos.push_back("hCSC2Pully");
1034  CSCYresHistos.push_back("hCSC3Pully");
1035  CSCYresHistos.push_back("hCSC4Pully");
1036 
1037  int numPlot_dtX, numPlot_dtY, numPlot_cscX, numPlot_cscY;
1038  double dtSigmaX, dtSigmaY, cscSigmaX, cscSigmaY;
1039  double dtSigmaX_err, dtSigmaY_err, cscSigmaX_err, cscSigmaY_err;
1040  double dtMeanX, dtMeanY, cscMeanX, cscMeanY;
1041  double dtMeanX_err, dtMeanY_err, cscMeanX_err, cscMeanY_err;
1042  MuonTestSummary::ResidualCheck(muType[i], DTXresHistos, numPlot_dtX, dtMeanX, dtMeanX_err, dtSigmaX, dtSigmaX_err);
1043  MuonTestSummary::ResidualCheck(muType[i], DTYresHistos, numPlot_dtY, dtMeanY, dtMeanY_err, dtSigmaY, dtSigmaY_err);
1044  MuonTestSummary::ResidualCheck(muType[i], CSCXresHistos, numPlot_cscX, cscMeanX, cscMeanX_err, cscSigmaX, cscSigmaX_err);
1045  MuonTestSummary::ResidualCheck(muType[i], CSCYresHistos, numPlot_cscY, cscMeanY, cscMeanY_err, cscSigmaY, cscSigmaY_err);
1046 
1047 
1048  LogTrace(metname)<<"DT mean must be between: "<<resSegmTrack_mean_min <<" and "<<resSegmTrack_mean_max<<endl;
1049  LogTrace(metname)<<"DT rms must be between: "<<resSegmTrack_rms_min <<" and "<<resSegmTrack_rms_max<<endl;
1050  LogTrace(metname)<<"DT X residual "<< muType[i]<<" mean: " << dtMeanX<<" +- "<< dtMeanX_err
1051  <<", sigma: "<< dtSigmaX <<" +- "<<dtSigmaX_err<< endl;
1052  LogTrace(metname)<<"DT Y residual "<< muType[i]<<" mean: " << dtMeanY<<" +- "<< dtMeanY_err
1053  <<", sigma: "<< dtSigmaY <<" +- "<<dtSigmaY_err<< endl;
1054  LogTrace(metname)<<"CSC X residual "<< muType[i]<<" mean: " << cscMeanX<<" +- "<< cscMeanX_err
1055  <<", sigma: "<< cscSigmaX <<" +- "<<cscSigmaX_err<< endl;
1056  LogTrace(metname)<<"CSC Y residual "<< muType[i]<<" mean: " << cscMeanY<<" +- "<< cscMeanY_err
1057  <<", sigma: "<< cscSigmaY <<" +- "<<cscSigmaY_err<< endl;
1058 
1059 
1060  //require the mean and rms to be within nsig sigma of preferred range;
1061  const int nsig=2;
1062  if(numPlot_dtX > 0 ) {
1063  if( dtMeanX + nsig*dtMeanX_err>resSegmTrack_mean_min &&
1064  dtMeanX - nsig*dtMeanX_err<resSegmTrack_mean_max)
1065  muonIdSummaryMap->setBinContent(2*i+1,2,1);
1066  else
1067  muonIdSummaryMap->setBinContent(2*i+1,2,0);
1068 
1069  if( dtSigmaX + nsig*dtSigmaX_err>resSegmTrack_rms_min &&
1070  dtSigmaX - nsig*dtSigmaX_err<resSegmTrack_rms_max)
1071  muonIdSummaryMap->setBinContent(2*i+1,3,1);
1072  else
1073  muonIdSummaryMap->setBinContent(2*i+1,3,0);
1074  }
1075  if(numPlot_dtY > 0 ){
1076  if( dtMeanY + nsig*dtMeanY_err>resSegmTrack_mean_min &&
1077  dtMeanY - nsig*dtMeanY_err<resSegmTrack_mean_max)
1078  muonIdSummaryMap->setBinContent(2*i+1,4,1);
1079  else
1080  muonIdSummaryMap->setBinContent(2*i+1,4,0);
1081 
1082  if( dtSigmaY + nsig*dtSigmaY_err>resSegmTrack_rms_min &&
1083  dtSigmaY - nsig*dtSigmaX_err<resSegmTrack_rms_max)
1084  muonIdSummaryMap->setBinContent(2*i+1,5,1);
1085  else
1086  muonIdSummaryMap->setBinContent(2*i+1,5,0);
1087  }
1088 
1089 
1090  if(numPlot_cscX > 0 ) {
1091  if( cscMeanX + nsig*cscMeanX_err>resSegmTrack_mean_min &&
1092  cscMeanX - nsig*cscMeanX_err<resSegmTrack_mean_max)
1093  muonIdSummaryMap->setBinContent(2*i+2,2,1);
1094  else
1095  muonIdSummaryMap->setBinContent(2*i+2,2,0);
1096 
1097  if( cscSigmaX + nsig*cscSigmaX_err>resSegmTrack_rms_min &&
1098  cscSigmaX - nsig*cscSigmaX_err<resSegmTrack_rms_max)
1099  muonIdSummaryMap->setBinContent(2*i+2,3,1);
1100  else
1101  muonIdSummaryMap->setBinContent(2*i+2,3,0);
1102  }
1103  if(numPlot_cscY > 0 ){
1104  if( cscMeanY + nsig*cscMeanY_err>resSegmTrack_mean_min &&
1105  cscMeanY - nsig*cscMeanY_err<resSegmTrack_mean_max)
1106  muonIdSummaryMap->setBinContent(2*i+2,4,1);
1107  else
1108  muonIdSummaryMap->setBinContent(2*i+2,4,0);
1109 
1110  if( cscSigmaY + nsig*cscSigmaY_err>resSegmTrack_rms_min &&
1111  cscSigmaY - nsig*cscSigmaY_err<resSegmTrack_rms_max)
1112  muonIdSummaryMap->setBinContent(2*i+2,5,1);
1113  else
1114  muonIdSummaryMap->setBinContent(2*i+2,5,0);
1115  }
1116 
1117  //---- end of modification
1118 
1119 
1120  }
1121 
1122 }
1123 
1124 void MuonTestSummary::ResidualCheck(std::string muType, const std::vector<std::string>& resHistos, int &numPlot, double &Mean, double &Mean_err, double &Sigma, double &Sigma_err){
1125 
1126  numPlot=0;
1127  Mean=0;
1128  Mean_err=0;
1129  Sigma=0;
1130  Sigma_err=0;
1131  for(uint name=0; name<resHistos.size(); name++){
1132  MonitorElement * resHisto = dbe->get("Muons/MuonIdDQM/" + muType + "/"+resHistos[name]);
1133 
1134  if(resHisto){
1135  TH1F * resHisto_root = resHisto->getTH1F();
1136  if(resHisto_root->GetEntries() < 20) {
1137  LogTrace(metname) << "[MuonTestSummary]: Test of "<< muType<<" for " <<resHistos[name]<< " not performed because # entries < 20 ";
1138  continue;
1139  }
1140 
1141  //we also want to check if the peak is away from zero.
1142  //so, try fitting in 3 sigma around the histogram mean.
1143  //alternatively, could use the maximum bin (less sensitive to 1-sided tails).
1144  // float mean = resHisto_root->GetMean();
1145  float mean = resHisto_root->GetBinLowEdge(resHisto_root->GetMaximumBin());
1146  TF1 *gfit = new TF1("Gaussian","gaus",mean-3,mean+3);
1147 
1148 
1149  try {
1150  resHisto_root->Fit(gfit, "Q0");
1151  } catch (cms::Exception& iException) {
1152  edm::LogError (metname)<< "[MuonTestSummary]: Exception when fitting "<<resHistos[name];
1153  continue;
1154  }
1155  if(gfit){
1156  double mean = gfit->GetParameter(1);
1157  double mean_err = gfit->GetParError(1);
1158  double sigma = gfit->GetParameter(2);
1159  double sigma_err = gfit->GetParError(2);
1160  LogTrace(metname)<<"meanRes: "<<mean<<" +- "<<mean_err<<" for "<<resHistos[name]<<endl;
1161  LogTrace(metname)<<"sigmaRes: "<<sigma<<" +- "<<sigma_err<<" for "<<resHistos[name]<<endl;
1162 
1163  Mean+=mean;
1164  Mean_err +=mean_err * mean_err;
1165  Sigma+=sigma;
1166  Sigma_err +=sigma_err * sigma_err;
1167  numPlot++;
1168  } //if gfit? why would we not have gfit?
1169 
1170  }//histogram exists...
1171  } // loop over residuals histos
1172 
1173 
1174  if(numPlot==0){ //eg no stats
1175  Mean_err = 1;
1176  Mean=1;
1177  Sigma_err =1;
1178  Sigma = 1;
1179  }
1180  else{
1181  Mean_err = sqrt(Mean_err);
1182  Mean_err/=numPlot;
1183  Mean/=numPlot;
1184 
1185  Sigma_err = sqrt(Sigma_err);
1186  Sigma_err/=numPlot;
1187  Sigma/=numPlot;
1188  }
1189  return;
1190 
1191 }
1192 
1193 
1194 
1195 
1196 
1197 void MuonTestSummary::doEnergyTests(string histname, string muonType, int binNumber){
1198 
1199  // num matches test
1200  string path = "Muons/MuonEnergyDepositAnalyzer/"+histname+muonType;
1201  MonitorElement * energyHisto = dbe->get(path);
1202  Double_t hPeak=-1, hFWHM=-1;
1203  if(energyHisto){
1204  TH1F * energyHisto_root = energyHisto->getTH1F();
1205 
1206  // Setting fit range and start values
1207  Double_t fitRange[2];
1208  Double_t startValues[4], parlimitslo[4], parlimitshi[4], fitPar[4], fitParErr[4];
1209 
1210  if (energyHisto->getEntries()>20){
1211  if(histname=="ecalS9PointingMuDepositedEnergy_"){
1212  fitRange[0]=0.04;
1213  fitRange[1]=3.0;
1214 
1215  startValues[0]=0.036; startValues[1]=0.193; startValues[2]=110.0; startValues[3]=0.06;
1216  parlimitslo[0]=0.0; parlimitslo[1]=0.; parlimitslo[2]=1.0; parlimitslo[3]=0.;
1217  parlimitshi[0]=0.05; parlimitshi[1]=0.5; parlimitshi[2]=80000.0; parlimitshi[3]=0.1;
1218 
1219  Double_t chisqr;
1220  Int_t ndf;
1221  TF1 *fit = langaufit(energyHisto_root,fitRange,startValues,parlimitslo,parlimitshi,fitPar,fitParErr,&chisqr,&ndf);
1222  if(fit){
1223  langaupro(fitPar,hPeak,hFWHM);
1224  LogTrace(metname)<<"hPeak from langau fit: "<<hPeak<<" for: "<<histname+muonType<<endl;
1225  LogTrace(metname)<<"hFWHM from langau fit: "<<hFWHM<<" for: "<<histname+muonType<<endl;
1226  }
1227  }
1228 
1229  if(histname=="hadS9PointingMuDepositedEnergy_"){
1230  fitRange[0]=0.0;
1231  fitRange[1]=7.0;
1232 
1233  startValues[0]=2.0; startValues[1]=2.4; startValues[2]=110.0; startValues[3]=4.0;
1234  parlimitslo[0]=0.0; parlimitslo[1]=0.; parlimitslo[2]=1.0; parlimitslo[3]=0.;
1235  parlimitshi[0]=4.0; parlimitshi[1]=4.0; parlimitshi[2]=80000.0; parlimitshi[3]=8.0;
1236 
1237  Double_t chisqr;
1238  Int_t ndf;
1239  TF1 *fit = langaufit(energyHisto_root,fitRange,startValues,parlimitslo,parlimitshi,fitPar,fitParErr,&chisqr,&ndf);
1240  if(fit){
1241  langaupro(fitPar,hPeak,hFWHM);
1242  LogTrace(metname)<<"hPeak from langau fit: "<<hPeak<<" for: "<<histname+muonType<<endl;
1243  LogTrace(metname)<<"hFWHM from langau fit: "<<hFWHM<<" for: "<<histname+muonType<<endl;
1244  }
1245  }
1246  }
1247  else{
1248  LogTrace(metname) << "[MuonTestSummary]: Test of Energy for "<< histname+muonType << " not performed because # entries < 20 ";
1249  }
1250  }
1251 
1252  if(histname=="ecalS9PointingMuDepositedEnergy_" && hPeak>expPeakEcalS9_min && hPeak<expPeakEcalS9_max)
1253  energySummaryMap->setBinContent(binNumber,1, 1);
1254  if(histname=="ecalS9PointingMuDepositedEnergy_" && (hPeak!=-1) &&!(hPeak>expPeakEcalS9_min && hPeak<expPeakEcalS9_max))
1255  energySummaryMap->setBinContent(binNumber,1, 0);
1256 
1257  if(histname=="hadS9PointingMuDepositedEnergy_" && hPeak>expPeakHadS9_min && hPeak<expPeakHadS9_max)
1258  energySummaryMap->setBinContent(binNumber,2, 1);
1259  if(histname=="hadS9PointingMuDepositedEnergy_" && (hPeak!=-1) && !(hPeak>expPeakHadS9_min && hPeak<expPeakHadS9_max))
1260  energySummaryMap->setBinContent(binNumber,2, 0);
1261 
1262  //missing test on ho distributions
1263 }
1264 
1265 
1266 void MuonTestSummary::doMultiplicityTests(){
1267 
1268  MonitorElement* multiplicityHisto = dbe->get("Muons/MuonRecoAnalyzer/muReco");
1269 
1270  if(multiplicityHisto){
1271  if(multiplicityHisto->getEntries()>20){
1272  double multiplicity_GLB = double(multiplicityHisto->getBinContent(1)+multiplicityHisto->getBinContent(2))/double(multiplicityHisto->getEntries());
1273  LogTrace(metname)<<"multiplicity_GLB: "<<multiplicity_GLB<< " ExpMultiplicityGlb_min " <<expMultiplicityGlb_min <<" ExpMultiplicityGlb_max " <<expMultiplicityGlb_max<<endl;
1274  double multiplicity_TK = double(multiplicityHisto->getBinContent(3)+multiplicityHisto->getBinContent(4))/double(multiplicityHisto->getEntries());
1275  LogTrace(metname)<<"multiplicity_TK: "<<multiplicity_TK<< " ExpMultiplicityTk_min " <<expMultiplicityTk_min <<" ExpMultiplicityTk_max " <<expMultiplicityTk_max<<endl;
1276  double multiplicity_STA = double(multiplicityHisto->getBinContent(3)+multiplicityHisto->getBinContent(5))/double(multiplicityHisto->getEntries());
1277  LogTrace(metname)<<"multiplicity_STA: "<<multiplicity_STA<< " ExpMultiplicitySta_min " <<expMultiplicitySta_min <<" ExpMultiplicitySta_max " <<expMultiplicitySta_max<<endl;
1278 
1279  if(multiplicity_GLB>expMultiplicityGlb_min && multiplicity_GLB<expMultiplicityGlb_max)
1280  multiplicitySummaryMap->setBinContent(1,1);
1281  else
1282  multiplicitySummaryMap->setBinContent(1,0);
1283 
1284  if(multiplicity_TK>expMultiplicityTk_min && multiplicity_TK<expMultiplicityTk_max)
1285  multiplicitySummaryMap->setBinContent(2,1);
1286  else
1287  multiplicitySummaryMap->setBinContent(2,0);
1288 
1289  if(multiplicity_STA>expMultiplicitySta_min && multiplicity_STA<expMultiplicitySta_max)
1290  multiplicitySummaryMap->setBinContent(3,1);
1291  else
1292  multiplicitySummaryMap->setBinContent(3,0);
1293  }
1294  else{
1295  LogTrace(metname) << "[MuonTestSummary]: Test of Multiplicity not performed because # entries < 20 ";
1296  }
1297  }
1298 
1299 }
type
type
Definition: HCALResponse.h:21
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
cuy.yBin
tuple yBin
Definition: cuy.py:891
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
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
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
MuonTestSummary::~MuonTestSummary
virtual ~MuonTestSummary()
Destructor.
Definition: MuonTestSummary.cc:74
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
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
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
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:1197
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:822
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::ResidualCheck
void ResidualCheck(std::string muType, const std::vector< std::string > &resHistos, int &numPlot, double &Mean, double &Mean_err, double &Sigma, double &Sigma_err)
Definition: MuonTestSummary.cc:1124
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:36
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