CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RPCEfficiencySecond.cc
Go to the documentation of this file.
1 /***************************************
2 Author:
3 Camilo Carrillo
4 Universidad de los Andes Bogota Colombia
5 camilo.carrilloATcern.ch
6 ****************************************/
7 
8 #include "DQM/RPCMonitorDigi/interface/utils.h"
9 #include "DQM/RPCMonitorClient/interface/RPCEfficiencySecond.h"
10 #include "DQM/RPCMonitorDigi/interface/RPCBookFolderStructure.h"
11 
12 // #include <memory>
13 // #include <string>
14 // #include <fstream>
15 // #include <iostream>
16 
17 #include "FWCore/Framework/interface/Frameworkfwd.h"
18 #include "FWCore/Framework/interface/EDAnalyzer.h"
19 #include "FWCore/Framework/interface/Event.h"
20 #include "FWCore/Framework/interface/MakerMacros.h"
21 #include "FWCore/Framework/interface/ESHandle.h"
22 #include "FWCore/ParameterSet/interface/ParameterSet.h"
23 
24 
25 #include <Geometry/RPCGeometry/interface/RPCGeometry.h>
26 #include <Geometry/RPCGeometry/interface/RPCGeomServ.h>
27 #include <Geometry/CommonDetUnit/interface/GeomDet.h>
28 #include <Geometry/Records/interface/MuonGeometryRecord.h>
29 
30 // #include <DataFormats/MuonDetId/interface/RPCDetId.h>
31 
32 // #include "DQMServices/Core/interface/MonitorElement.h"
33 
34 //#include "TH1F.h"
35 
36 
37 RPCEfficiencySecond::RPCEfficiencySecond(const edm::ParameterSet& iConfig){
38  SaveFile = iConfig.getUntrackedParameter<bool>("SaveFile", false);
39  NameFile = iConfig.getUntrackedParameter<std::string>("NameFile","RPCEfficiency.root");
40  folderPath = iConfig.getUntrackedParameter<std::string>("folderPath","RPC/RPCEfficiency/");
41  debug = iConfig.getUntrackedParameter<bool>("debug",false);
42  barrel = iConfig.getUntrackedParameter<bool>("barrel");
43  endcap = iConfig.getUntrackedParameter<bool>("endcap");
44 }
45 
46 RPCEfficiencySecond::~RPCEfficiencySecond(){}
47 
48 void RPCEfficiencySecond::beginRun(const edm::Run&, const edm::EventSetup& iSetup){
49 
50  dbe = edm::Service<DQMStore>().operator->();
51 
52 // if(debug) std::cout<<"Booking Residuals Barrel"<<std::endl;
53 // dbe->setCurrentFolder(folderPath+"ResidualsBarrel/");
54 
55  //Barrel
56 // hGlobal2ResClu1La1 = dbe->book1D("GlobalResidualsClu1La1","RPC Residuals Layer 1 Cluster Size 1",101,-10.,10.);
57 // hGlobal2ResClu1La2 = dbe->book1D("GlobalResidualsClu1La2","RPC Residuals Layer 2 Cluster Size 1",101,-10.,10.);
58 // hGlobal2ResClu1La3 = dbe->book1D("GlobalResidualsClu1La3","RPC Residuals Layer 3 Cluster Size 1",101,-10.,10.);
59 // hGlobal2ResClu1La4 = dbe->book1D("GlobalResidualsClu1La4","RPC Residuals Layer 4 Cluster Size 1",101,-10.,10.);
60 // hGlobal2ResClu1La5 = dbe->book1D("GlobalResidualsClu1La5","RPC Residuals Layer 5 Cluster Size 1",101,-10.,10.);
61 // hGlobal2ResClu1La6 = dbe->book1D("GlobalResidualsClu1La6","RPC Residuals Layer 6 Cluster Size 1",101,-10.,10.);
62 
63 // hGlobal2ResClu2La1 = dbe->book1D("GlobalResidualsClu2La1","RPC Residuals Layer 1 Cluster Size 2",101,-10.,10.);
64 // hGlobal2ResClu2La2 = dbe->book1D("GlobalResidualsClu2La2","RPC Residuals Layer 2 Cluster Size 2",101,-10.,10.);
65 // hGlobal2ResClu2La3 = dbe->book1D("GlobalResidualsClu2La3","RPC Residuals Layer 3 Cluster Size 2",101,-10.,10.);
66 // hGlobal2ResClu2La4 = dbe->book1D("GlobalResidualsClu2La4","RPC Residuals Layer 4 Cluster Size 2",101,-10.,10.);
67 // hGlobal2ResClu2La5 = dbe->book1D("GlobalResidualsClu2La5","RPC Residuals Layer 5 Cluster Size 2",101,-10.,10.);
68 // hGlobal2ResClu2La6 = dbe->book1D("GlobalResidualsClu2La6","RPC Residuals Layer 6 Cluster Size 2",101,-10.,10.);
69 
70 // hGlobal2ResClu3La1 = dbe->book1D("GlobalResidualsClu3La1","RPC Residuals Layer 1 Cluster Size 3",101,-10.,10.);
71 // hGlobal2ResClu3La2 = dbe->book1D("GlobalResidualsClu3La2","RPC Residuals Layer 2 Cluster Size 3",101,-10.,10.);
72 // hGlobal2ResClu3La3 = dbe->book1D("GlobalResidualsClu3La3","RPC Residuals Layer 3 Cluster Size 3",101,-10.,10.);
73 // hGlobal2ResClu3La4 = dbe->book1D("GlobalResidualsClu3La4","RPC Residuals Layer 4 Cluster Size 3",101,-10.,10.);
74 // hGlobal2ResClu3La5 = dbe->book1D("GlobalResidualsClu3La5","RPC Residuals Layer 5 Cluster Size 3",101,-10.,10.);
75 // hGlobal2ResClu3La6 = dbe->book1D("GlobalResidualsClu3La6","RPC Residuals Layer 6 Cluster Size 3",101,-10.,10.);
76 
77 // if(debug) std::cout<<"Booking Residuals EndCaps"<<std::endl;
78 // dbe->setCurrentFolder(folderPath+"ResidualsEndCaps/");
79 
80  //Endcap
81 // hGlobal2ResClu1R3C = dbe->book1D("GlobalResidualsClu1R3C","RPC Residuals Ring 3 Roll C Cluster Size 1",101,-10.,10.);
82 // hGlobal2ResClu1R3B = dbe->book1D("GlobalResidualsClu1R3B","RPC Residuals Ring 3 Roll B Cluster Size 1",101,-10.,10.);
83 // hGlobal2ResClu1R3A = dbe->book1D("GlobalResidualsClu1R3A","RPC Residuals Ring 3 Roll A Cluster Size 1",101,-10.,10.);
84 // hGlobal2ResClu1R2C = dbe->book1D("GlobalResidualsClu1R2C","RPC Residuals Ring 2 Roll C Cluster Size 1",101,-10.,10.);
85 // hGlobal2ResClu1R2B = dbe->book1D("GlobalResidualsClu1R2B","RPC Residuals Ring 2 Roll B Cluster Size 1",101,-10.,10.);
86 // hGlobal2ResClu1R2A = dbe->book1D("GlobalResidualsClu1R2A","RPC Residuals Ring 2 Roll A Cluster Size 1",101,-10.,10.);
87 
88 // hGlobal2ResClu2R3C = dbe->book1D("GlobalResidualsClu2R3C","RPC Residuals Ring 3 Roll C Cluster Size 2",101,-10.,10.);
89 // hGlobal2ResClu2R3B = dbe->book1D("GlobalResidualsClu2R3B","RPC Residuals Ring 3 Roll B Cluster Size 2",101,-10.,10.);
90 // hGlobal2ResClu2R3A = dbe->book1D("GlobalResidualsClu2R3A","RPC Residuals Ring 3 Roll A Cluster Size 2",101,-10.,10.);
91 // hGlobal2ResClu2R2C = dbe->book1D("GlobalResidualsClu2R2C","RPC Residuals Ring 2 Roll C Cluster Size 2",101,-10.,10.);
92 // hGlobal2ResClu2R2B = dbe->book1D("GlobalResidualsClu2R2B","RPC Residuals Ring 2 Roll B Cluster Size 2",101,-10.,10.);
93 // hGlobal2ResClu2R2A = dbe->book1D("GlobalResidualsClu2R2A","RPC Residuals Ring 2 Roll A Cluster Size 2",101,-10.,10.);
94 
95 // hGlobal2ResClu3R3C = dbe->book1D("GlobalResidualsClu3R3C","RPC Residuals Ring 3 Roll C Cluster Size 3",101,-10.,10.);
96 // hGlobal2ResClu3R3B = dbe->book1D("GlobalResidualsClu3R3B","RPC Residuals Ring 3 Roll B Cluster Size 3",101,-10.,10.);
97 // hGlobal2ResClu3R3A = dbe->book1D("GlobalResidualsClu3R3A","RPC Residuals Ring 3 Roll A Cluster Size 3",101,-10.,10.);
98 // hGlobal2ResClu3R2C = dbe->book1D("GlobalResidualsClu3R2C","RPC Residuals Ring 2 Roll C Cluster Size 3",101,-10.,10.);
99 // hGlobal2ResClu3R2B = dbe->book1D("GlobalResidualsClu3R2B","RPC Residuals Ring 2 Roll B Cluster Size 3",101,-10.,10.);
100 // hGlobal2ResClu3R2A = dbe->book1D("GlobalResidualsClu3R2A","RPC Residuals Ring 2 Roll A Cluster Size 3",101,-10.,10.);
101 
102 // if(debug) std::cout<<"Booking EffDistros"<<std::endl;
103 // dbe->setCurrentFolder(folderPath);
104 
105 // if(debug) std::cout<<"Booking statistics2"<<std::endl;
106 // dbe->setCurrentFolder(folderPath);
107 // statistics2 = dbe->book1D("AllStatistics","Analyzed Events DT and CSC Segments",33,0.5,33.5);
108 
109  //Barrel
110 
111  dbe->setCurrentFolder(folderPath+"Wheel_-2");
112  EffDistroWm2=dbe->book1D("EffDistroWheel_-2","Efficiency Distribution for Wheel -2 ",20,0.5,100.5);
113  //EffDistroWm2far=dbe->book1D("EffDistroWheel_-2far","Efficiency Distribution for Far Side Wheel -2 ",20,0.5,100.5);
114  EffGlobWm2=dbe->book1D("GlobEfficiencyWheel_-2","Efficiency Wheel -2 ",206,0.5,206.5);
115  //EffGlobWm2far=dbe->book1D("GlobEfficiencyWheel_-2far","Efficiency Far Side Wheel -2",105,0.5,105.5);
116  //BXGlobWm2= dbe->book1D("GlobBXWheel_-2near","BX Near Side Wheel -2",101,0.5,101.5);
117  //BXGlobWm2far= dbe->book1D("GlobBXWheel_-2far","BX Far Side Wheel -2",105,0.5,105.5);
118  //MaskedGlobWm2= dbe->book1D("GlobMaskedWheel_-2near","Masked Near Side Wheel -2",101,0.5,101.5);
119  //MaskedGlobWm2far= dbe->book1D("GlobMaskedWheel_-2far","Masked Far Side Wheel -2",105,0.5,105.5);
120  //AverageEffWm2=dbe->book1D("AverageEfficiencyWheel_-2near","Average Efficiency Near Side Wheel -2 ",101,0.5,101.5);
121  //AverageEffWm2far =dbe->book1D("AverageEfficiencyWheel_-2far","Average Efficiency Far Side Wheel -2 ",105,0.5,105.5);
122  //NoPredictionWm2=dbe->book1D("NoPredictionWheel_-2near","No Predictions Near Side Wheel -2 ",101,0.5,101.5);
123  //NoPredictionWm2far=dbe->book1D("NoPredictionWheel_-2far","No Predictions Efficiency Far Side Wheel -2 ",105,0.5,105.5);
124 
125  dbe->setCurrentFolder(folderPath+"Wheel_-1");
126  EffDistroWm1=dbe->book1D("EffDistroWheel_-1","Efficiency Distribution for Wheel -1 ",20,0.5,100.5);
127  //EffDistroWm1far=dbe->book1D("EffDistroWheel_-1far","Efficiency Distribution for Far Side Wheel -1 ",20,0.5,100.5);
128  EffGlobWm1= dbe->book1D("GlobEfficiencyWheel_-1","Efficiency Wheel -1",206,0.5,206.5);
129  //EffGlobWm1far=dbe->book1D("GlobEfficiencyWheel_-1far","Efficiency Far Side Wheel -1",105,0.5,105.5);
130  //BXGlobWm1= dbe->book1D("GlobBXWheel_-1near","BX Near Side Wheel -1",101,0.5,101.5);
131  //BXGlobWm1far= dbe->book1D("GlobBXWheel_-1far","BX Far Side Wheel -1",105,0.5,105.5);
132  //MaskedGlobWm1= dbe->book1D("GlobMaskedWheel_-1near","Masked Near Side Wheel -1",101,0.5,101.5);
133  //MaskedGlobWm1far= dbe->book1D("GlobMaskedWheel_-1far","Masked Far Side Wheel -1",105,0.5,105.5);
134  //AverageEffWm1=dbe->book1D("AverageEfficiencyWheel_-1near","Average Efficiency Near Side Wheel -1 ",101,0.5,101.5);
135  //AverageEffWm1far=dbe->book1D("AverageEfficiencyWheel_-1far","Average Efficiency Far Side Wheel -1 ",105,0.5,105.5);
136  //NoPredictionWm1=dbe->book1D("NoPredictionWheel_-1near","No Predictions Near Side Wheel -1 ",101,0.5,101.5);
137  //NoPredictionWm1far=dbe->book1D("NoPredictionWheel_-1far","No Predictions Efficiency Far Side Wheel -1 ",105,0.5,105.5);
138 
139  dbe->setCurrentFolder(folderPath+"Wheel_0");
140  EffDistroW0=dbe->book1D("EffDistroWheel_0","Efficiency Distribution for Wheel 0 ",20,0.5,100.5);
141  //EffDistroW0far=dbe->book1D("EffDistroWheel_0far","Efficiency Distribution for Far Side Wheel 0 ",20,0.5,100.5);
142  EffGlobW0 = dbe->book1D("GlobEfficiencyWheel_0","Efficiency Wheel 0",206,0.5,206.5);
143  //EffGlobW0far =dbe->book1D("GlobEfficiencyWheel_0far","Efficiency Far Side Wheel 0",105,0.5,105.5);
144  //BXGlobW0 = dbe->book1D("GlobBXWheel_0near","BX Near Side Wheel 0",101,0.5,101.5);
145  //BXGlobW0far = dbe->book1D("GlobBXWheel_0far","BX Far Side Wheel 0",105,0.5,105.5);
146  //MaskedGlobW0 = dbe->book1D("GlobMaskedWheel_0near","Masked Near Side Wheel 0",101,0.5,101.5);
147  //MaskedGlobW0far = dbe->book1D("GlobMaskedWheel_0far","Masked Far Side Wheel 0",105,0.5,105.5);
148  //AverageEffW0=dbe->book1D("AverageEfficiencyWheel_0near","Average Efficiency Near Side Wheel 0 ",101,0.5,101.5);
149  //AverageEffW0far=dbe->book1D("AverageEfficiencyWheel_0far","Average Efficiency Far Side Wheel 0 ",105,0.5,105.5);
150  //NoPredictionW0=dbe->book1D("NoPredictionWheel_0near","No Predictions Near Side Wheel 0 ",101,0.5,101.5);
151  //NoPredictionW0far=dbe->book1D("NoPredictionWheel_0far","No Predictions Efficiency Far Side Wheel 0 ",105,0.5,105.5);
152 
153  dbe->setCurrentFolder(folderPath+"Wheel_1");
154  EffDistroW1=dbe->book1D("EffDistroWheel_1","Efficiency Distribution for Wheel 1 ",20,0.5,100.5);
155  //EffDistroW1far=dbe->book1D("EffDistroWheel_1far","Efficiency Distribution for Far Side Wheel 1 ",20,0.5,100.5);
156  EffGlobW1 = dbe->book1D("GlobEfficiencyWheel_1","Efficiency Wheel 1",206,0.5,206.5);
157  //EffGlobW1far =dbe->book1D("GlobEfficiencyWheel_1far","Efficiency Far Side Wheel 1",105,0.5,105.5);
158  //BXGlobW1 = dbe->book1D("GlobBXWheel_1near","BX Near Side Wheel 1",101,0.5,101.5);
159  //BXGlobW1far = dbe->book1D("GlobBXWheel_1far","BX Far Side Wheel 1",105,0.5,105.5);
160  //MaskedGlobW1 = dbe->book1D("GlobMaskedWheel_1near","Masked Near Side Wheel 1",101,0.5,101.5);
161  //MaskedGlobW1far = dbe->book1D("GlobMaskedWheel_1far","Masked Far Side Wheel 1",105,0.5,105.5);
162  //AverageEffW1=dbe->book1D("AverageEfficiencyWheel_1near","Average Efficiency Near Side Wheel 1 ",101,0.5,101.5);
163  //AverageEffW1far=dbe->book1D("AverageEfficiencyWheel_1far","Average Efficiency Far Side Wheel 1 ",105,0.5,105.5);
164  //NoPredictionW1=dbe->book1D("NoPredictionWheel_1near","No Predictions Near Side Wheel 1 ",101,0.5,101.5);
165  //NoPredictionW1far=dbe->book1D("NoPredictionWheel_1far","No Predictions Efficiency Far Side Wheel 1 ",105,0.5,105.5);
166 
167  dbe->setCurrentFolder(folderPath+"Wheel_2");
168  EffDistroW2=dbe->book1D("EffDistroWheel_2","Efficiency Distribution for Wheel 2 ",20,0.5,100.5);
169  //EffDistroW2far=dbe->book1D("EffDistroWheel_2far","Efficiency Distribution for Far Side Wheel 2 ",20,0.5,100.5);
170  EffGlobW2 = dbe->book1D("GlobEfficiencyWheel_2","Efficiency Wheel 2",206,0.5,206.5);
171  //EffGlobW2far =dbe->book1D("GlobEfficiencyWheel_2far","Efficiency Far Side Wheel 2",105,0.5,105.5);
172  //BXGlobW2 = dbe->book1D("GlobBXWheel_2near","BX Near Side Wheel 2",101,0.5,101.5);
173  //BXGlobW2far = dbe->book1D("GlobBXWheel_2far","BX Far Side Wheel 2",105,0.5,105.5);
174  //MaskedGlobW2 = dbe->book1D("GlobMaskedWheel_2near","Masked Near Side Wheel 2",101,0.5,101.5);
175  //MaskedGlobW2far = dbe->book1D("GlobMaskedWheel_2far","Masked Far Side Wheel 2",105,0.5,105.5);
176  //AverageEffW2=dbe->book1D("AverageEfficiencyWheel_2near","Average Efficiency Near Side Wheel 2 ",101,0.5,101.5);
177  //AverageEffW2far=dbe->book1D("AverageEfficiencyWheel_2far","Average Efficiency Far Side Wheel 2 ",105,0.5,105.5);
178  //NoPredictionW2=dbe->book1D("NoPredictionWheel_2near","No Predictions Near Side Wheel 2 ",101,0.5,101.5);
179  //NoPredictionW2far=dbe->book1D("NoPredictionWheel_2far","No Predictions Efficiency Far Side Wheel 2 ",105,0.5,105.5);
180 
181  //EndCap
182 
183  dbe->setCurrentFolder(folderPath+"Disk_3");
184  EffDistroD3=dbe->book1D("EffDistroDisk_3","Efficiency Distribution Disk 3 ",20,0.5,100.5);
185  //EffDistroD3far=dbe->book1D("EffDistroDisk_3far","Efficiency Distribution Far Side Disk 3 ",20,0.5,100.5);
186  EffGlobD3 = dbe->book1D("GlobEfficiencyDisk_3","Efficiency Disk 3",218,0.5,218.5);
187  //EffGlobD3far =dbe->book1D("GlobEfficiencyDisk_3far","Efficiency Far Side Disk 3",109,0.5,109.5);
188  //BXGlobD3 = dbe->book1D("GlobBXDisk_3near","BX Near Side Disk 3",109,0.5,109.5);
189  //BXGlobD3far = dbe->book1D("GlobBXDisk_3far","BX Far Side Disk 3",109,0.5,109.5);
190  //MaskedGlobD3 = dbe->book1D("GlobMaskedDisk_3near","Masked Near Side Disk 3",109,0.5,109.5);
191  //MaskedGlobD3far = dbe->book1D("GlobMaskedDisk_3far","Masked Far Side Disk 3",109,0.5,109.5);
192  //AverageEffD3=dbe->book1D("AverageEfficiencyDisk_3near","Average Efficiency Near Side Disk 3 ",109,0.5,109.5);
193  //AverageEffD3far=dbe->book1D("AverageEfficiencyDisk_3far","Average Efficiency Far Side Disk 3 ",109,0.5,109.5);
194  //NoPredictionD3=dbe->book1D("NoPredictionDisk_3near","No Predictions Near Side Disk 3 ",109,0.5,109.5);
195  //NoPredictionD3far=dbe->book1D("NoPredictionDisk_3far","No Predictions Efficiency Far Side Disk 3 ",109,0.5,109.5);
196 
197  dbe->setCurrentFolder(folderPath+"Disk_2");
198  EffDistroD2=dbe->book1D("EffDistroDisk_2","Efficiency Distribution Disk 2 ",20,0.5,100.5);
199  //EffDistroD2far=dbe->book1D("EffDistroDisk_2far","Efficiency Distribution Far Side Disk 2 ",20,0.5,100.5);
200  EffGlobD2 = dbe->book1D("GlobEfficiencyDisk_2","Efficiency Disk 2",218,0.5,218.5);
201  //EffGlobD2far =dbe->book1D("GlobEfficiencyDisk_2far","Efficiency Far Side Disk 2",109,0.5,109.5);
202  //BXGlobD2 = dbe->book1D("GlobBXDisk_2near","BX Near Side Disk 2",109,0.5,109.5);
203  //BXGlobD2far = dbe->book1D("GlobBXDisk_2far","BX Far Side Disk 2",109,0.5,109.5);
204  //MaskedGlobD2 = dbe->book1D("GlobMaskedDisk_2near","Masked Near Side Disk 2",109,0.5,109.5);
205  //MaskedGlobD2far = dbe->book1D("GlobMaskedDisk_2far","Masked Far Side Disk 2",109,0.5,109.5);
206  //AverageEffD2=dbe->book1D("AverageEfficiencyDisk_2near","Average Efficiency Near Side Disk 2 ",109,0.5,109.5);
207  //AverageEffD2far=dbe->book1D("AverageEfficiencyDisk_2far","Average Efficiency Far Side Disk 2 ",109,0.5,109.5);
208  //NoPredictionD2=dbe->book1D("NoPredictionDisk_2near","No Predictions Near Side Disk 2 ",109,0.5,109.5);
209  //NoPredictionD2far=dbe->book1D("NoPredictionDisk_2far","No Predictions Efficiency Far Side Disk 2 ",109,0.5,109.5);
210 
211  dbe->setCurrentFolder(folderPath+"Disk_1");
212  EffDistroD1=dbe->book1D("EffDistroDisk_1","Efficiency Distribution Disk 1 ",20,0.5,100.5);
213  //EffDistroD1far=dbe->book1D("EffDistroDisk_1far","Efficiency Distribution Far Side Disk 1 ",20,0.5,100.5);
214  EffGlobD1 = dbe->book1D("GlobEfficiencyDisk_1","Efficiency Disk 1",218,0.5,218.5);
215  //EffGlobD1far =dbe->book1D("GlobEfficiencyDisk_1far","Efficiency Far Side Disk 1",109,0.5,109.5);
216  //BXGlobD1 = dbe->book1D("GlobBXDisk_1near","BX Near Side Disk 1",109,0.5,109.5);
217  //BXGlobD1far = dbe->book1D("GlobBXDisk_1far","BX Far Side Disk 1",109,0.5,109.5);
218  //MaskedGlobD1 = dbe->book1D("GlobMaskedDisk_1near","Masked Near Side Disk 1",109,0.5,109.5);
219  //MaskedGlobD1far = dbe->book1D("GlobMaskedDisk_1far","Masked Far Side Disk 1",109,0.5,109.5);
220  //AverageEffD1=dbe->book1D("AverageEfficiencyDisk_1near","Average Efficiency Near Side Disk 1 ",109,0.5,109.5);
221  //AverageEffD1far=dbe->book1D("AverageEfficiencyDisk_1far","Average Efficiency Far Side Disk 1 ",109,0.5,109.5);
222  //NoPredictionD1=dbe->book1D("NoPredictionDisk_1near","No Predictions Near Side Disk 1 ",109,0.5,109.5);
223  //NoPredictionD1far=dbe->book1D("NoPredictionDisk_1far","No Predictions Efficiency Far Side Disk 1 ",109,0.5,109.5);
224 
225  dbe->setCurrentFolder(folderPath+"Disk_-1");
226  EffDistroDm1=dbe->book1D("EffDistroDisk_m1","Efficiency Distribution Disk - 1 ",20,0.5,100.5);
227  //EffDistroDm1far=dbe->book1D("EffDistroDisk_m1far","Efficiency Distribution Far Side Disk - 1 ",20,0.5,100.5);
228  EffGlobDm1 = dbe->book1D("GlobEfficiencyDisk_m1","Efficiency Disk -1",218,0.5,218.5);
229  //EffGlobDm1far =dbe->book1D("GlobEfficiencyDisk_m1far","Efficiency Far Side Disk -1",109,0.5,109.5);
230  //BXGlobDm1 = dbe->book1D("GlobBXDisk_m1near","BX Near Side Disk -1",109,0.5,109.5);
231  //BXGlobDm1far = dbe->book1D("GlobBXDisk_m1far","BX Far Side Disk -1",109,0.5,109.5);
232  //MaskedGlobDm1 = dbe->book1D("GlobMaskedDisk_m1near","Masked Near Side Disk -1",109,0.5,109.5);
233  //MaskedGlobDm1far = dbe->book1D("GlobMaskedDisk_m1far","Masked Far Side Disk -1",109,0.5,109.5);
234  //AverageEffDm1=dbe->book1D("AverageEfficiencyDisk_m1near","Average Efficiency Near Side Disk -1 ",109,0.5,109.5);
235  //AverageEffDm1far=dbe->book1D("AverageEfficiencyDisk_m1far","Average Efficiency Far Side Disk -1 ",109,0.5,109.5);
236  //NoPredictionDm1=dbe->book1D("NoPredictionDisk_m1near","No Predictions Near Side Disk -1 ",109,0.5,109.5);
237  //NoPredictionDm1far=dbe->book1D("NoPredictionDisk_m1far","No Predictions Efficiency Far Side Disk -1 ",109,0.5,109.5);
238 
239  dbe->setCurrentFolder(folderPath+"Disk_-2");
240  EffDistroDm2=dbe->book1D("EffDistroDisk_m2","Efficiency Distribution Disk - 2 ",20,0.5,100.5);
241  //EffDistroDm2far=dbe->book1D("EffDistroDisk_m2far","Efficiency Distribution Far Side Disk - 2 ",20,0.5,100.5);
242  EffGlobDm2 = dbe->book1D("GlobEfficiencyDisk_m2","Efficiency Disk -2",218,0.5,218.5);
243  //EffGlobDm2far =dbe->book1D("GlobEfficiencyDisk_m2far","Efficiency Far Side Disk -2",109,0.5,109.5);
244  //BXGlobDm2 = dbe->book1D("GlobBXDisk_m2near","BX Near Side Disk -2",109,0.5,109.5);
245  //BXGlobDm2far = dbe->book1D("GlobBXDisk_m2far","BX Far Side Disk -2",109,0.5,109.5);
246  //MaskedGlobDm2 = dbe->book1D("GlobMaskedDisk_m2near","Masked Near Side Disk -2",109,0.5,109.5);
247  //MaskedGlobDm2far = dbe->book1D("GlobMaskedDisk_m2far","Masked Far Side Disk -2",109,0.5,109.5);
248  //AverageEffDm2=dbe->book1D("AverageEfficiencyDisk_m2near","Average Efficiency Near Side Disk -2 ",109,0.5,109.5);
249  //AverageEffDm2far=dbe->book1D("AverageEfficiencyDisk_m2far","Average Efficiency Far Side Disk -2 ",109,0.5,109.5);
250  //NoPredictionDm2=dbe->book1D("NoPredictionDisk_m2near","No Predictions Near Side Disk -2 ",109,0.5,109.5);
251  //NoPredictionDm2far=dbe->book1D("NoPredictionDisk_m2far","No Predictions Efficiency Far Side Disk -2 ",109,0.5,109.5);
252 
253  dbe->setCurrentFolder(folderPath+"Disk_-3");
254  EffDistroDm3=dbe->book1D("EffDistroDisk_m3","Efficiency Distribution Disk - 3 ",20,0.5,100.5);
255  //EffDistroDm3far=dbe->book1D("EffDistroDisk_m3far","Efficiency Distribution Far Side Disk - 3 ",20,0.5,100.5);
256  EffGlobDm3 = dbe->book1D("GlobEfficiencyDisk_m3","Efficiency Disk -3",218,0.5,218.5);
257  //EffGlobDm3far =dbe->book1D("GlobEfficiencyDisk_m3far","Efficiency Far Side Disk -3",109,0.5,109.5);
258  //BXGlobDm3 = dbe->book1D("GlobBXDisk_m3near","BX Near Side Disk -3",109,0.5,109.5);
259  //BXGlobDm3far = dbe->book1D("GlobBXDisk_m3far","BX Far Side Disk -3",109,0.5,109.5);
260  //MaskedGlobDm3 = dbe->book1D("GlobMaskedDisk_m3near","Masked Near Side Disk -3",109,0.5,109.5);
261  //MaskedGlobDm3far = dbe->book1D("GlobMaskedDisk_m3far","Masked Far Side Disk -3",109,0.5,109.5);
262  //AverageEffDm3=dbe->book1D("AverageEfficiencyDisk_m3near","Average Efficiency Near Side Disk -3 ",109,0.5,109.5);
263  //AverageEffDm3far=dbe->book1D("AverageEfficiencyDisk_m3far","Average Efficiency Far Side Disk -3 ",109,0.5,109.5);
264  //NoPredictionDm3=dbe->book1D("NoPredictionDisk_m3near","No Predictions Near Side Disk -3 ",109,0.5,109.5);
265  //NoPredictionDm3far=dbe->book1D("NoPredictionDisk_m3far","No Predictions Efficiency Far Side Disk -3 ",109,0.5,109.5);
266 
267  //Summary Histograms
268 
269 
270  dbe->setCurrentFolder(folderPath);
271  std::string os;
272  os="Efficiency_Roll_vs_Sector_Wheel_-2";
273  Wheelm2Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
274  os="Efficiency_Roll_vs_Sector_Wheel_-1";
275  Wheelm1Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
276  os="Efficiency_Roll_vs_Sector_Wheel_0";
277  Wheel0Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
278  os="Efficiency_Roll_vs_Sector_Wheel_+1";
279  Wheel1Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
280  os="Efficiency_Roll_vs_Sector_Wheel_+2";
281  Wheel2Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
282 
283  rpcdqm::utils rpcUtils;
284  rpcUtils.labelXAxisSector( Wheel2Summary );
285  rpcUtils.labelYAxisRoll( Wheel2Summary, 0, 2);
286 
287  rpcUtils.labelXAxisSector( Wheel1Summary );
288  rpcUtils.labelYAxisRoll( Wheel1Summary, 0, 1);
289 
290  rpcUtils.labelXAxisSector( Wheel0Summary );
291  rpcUtils.labelYAxisRoll( Wheel0Summary, 0, 0);
292 
293  rpcUtils.labelXAxisSector( Wheelm1Summary );
294  rpcUtils.labelYAxisRoll( Wheelm1Summary, 0, -1);
295 
296  rpcUtils.labelXAxisSector( Wheelm2Summary );
297  rpcUtils.labelYAxisRoll( Wheelm2Summary, 0, -2);
298 
299  os="Efficiency_Roll_vs_Segment_Disk_-3";
300  Diskm3Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
301  os="Efficiency_Roll_vs_Segment_Disk_-2";
302  Diskm2Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
303  os="Efficiency_Roll_vs_Segment_Disk_-1";
304  Diskm1Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
305  os="Efficiency_Roll_vs_Segment_Disk_1";
306  Disk1Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
307  os="Efficiency_Roll_vs_Segment_Disk_2";
308  Disk2Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
309  os="Efficiency_Roll_vs_Segment_Disk_3";
310  Disk3Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
311 
312  rpcUtils.labelXAxisSegment(Diskm3Summary);
313  rpcUtils.labelYAxisRing(Diskm3Summary, 2);
314 
315  rpcUtils.labelXAxisSegment(Diskm2Summary);
316  rpcUtils.labelYAxisRing(Diskm2Summary, 2);
317 
318  rpcUtils.labelXAxisSegment(Diskm1Summary);
319  rpcUtils.labelYAxisRing(Diskm1Summary, 2);
320 
321  rpcUtils.labelXAxisSegment(Disk1Summary);
322  rpcUtils.labelYAxisRing(Disk1Summary, 2);
323 
324  rpcUtils.labelXAxisSegment(Disk2Summary);
325  rpcUtils.labelYAxisRing(Disk2Summary, 2);
326 
327  rpcUtils.labelXAxisSegment(Disk3Summary);
328  rpcUtils.labelYAxisRing(Disk3Summary, 2);
329 
330  //Azimutal Histograms
331 
332  dbe->setCurrentFolder(folderPath+"Azimutal/");
333  sectorEffWm2= dbe->book1D("AzimutalDistroWm2","Efficiency per Sector Wheel -2",12,0.5,12.5);
334  sectorEffWm1= dbe->book1D("AzimutalDistroWm1","Efficiency per Sector Wheel -1",12,0.5,12.5);
335  sectorEffW0= dbe->book1D("AzimutalDistroW0","Efficiency per Sector Wheel 0",12,0.5,12.5);
336  sectorEffW1= dbe->book1D("AzimutalDistroW1","Efficiency per Sector Wheel 1",12,0.5,12.5);
337  sectorEffW2= dbe->book1D("AzimutalDistroW2","Efficiency per Sector Wheel 2",12,0.5,12.5);
338 
339  OcsectorEffWm2= dbe->book1D("AzimutalDistroWm2Oc","Occupancy per Sector Wheel -2",12,0.5,12.5);
340  OcsectorEffWm1= dbe->book1D("AzimutalDistroWm1Oc","Occupancy per Sector Wheel -1",12,0.5,12.5);
341  OcsectorEffW0= dbe->book1D("AzimutalDistroW0Oc","Ocuppancy per Sector Wheel 0",12,0.5,12.5);
342  OcsectorEffW1= dbe->book1D("AzimutalDistroW1Oc","Ocuppancy per Sector Wheel 1",12,0.5,12.5);
343  OcsectorEffW2= dbe->book1D("AzimutalDistroW2Oc","Ocupancy per Sector Wheel 2",12,0.5,12.5);
344 
345  ExsectorEffWm2= dbe->book1D("AzimutalDistroWm2Ex","Expected per Sector Wheel -2",12,0.5,12.5);
346  ExsectorEffWm1= dbe->book1D("AzimutalDistroWm1Ex","Expected per Sector Wheel -1",12,0.5,12.5);
347  ExsectorEffW0= dbe->book1D("AzimutalDistroW0Ex","Expected per Sector Wheel 0",12,0.5,12.5);
348  ExsectorEffW1= dbe->book1D("AzimutalDistroW1Ex","Expected per Sector Wheel 1",12,0.5,12.5);
349  ExsectorEffW2= dbe->book1D("AzimutalDistroW2Ex","Expected per Sector Wheel 2",12,0.5,12.5);
350 
351  GregD1R2= dbe->book1D("GregDistroD1R2","Efficiency for Station 1 Ring 2",36,0.5,36.5);
352  GregD1R3= dbe->book1D("GregDistroD1R3","Efficiency for Station 1 Ring 3",36,0.5,36.5);
353  GregD2R2= dbe->book1D("GregDistroD2R2","Efficiency for Station 2 Ring 2",36,0.5,36.5);
354  GregD2R3= dbe->book1D("GregDistroD2R3","Efficiency for Station 2 Ring 3",36,0.5,36.5);
355  GregD3R2= dbe->book1D("GregDistroD3R2","Efficiency for Station 3 Ring 2",36,0.5,36.5);
356  GregD3R3= dbe->book1D("GregDistroD3R3","Efficiency for Station 3 Ring 3",36,0.5,36.5);
357  GregDm1R2= dbe->book1D("GregDistroDm1R2","Efficiency for Station -1 Ring 2",36,0.5,36.5);
358  GregDm1R3= dbe->book1D("GregDistroDm1R3","Efficiency for Station -1 Ring 3",36,0.5,36.5);
359  GregDm2R2= dbe->book1D("GregDistroDm2R2","Efficiency for Station -2 Ring 2",36,0.5,36.5);
360  GregDm2R3= dbe->book1D("GregDistroDm2R3","Efficiency for Station -2 Ring 3",36,0.5,36.5);
361  GregDm3R2= dbe->book1D("GregDistroDm3R2","Efficiency for Station -3 Ring 2",36,0.5,36.5);
362  GregDm3R3= dbe->book1D("GregDistroDm3R3","Efficiency for Station -3 Ring 3",36,0.5,36.5);
363 
364  OcGregD1R2= dbe->book1D("OcGregDistroD1R2","Occupancy Distribution for Station 1 Ring 2",36,0.5,36.5);
365  OcGregD1R3= dbe->book1D("OcGregDistroD1R3","Occupancy Distribution for Station 1 Ring 3",36,0.5,36.5);
366  OcGregD2R2= dbe->book1D("OcGregDistroD2R2","Occupancy Distribution for Station 2 Ring 2",36,0.5,36.5);
367  OcGregD2R3= dbe->book1D("OcGregDistroD2R3","Occupancy Distribution for Station 2 Ring 3",36,0.5,36.5);
368  OcGregD3R2= dbe->book1D("OcGregDistroD3R2","Occupancy Distribution for Station 3 Ring 2",36,0.5,36.5);
369  OcGregD3R3= dbe->book1D("OcGregDistroD3R3","Occupancy Distribution for Station 3 Ring 3",36,0.5,36.5);
370  OcGregDm1R2= dbe->book1D("OcGregDistroDm1R2","Occupancy Distribution for Station -1 Ring 2",36,0.5,36.5);
371  OcGregDm1R3= dbe->book1D("OcGregDistroDm1R3","Occupancy Distribution for Station -1 Ring 3",36,0.5,36.5);
372  OcGregDm2R2= dbe->book1D("OcGregDistroDm2R2","Occupancy Distribution for Station -2 Ring 2",36,0.5,36.5);
373  OcGregDm2R3= dbe->book1D("OcGregDistroDm2R3","Occupancy Distribution for Station -2 Ring 3",36,0.5,36.5);
374  OcGregDm3R2= dbe->book1D("OcGregDistroDm3R2","Occupancy Distribution for Station -3 Ring 2",36,0.5,36.5);
375  OcGregDm3R3= dbe->book1D("OcGregDistroDm3R3","Occupancy Distribution for Station -3 Ring 3",36,0.5,36.5);
376 
377  ExGregD1R2= dbe->book1D("ExGregDistroD1R2","Expected Distribution for Station 1 Ring 2",36,0.5,36.5);
378  ExGregD1R3= dbe->book1D("ExGregDistroD1R3","Expected Distribution for Station 1 Ring 3",36,0.5,36.5);
379  ExGregD2R2= dbe->book1D("ExGregDistroD2R2","Expected Distribution for Station 2 Ring 2",36,0.5,36.5);
380  ExGregD2R3= dbe->book1D("ExGregDistroD2R3","Expected Distribution for Station 2 Ring 3",36,0.5,36.5);
381  ExGregD3R2= dbe->book1D("ExGregDistroD3R2","Expected Distribution for Station 3 Ring 2",36,0.5,36.5);
382  ExGregD3R3= dbe->book1D("ExGregDistroD3R3","Expected Distribution for Station 3 Ring 3",36,0.5,36.5);
383  ExGregDm1R2= dbe->book1D("ExGregDistroDm1R2","Expected Distribution for Station -1 Ring 2",36,0.5,36.5);
384  ExGregDm1R3= dbe->book1D("ExGregDistroDm1R3","Expected Distribution for Station -1 Ring 3",36,0.5,36.5);
385  ExGregDm2R2= dbe->book1D("ExGregDistroDm2R2","Expected Distribution for Station -2 Ring 2",36,0.5,36.5);
386  ExGregDm2R3= dbe->book1D("ExGregDistroDm2R3","Expected Distribution for Station -2 Ring 3",36,0.5,36.5);
387  ExGregDm3R2= dbe->book1D("ExGregDistroDm3R2","Expected Distribution for Station -3 Ring 2",36,0.5,36.5);
388  ExGregDm3R3= dbe->book1D("ExGregDistroDm3R3","Expected Distribution for Station -3 Ring 3",36,0.5,36.5);
389 
390  dbe->setCurrentFolder(folderPath+"BarrelPerLayer/");
391  ExpLayerWm2= dbe->book1D("ExpLayerWm2","Expected Wheel - 2",6,0.5,6.5);
392  ExpLayerWm1= dbe->book1D("ExpLayerWm1","Expected Wheel - 1",6,0.5,6.5);
393  ExpLayerW0= dbe->book1D("ExpLayerW0","Expected Wheel 0",6,0.5,6.5);
394  ExpLayerW1= dbe->book1D("ExpLayerW1","Expected Wheel 1",6,0.5,6.5);
395  ExpLayerW2= dbe->book1D("ExpLayerW2","Expected Wheel 2",6,0.5,6.5);
396 
397  ObsLayerWm2= dbe->book1D("ObsLayerWm2","Observed Wheel - 2",6,0.5,6.5);
398  ObsLayerWm1= dbe->book1D("ObsLayerWm1","Observed Wheel - 1",6,0.5,6.5);
399  ObsLayerW0= dbe->book1D("ObsLayerW0","Observed Wheel 0",6,0.5,6.5);
400  ObsLayerW1= dbe->book1D("ObsLayerW1","Observed Wheel 1",6,0.5,6.5);
401  ObsLayerW2= dbe->book1D("ObsLayerW2","Observed Wheel 2",6,0.5,6.5);
402 }
403 
404 void RPCEfficiencySecond::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup){ }
405 
406 void RPCEfficiencySecond::endRun(const edm::Run& r, const edm::EventSetup& iSetup){
407 
408  if(debug) std::cout <<"\t Getting the RPC Geometry"<<std::endl;
409 
410  edm::ESHandle<RPCGeometry> rpcGeo;
411  iSetup.get<MuonGeometryRecord>().get(rpcGeo);
412 
413  // std::string label,folder;
414  // folder = folderPath;
415 // label = folder + "MuonSegEff/Statistics";
416 // if(debug) std::cout<<"Getting statistcs="<<label<<std::endl;
417 // statistics = dbe->get(label);
418 // if(debug && !statistics){
419 
420 // std::cout<<"Statistics Doesn't exist Not access to a monitor element"<<std::endl;
421 // std::cout<<label<<std::endl;
422 // edm::LogWarning("Missing rpcSource in the sequence") << " Statistics Doesn't exist.";
423 // return;
424 // }
425 // if(debug) std::cout<<"Cloning statistcs"<<std::endl;
426 // for(int i=1;i<=33;i++){
427 // if(debug) std::cout<<statistics->getBinContent(i)<<std::endl;
428 // statistics2->setBinContent(i,statistics->getBinContent(i));
429 // }
430 
431 
432 
433  //Cloning Residuals.
434 
435 // folder = folderPath+"MuonSegEff/Residuals/Barrel/";
436 
437 // label = folder + "GlobalResidualsClu1La1"; hGlobalResClu1La1 = dbe->get(label);
438 // label = folder + "GlobalResidualsClu1La2"; hGlobalResClu1La2 = dbe->get(label);
439 // label = folder + "GlobalResidualsClu1La3"; hGlobalResClu1La3 = dbe->get(label);
440 // label = folder + "GlobalResidualsClu1La4"; hGlobalResClu1La4 = dbe->get(label);
441 // label = folder + "GlobalResidualsClu1La5"; hGlobalResClu1La5 = dbe->get(label);
442 // label = folder + "GlobalResidualsClu1La6"; hGlobalResClu1La6 = dbe->get(label);
443 
444 // label = folder + "GlobalResidualsClu2La1"; hGlobalResClu2La1 = dbe->get(label);
445 // label = folder + "GlobalResidualsClu2La2"; hGlobalResClu2La2 = dbe->get(label);
446 // label = folder + "GlobalResidualsClu2La3"; hGlobalResClu2La3 = dbe->get(label);
447 // label = folder + "GlobalResidualsClu2La4"; hGlobalResClu2La4 = dbe->get(label);
448 // label = folder + "GlobalResidualsClu2La5"; hGlobalResClu2La5 = dbe->get(label);
449 // label = folder + "GlobalResidualsClu2La6"; hGlobalResClu2La6 = dbe->get(label);
450 
451 // label = folder + "GlobalResidualsClu3La1"; hGlobalResClu3La1 = dbe->get(label);
452 // label = folder + "GlobalResidualsClu3La2"; hGlobalResClu3La2 = dbe->get(label);
453 // label = folder + "GlobalResidualsClu3La3"; hGlobalResClu3La3 = dbe->get(label);
454 // label = folder + "GlobalResidualsClu3La4"; hGlobalResClu3La4 = dbe->get(label);
455 // label = folder + "GlobalResidualsClu3La5"; hGlobalResClu3La5 = dbe->get(label);
456 // label = folder + "GlobalResidualsClu3La6"; hGlobalResClu3La6 = dbe->get(label);
457 
458  // if(debug) std::cout<<"Clonning for Barrel"<<std::endl;
459 
460  // for(int i=1;i<=101;i++){
461 // if(debug) std::cout<<"Global Residual"<<hGlobalResClu1La1->getBinContent(i)<<std::endl;
462 // hGlobal2ResClu1La1->setBinContent(i,hGlobalResClu1La1->getBinContent(i));
463 // hGlobal2ResClu1La2->setBinContent(i,hGlobalResClu1La2->getBinContent(i));
464 // hGlobal2ResClu1La3->setBinContent(i,hGlobalResClu1La3->getBinContent(i));
465 // hGlobal2ResClu1La4->setBinContent(i,hGlobalResClu1La4->getBinContent(i));
466 // hGlobal2ResClu1La5->setBinContent(i,hGlobalResClu1La5->getBinContent(i));
467 // hGlobal2ResClu1La6->setBinContent(i,hGlobalResClu1La6->getBinContent(i));
468 
469 // hGlobal2ResClu2La1->setBinContent(i,hGlobalResClu2La1->getBinContent(i));
470 // hGlobal2ResClu2La2->setBinContent(i,hGlobalResClu2La2->getBinContent(i));
471 // hGlobal2ResClu2La3->setBinContent(i,hGlobalResClu2La3->getBinContent(i));
472 // hGlobal2ResClu2La4->setBinContent(i,hGlobalResClu2La4->getBinContent(i));
473 // hGlobal2ResClu2La5->setBinContent(i,hGlobalResClu2La5->getBinContent(i));
474 // hGlobal2ResClu2La6->setBinContent(i,hGlobalResClu2La6->getBinContent(i));
475 
476 // hGlobal2ResClu3La1->setBinContent(i,hGlobalResClu3La1->getBinContent(i));
477 // hGlobal2ResClu3La2->setBinContent(i,hGlobalResClu3La2->getBinContent(i));
478 // hGlobal2ResClu3La3->setBinContent(i,hGlobalResClu3La3->getBinContent(i));
479 // hGlobal2ResClu3La4->setBinContent(i,hGlobalResClu3La4->getBinContent(i));
480 // hGlobal2ResClu3La5->setBinContent(i,hGlobalResClu3La5->getBinContent(i));
481 // hGlobal2ResClu3La6->setBinContent(i,hGlobalResClu3La6->getBinContent(i));
482 // }
483 
484 // if(debug) std::cout<<"Clonning the EndCap"<<std::endl;
485 // folder = folderPath+"MuonSegEff/Residuals/EndCap/";
486 // if(debug) std::cout<<folder<<std::endl;
487 
488 // label = folder + "GlobalResidualsClu1R3C"; hGlobalResClu1R3C = dbe->get(label);
489 // //if(!hGlobalResClu1R3C)std::cout<<"hGlobal2ResClu1R3C dont exist"<<std::endl;
490 // //std::cout<<label<<std::endl;
491 // label = folder + "GlobalResidualsClu1R3B"; hGlobalResClu1R3B = dbe->get(label);
492 // //if(!hGlobalResClu1R3B)std::cout<<"hGlobal2ResClu1R3B dont exist"<<std::endl;
493 // //std::cout<<label<<std::endl;
494 // label = folder + "GlobalResidualsClu1R3A"; hGlobalResClu1R3A = dbe->get(label);
495 // label = folder + "GlobalResidualsClu1R2C"; hGlobalResClu1R2C = dbe->get(label);
496 // label = folder + "GlobalResidualsClu1R2B"; hGlobalResClu1R2B = dbe->get(label);
497 // label = folder + "GlobalResidualsClu1R2A"; hGlobalResClu1R2A = dbe->get(label);
498 
499 // label = folder + "GlobalResidualsClu2R3C"; hGlobalResClu2R3C = dbe->get(label);
500 // label = folder + "GlobalResidualsClu2R3B"; hGlobalResClu2R3B = dbe->get(label);
501 // label = folder + "GlobalResidualsClu2R3A"; hGlobalResClu2R3A = dbe->get(label);
502 // label = folder + "GlobalResidualsClu2R2C"; hGlobalResClu2R2C = dbe->get(label);
503 // label = folder + "GlobalResidualsClu2R2B"; hGlobalResClu2R2B = dbe->get(label);
504 // label = folder + "GlobalResidualsClu2R2A"; hGlobalResClu2R2A = dbe->get(label);
505 
506 // label = folder + "GlobalResidualsClu3R3C"; hGlobalResClu3R3C = dbe->get(label);
507 // label = folder + "GlobalResidualsClu3R3B"; hGlobalResClu3R3B = dbe->get(label);
508 // label = folder + "GlobalResidualsClu3R3A"; hGlobalResClu3R3A = dbe->get(label);
509 // label = folder + "GlobalResidualsClu3R2C"; hGlobalResClu3R2C = dbe->get(label);
510 // label = folder + "GlobalResidualsClu3R2B"; hGlobalResClu3R2B = dbe->get(label);
511 // label = folder + "GlobalResidualsClu3R2A"; hGlobalResClu3R2A = dbe->get(label);
512 
513 
514  // if(debug) std::cout<<"Going for!"<<std::endl;
515  /*for(int i=1;i<=101;i++){
516  if(debug) std::cout<<i<<std::endl;
517  hGlobal2ResClu1R3C->setBinContent(i,hGlobalResClu1R3C->getBinContent(i)); std::cout<<"hGlobal2ResClu1R3C"<<std::endl;
518  hGlobal2ResClu1R3B->setBinContent(i,hGlobalResClu1R3B->getBinContent(i)); std::cout<<"hGlobal2ResClu1R3B"<<std::endl;
519  hGlobal2ResClu1R3A->setBinContent(i,hGlobalResClu1R3A->getBinContent(i)); std::cout<<"hGlobal2ResClu1R3A"<<std::endl;
520  hGlobal2ResClu1R2C->setBinContent(i,hGlobalResClu1R2C->getBinContent(i)); std::cout<<"hGlobal2ResClu1R2C"<<std::endl;
521  hGlobal2ResClu1R2B->setBinContent(i,hGlobalResClu1R2B->getBinContent(i)); std::cout<<"hGlobal2ResClu1R2B"<<std::endl;
522  hGlobal2ResClu1R2A->setBinContent(i,hGlobalResClu1R2A->getBinContent(i)); std::cout<<"hGlobal2ResClu1R2A"<<std::endl;
523 
524  hGlobal2ResClu2R3C->setBinContent(i,hGlobalResClu2R3C->getBinContent(i)); std::cout<<"hGlobal2ResClu2R3C"<<std::endl;
525  hGlobal2ResClu2R3B->setBinContent(i,hGlobalResClu2R3B->getBinContent(i)); std::cout<<"hGlobal2ResClu2R3B"<<std::endl;
526  hGlobal2ResClu2R3A->setBinContent(i,hGlobalResClu2R3A->getBinContent(i)); std::cout<<"hGlobal2ResClu2R3A"<<std::endl;
527  hGlobal2ResClu2R2C->setBinContent(i,hGlobalResClu2R2C->getBinContent(i)); std::cout<<"hGlobal2ResClu2R2C"<<std::endl;
528  hGlobal2ResClu2R2B->setBinContent(i,hGlobalResClu2R2B->getBinContent(i)); std::cout<<"hGlobal2ResClu2R2B"<<std::endl;
529  hGlobal2ResClu2R2A->setBinContent(i,hGlobalResClu2R2A->getBinContent(i)); std::cout<<"hGlobal2ResClu2R2A"<<std::endl;
530 
531  hGlobal2ResClu3R3C->setBinContent(i,hGlobalResClu3R3C->getBinContent(i)); std::cout<<"hGlobal2ResClu3R3C"<<std::endl;
532  hGlobal2ResClu3R3B->setBinContent(i,hGlobalResClu3R3B->getBinContent(i)); std::cout<<"hGlobal2ResClu3R3B"<<std::endl;
533  hGlobal2ResClu3R3A->setBinContent(i,hGlobalResClu3R3A->getBinContent(i)); std::cout<<"hGlobal2ResClu3R3A"<<std::endl;
534  hGlobal2ResClu3R2C->setBinContent(i,hGlobalResClu3R2C->getBinContent(i)); std::cout<<"hGlobal2ResClu3R2C"<<std::endl;
535  hGlobal2ResClu3R2B->setBinContent(i,hGlobalResClu3R2B->getBinContent(i)); std::cout<<"hGlobal2ResClu3R2B"<<std::endl;
536  hGlobal2ResClu3R2A->setBinContent(i,hGlobalResClu3R2A->getBinContent(i)); std::cout<<"hGlobal2ResClu3R2A"<<std::endl;
537  }*/
538 
539  //Setting Labels in Summary Label.
540  std::stringstream binLabel;
541 
542  if(debug) std::cout<<"Default -1 for Barrel GUI"<<std::endl;
543 
544  for(int x = 1;x<=12;x++){
545  for(int y = 1;y<=21;y++){
546  Wheelm2Summary->setBinContent(x,y,-1);
547  Wheelm1Summary->setBinContent(x,y,-1);
548  Wheel0Summary->setBinContent(x,y,-1);
549  Wheel1Summary->setBinContent(x,y,-1);
550  Wheel2Summary->setBinContent(x,y,-1);
551  }
552  }
553 
554  if(debug) std::cout<<"Default -1 for EndCap GUI"<<std::endl;
555 
556  for(int x = 1;x<=36;x++){
557  for(int y = 1;y<=6;y++){
558  Diskm3Summary->setBinContent(x,y,-1);
559  Diskm2Summary->setBinContent(x,y,-1);
560  Diskm1Summary->setBinContent(x,y,-1);
561  Disk1Summary->setBinContent(x,y,-1);
562  Disk2Summary->setBinContent(x,y,-1);
563  Disk3Summary->setBinContent(x,y,-1);
564  }
565  }
566 
567  binLabel.str("");
568 
569  int indexWheel[5];
570  for(int j=0;j<5;j++){
571  indexWheel[j]=0;
572  }
573 
574  int indexWheelf[5];
575  for(int j=0;j<5;j++){
576  indexWheelf[j]=0;
577  }
578 
579  int indexDisk[6];
580  for(int j=0;j<6;j++){
581  indexDisk[j]=0;
582  }
583 
584  int indexDiskf[6];
585  for(int j=0;j<6;j++){
586  indexDiskf[j]=0;
587  }
588 
589 // for(TrackingGeometry::DetContainer::const_iterator it=rpcGeo->dets().begin();it<rpcGeo->dets().end();it++){
590 // if(dynamic_cast< RPCChamber* >( *it ) != 0 ){
591 // RPCChamber* ch = dynamic_cast< RPCChamber* >( *it );
592 // std::vector< const RPCRoll*> roles = (ch->rolls());
593 // for(std::vector<const RPCRoll*>::const_iterator r = roles.begin();r != roles.end(); ++r){
594 // RPCDetId rpcId = (*r)->id();
595 // RPCGeomServ rpcsrv(rpcId);
596 // std::string nameRoll = rpcsrv.name();
597 // if(debug) std::cout<<"Booking for "<<nameRoll<<std::endl;
598 // meCollection[rpcId.rawId()] = bookDetUnitSeg(rpcId,(*r)->nstrips(),folderPath);
599 // }
600 // }
601 // }
602 
603  //if(debug) dbe->showDirStructure();
604 
605  for(TrackingGeometry::DetContainer::const_iterator it=rpcGeo->dets().begin();it<rpcGeo->dets().end();it++){
606  if(dynamic_cast< RPCChamber* >( *it ) != 0 ){
607  RPCChamber* ch = dynamic_cast< RPCChamber* >( *it );
608  std::vector< const RPCRoll*> roles = (ch->rolls());
609  for(std::vector<const RPCRoll*>::const_iterator r = roles.begin();r != roles.end(); ++r){
610  RPCDetId rpcId = (*r)->id();
611  RPCGeomServ rpcsrv(rpcId);
612 // int sector = rpcId.sector();
613  std::string nameRoll = rpcsrv.name();
614  // std::map<std::string, MonitorElement*> meMap=meCollection[rpcId.rawId()];
615 // if(debug){
616 // std::map<std::string, MonitorElement*>::const_iterator it;
617 // for (it = meMap.begin(); it != meMap.end(); ++it){
618 // std::cout<<"Histo name:" <<it->first<<std::endl;
619 // }
620 // }
621 
622 
623  if(debug){
624  if(meCollection.find(rpcId.rawId())==meCollection.end()){
625  std::cout<<"WARNING!!! Empty RecHit collection map"<<std::endl;
626  }
627  std::cout<<rpcId<<std::endl;
628  //printing indexes
629  std::cout<<"indexWheel=";
630  for(int j=0;j<5;j++){
631  std::cout<<indexWheel[j]<<" ";
632  }
633  std::cout<<std::endl;
634  std::cout<<"indexWheelf=";
635  for(int j=0;j<5;j++){
636  std::cout<<indexWheelf[j]<<" ";
637  }
638  std::cout<<std::endl;
639  std::cout<<"indexDisk=";
640  for(int j=0;j<6;j++){
641  std::cout<<indexDisk[j]<<" ";
642  }
643  std::cout<<std::endl;
644  std::cout<<"indexDiskf=";
645  for(int j=0;j<6;j++){
646  std::cout<<indexDiskf[j]<<" ";
647  }
648  std::cout<<std::endl;
649  }
650 
651  if(rpcId.region()==0){
652  std::stringstream meIdRPC, meIdDT; //, bxDistroId;
653  // std::string meIdPRO,
654  // std::string meIdRPC2, meIdDT2; //, bxDistroId2;
655 
656  // RPCBookFolderStructure * folderStr = new RPCBookFolderStructure();
657 
658  // std::string folder = folderPath+"MuonSegEff";
659 
660  //if(debug) std::cout<<"Setting the folder "<<folder<<std::endl;
661 
662  meIdRPC<<folderPath<<"MuonSegEff/RPCDataOccupancyFromDT_"<<rpcId.rawId();
663  meIdDT<<folderPath<<"MuonSegEff/ExpectedOccupancyFromDT_"<<rpcId.rawId();
664  // bxDistroId<<folder<<"/BXDistribution_"<<rpcId.rawId();
665 
666  // std::string folder2 = folderPath+"RollByRoll/" + folderStr->folderStructure(rpcId);
667 
668  // delete folderStr;
669 
670  // meIdRPC2 = "RPCDataOccupancyFromDT_" + rpcsrv.name();
671 // meIdDT2 = "ExpectedOccupancyFromDT_"+ rpcsrv.name();
672 
673  // meIdPRO = "Profile_"+ rpcsrv.name();
674 
675  histoRPC = dbe->get(meIdRPC.str());
676  histoDT = dbe->get(meIdDT.str());
677  // histoPRO = dbe->get(meIdPRO);
678 
679  int NumberWithOutPrediction=0;
680  double p = 0.;
681  double o = 0.;
682 // float mybxhisto = 0.;
683 // float mybxerror = 0.;
684  float ef = 0.;
685  float er = 0.;
686  float buffef = 0.;
687  float buffer = 0.;
688  float sumbuffef = 0.;
689  float sumbuffer = 0.;
690  float averageeff = 0.;
691  float averageerr = 0.;
692  int NumberStripsPointed = 0;
693 
694 
695  if(histoRPC && histoDT){ // && BXDistribution){
696  if(debug) std::cout <<rpcsrv.name()<<std::endl;
697 
698  for(int i=1;i<=int((*r)->nstrips());++i){
699 
700  if(histoDT->getBinContent(i)!=0){
701  if(debug) std::cout<<"Inside the If"<<std::endl;
702  buffef = float(histoRPC->getBinContent(i))/float(histoDT->getBinContent(i));
703  // meMap[meIdPRO]->setBinContent(i,buffef);
704  buffer = sqrt(buffef*(1.-buffef)/float(histoDT->getBinContent(i)));
705  // meMap[meIdPRO]->setBinError(i,buffer);
706  sumbuffef=sumbuffef+buffef;
707  sumbuffer = sumbuffer + buffer*buffer;
708  NumberStripsPointed++;
709  }else{
710  NumberWithOutPrediction++;
711  }
712  if(debug) std::cout<<"\t Strip="<<i<<" RPC="<<histoRPC->getBinContent(i)<<" DT="<<histoDT->getBinContent(i)<<" buffef="<<buffef<<" buffer="<<buffer<<" sumbuffef="<<sumbuffef<<" sumbuffer="<<sumbuffer<<" NumberStripsPointed="<<NumberStripsPointed<<" NumberWithOutPrediction"<<NumberWithOutPrediction<<std::endl;
713  }
714 
715  p=histoDT->getTH1F()->Integral();
716  o=histoRPC->getTH1F()->Integral();
717 
718  if(NumberStripsPointed!=0){
719  averageeff = (sumbuffef/float(NumberStripsPointed))*100.;
720  averageerr = sqrt(sumbuffer/float(NumberStripsPointed))*100.;
721  }
722 
723  }
724 
725  int Ring = rpcId.ring();
726 
727  if(p!=0){
728  ef = float(o)/float(p);
729  er = sqrt(ef*(1.-ef)/float(p));
730  }
731 
732  ef=ef*100;
733  er=er*100;
734 
735 
736  //Filling azimutal Wheel Histograms
737 
738  int wheel = rpcId.ring();
739  int sector = rpcId.sector();
740  int region = rpcId.region();
741 
742 
743  if(region ==0){
744 
745  int layer = 0;
746 
747  if(rpcId.station()==1&&rpcId.layer()==1) layer = 1;
748  else if(rpcId.station()==1&&rpcId.layer()==2) layer = 2;
749  else if(rpcId.station()==2&&rpcId.layer()==1) layer = 3;
750  else if(rpcId.station()==2&&rpcId.layer()==2) layer = 4;
751  else if(rpcId.station()==3) layer = 5;
752  else if(rpcId.station()==4) layer = 6;
753 
754  if(wheel==-2){ExsectorEffWm2->Fill(sector,p); OcsectorEffWm2->Fill(sector,o); ExpLayerWm2->Fill(layer, p); ObsLayerWm2->Fill(layer, o);}
755  else if(wheel==-1){ExsectorEffWm1->Fill(sector,p); OcsectorEffWm1->Fill(sector,o); ExpLayerWm1->Fill(layer, p); ObsLayerWm1->Fill(layer, o);}
756  else if(wheel==0){ExsectorEffW0->Fill(sector,p); OcsectorEffW0->Fill(sector,o); ExpLayerW0->Fill(layer, p); ObsLayerW0->Fill(layer, o);}
757  else if(wheel==1){ExsectorEffW1->Fill(sector,p); OcsectorEffW1->Fill(sector,o); ExpLayerW1->Fill(layer, p); ObsLayerW1->Fill(layer, o);}
758  else if(wheel==2){ExsectorEffW2->Fill(sector,p); OcsectorEffW2->Fill(sector,o); ExpLayerW2->Fill(layer, p); ObsLayerW2->Fill(layer, o);}
759  }
760 
761 
762  std::string camera = rpcsrv.name();
763 
764  //float nopredictionsratio = (float(NumberWithOutPrediction)/float((*r)->nstrips()))*100.;
765 
766  //Efficiency for Pigis Histos
767 
768  if(debug) std::cout<<"Pigi "<<camera<<" "<<rpcsrv.shortname()<<" "
769  <<(*r)->id()<<std::endl;
770 
771  if(p > 100){//We need at least 100 predictions to fill the summary plot
772 
773  int xBin,yBin;
774  xBin= (*r)->id().sector();
775  rpcdqm::utils rollNumber;
776  yBin = rollNumber.detId2RollNr((*r)->id());
777 
778  if((*r)->id().ring()==2) Wheel2Summary->setBinContent(xBin,yBin,averageeff);
779  else if((*r)->id().ring()==1) Wheel1Summary->setBinContent(xBin,yBin,averageeff);
780  else if((*r)->id().ring()==0) Wheel0Summary->setBinContent(xBin,yBin,averageeff);
781  else if((*r)->id().ring()==-1) Wheelm1Summary->setBinContent(xBin,yBin,averageeff);
782  else if((*r)->id().ring()==-2) Wheelm2Summary->setBinContent(xBin,yBin,averageeff);
783 
784  }
785 
786  //Near Side
787 
788  //float maskedratio =0;
789 
790 // if((sector==1||sector==2||sector==3||sector==10||sector==11||sector==12)){
791  if(Ring==-2){
792  EffDistroWm2->Fill(averageeff);
793  indexWheel[0]++;
794  EffGlobWm2->setBinContent(indexWheel[0],ef);
795  EffGlobWm2->setBinError(indexWheel[0],er);
796  EffGlobWm2->setBinLabel(indexWheel[0],camera,1);
797 
798 // BXGlobWm2->setBinContent(indexWheel[0],mybxhisto);
799 // BXGlobWm2->setBinError(indexWheel[0],mybxerror);
800 // BXGlobWm2->setBinLabel(indexWheel[0],camera,1);
801 
802 // MaskedGlobWm2->setBinContent(indexWheel[0],maskedratio);
803 // MaskedGlobWm2->setBinLabel(indexWheel[0],camera,1);
804 
805 // AverageEffWm2->setBinContent(indexWheel[0],averageeff);
806 // AverageEffWm2->setBinError(indexWheel[0],averageerr);
807 // AverageEffWm2->setBinLabel(indexWheel[0],camera,1);
808 
809 // NoPredictionWm2->setBinContent(indexWheel[0],nopredictionsratio);
810 // NoPredictionWm2->setBinLabel(indexWheel[0],camera,1);
811  }else if(Ring==-1){
812  EffDistroWm1->Fill(averageeff);
813  indexWheel[1]++;
814  EffGlobWm1->setBinContent(indexWheel[1],ef);
815  EffGlobWm1->setBinError(indexWheel[1],er);
816  EffGlobWm1->setBinLabel(indexWheel[1],camera,1);
817 
818 // BXGlobWm1->setBinContent(indexWheel[1],mybxhisto);
819 // BXGlobWm1->setBinError(indexWheel[1],mybxerror);
820 // BXGlobWm1->setBinLabel(indexWheel[1],camera,1);
821 
822 // MaskedGlobWm1->setBinContent(indexWheel[1],maskedratio);
823 // MaskedGlobWm1->setBinLabel(indexWheel[1],camera,1);
824 
825 // AverageEffWm1->setBinContent(indexWheel[1],averageeff);
826 // AverageEffWm1->setBinError(indexWheel[1],averageerr);
827 // AverageEffWm1->setBinLabel(indexWheel[1],camera,1);
828 
829 // NoPredictionWm1->setBinContent(indexWheel[1],nopredictionsratio);
830 // NoPredictionWm1->setBinLabel(indexWheel[1],camera,1);
831 
832  }else if(Ring==0){
833  EffDistroW0->Fill(averageeff);
834  indexWheel[2]++;
835  EffGlobW0->setBinContent(indexWheel[2],ef);
836  EffGlobW0->setBinError(indexWheel[2],er);
837  EffGlobW0->setBinLabel(indexWheel[2],camera,1);
838 
839 // BXGlobW0->setBinContent(indexWheel[2],mybxhisto);
840 // BXGlobW0->setBinError(indexWheel[2],mybxerror);
841 // BXGlobW0->setBinLabel(indexWheel[2],camera,1);
842 
843 // MaskedGlobW0->setBinContent(indexWheel[2],maskedratio);
844 // MaskedGlobW0->setBinLabel(indexWheel[2],camera,1);
845 
846 // AverageEffW0->setBinContent(indexWheel[2],averageeff);
847 // AverageEffW0->setBinError(indexWheel[2],averageerr);
848 // AverageEffW0->setBinLabel(indexWheel[2],camera,1);
849 
850 // NoPredictionW0->setBinContent(indexWheel[2],nopredictionsratio);
851 // NoPredictionW0->setBinLabel(indexWheel[2],camera,1);
852  }else if(Ring==1){
853  EffDistroW1->Fill(averageeff);
854  indexWheel[3]++;
855  EffGlobW1->setBinContent(indexWheel[3],ef);
856  EffGlobW1->setBinError(indexWheel[3],er);
857  EffGlobW1->setBinLabel(indexWheel[3],camera,1);
858 
859 // BXGlobW1->setBinContent(indexWheel[3],mybxhisto);
860 // BXGlobW1->setBinError(indexWheel[3],mybxerror);
861 // BXGlobW1->setBinLabel(indexWheel[3],camera,1);
862 
863 // MaskedGlobW1->setBinContent(indexWheel[3],maskedratio);
864 // MaskedGlobW1->setBinLabel(indexWheel[3],camera,1);
865 
866 // AverageEffW1->setBinContent(indexWheel[3],averageeff);
867 // AverageEffW1->setBinError(indexWheel[3],averageerr);
868 // AverageEffW1->setBinLabel(indexWheel[3],camera,1);
869 
870 // NoPredictionW1->setBinContent(indexWheel[3],nopredictionsratio);
871 // NoPredictionW1->setBinLabel(indexWheel[3],camera,1);
872  }else if(Ring==2){
873  EffDistroW2->Fill(averageeff);
874  indexWheel[4]++;
875  EffGlobW2->setBinContent(indexWheel[4],ef);
876  EffGlobW2->setBinError(indexWheel[4],er);
877  EffGlobW2->setBinLabel(indexWheel[4],camera,1);
878 
879 // BXGlobW2->setBinContent(indexWheel[4],mybxhisto);
880 // BXGlobW2->setBinError(indexWheel[4],mybxerror);
881 // BXGlobW2->setBinLabel(indexWheel[4],camera,1);
882 
883 // MaskedGlobW2->setBinContent(indexWheel[4],maskedratio);
884 // MaskedGlobW2->setBinLabel(indexWheel[4],camera,1);
885 
886 // AverageEffW2->setBinContent(indexWheel[4],averageeff);
887 // AverageEffW2->setBinError(indexWheel[4],averageerr);
888 // AverageEffW2->setBinLabel(indexWheel[4],camera,1);
889 
890 // NoPredictionW2->setBinContent(indexWheel[4],nopredictionsratio);
891 // NoPredictionW2->setBinLabel(indexWheel[4],camera,1);
892  }
893 /* }else{//Far Side
894  if(Ring==-2){
895  EffDistroWm2far->Fill(averageeff);
896  indexWheelf[0]++;
897  EffGlobWm2far->setBinContent(indexWheelf[0],ef);
898  EffGlobWm2far->setBinError(indexWheelf[0],er);
899  EffGlobWm2far->setBinLabel(indexWheelf[0],camera,1);
900 
901 // BXGlobWm2far->setBinContent(indexWheelf[0],mybxhisto);
902 // BXGlobWm2far->setBinError(indexWheelf[0],mybxerror);
903 // BXGlobWm2far->setBinLabel(indexWheelf[0],camera);
904 
905  MaskedGlobWm2far->setBinContent(indexWheelf[0],maskedratio);
906  MaskedGlobWm2far->setBinLabel(indexWheelf[0],camera,1);
907 
908  AverageEffWm2far->setBinContent(indexWheelf[0],averageeff);
909  AverageEffWm2far->setBinError(indexWheelf[0],averageerr);
910  AverageEffWm2far->setBinLabel(indexWheelf[0],camera,1);
911 
912  NoPredictionWm2->setBinContent(indexWheel[0],nopredictionsratio);
913  NoPredictionWm2->setBinLabel(indexWheel[0],camera,1);
914 
915  }else if(Ring==-1){
916  EffDistroWm1far->Fill(averageeff);
917  indexWheelf[1]++;
918  EffGlobWm1far->setBinContent(indexWheelf[1],ef);
919  EffGlobWm1far->setBinError(indexWheelf[1],er);
920  EffGlobWm1far->setBinLabel(indexWheelf[1],camera,1);
921 
922  // BXGlobWm1far->setBinContent(indexWheelf[1],mybxhisto);
923 // BXGlobWm1far->setBinError(indexWheelf[1],mybxerror);
924 // BXGlobWm1far->setBinLabel(indexWheelf[1],camera,1);
925 
926  MaskedGlobWm1far->setBinContent(indexWheelf[1],maskedratio);
927  MaskedGlobWm1far->setBinLabel(indexWheelf[1],camera,1);
928 
929  AverageEffWm1far->setBinContent(indexWheelf[1],averageeff);
930  AverageEffWm1far->setBinError(indexWheelf[1],averageerr);
931  AverageEffWm1far->setBinLabel(indexWheelf[1],camera,1);
932 
933  NoPredictionWm1far->setBinContent(indexWheelf[1],nopredictionsratio);
934  NoPredictionWm1far->setBinLabel(indexWheelf[1],camera,1);
935 
936  }else if(Ring==0){
937  EffDistroW0far->Fill(averageeff);
938  indexWheelf[2]++;
939  EffGlobW0far->setBinContent(indexWheelf[2],ef);
940  EffGlobW0far->setBinError(indexWheelf[2],er);
941  EffGlobW0far->setBinLabel(indexWheelf[2],camera,1);
942 
943 // BXGlobW0far->setBinContent(indexWheelf[2],mybxhisto);
944 // BXGlobW0far->setBinError(indexWheelf[2],mybxerror);
945 // BXGlobW0far->setBinLabel(indexWheelf[2],camera,1);
946 
947  MaskedGlobW0far->setBinContent(indexWheelf[2],maskedratio);
948  MaskedGlobW0far->setBinLabel(indexWheelf[2],camera,1);
949 
950  AverageEffW0far->setBinContent(indexWheelf[2],averageeff);
951  AverageEffW0far->setBinError(indexWheelf[2],averageerr);
952  AverageEffW0far->setBinLabel(indexWheelf[2],camera,1);
953 
954  NoPredictionW0far->setBinContent(indexWheelf[2],nopredictionsratio);
955  NoPredictionW0far->setBinLabel(indexWheelf[2],camera,1);
956  }else if(Ring==1){
957  EffDistroW1far->Fill(averageeff);
958  indexWheelf[3]++;
959  EffGlobW1far->setBinContent(indexWheelf[3],ef);
960  EffGlobW1far->setBinError(indexWheelf[3],er);
961  EffGlobW1far->setBinLabel(indexWheelf[3],camera,1);
962 
963  // BXGlobW1far->setBinContent(indexWheelf[3],mybxhisto);
964 // BXGlobW1far->setBinError(indexWheelf[3],mybxerror);
965 // BXGlobW1far->setBinLabel(indexWheelf[3],camera,1);
966 
967  MaskedGlobW1far->setBinContent(indexWheelf[3],maskedratio);
968  MaskedGlobW1far->setBinLabel(indexWheelf[3],camera,1);
969 
970  AverageEffW1far->setBinContent(indexWheelf[3],averageeff);
971  AverageEffW1far->setBinError(indexWheelf[3],averageerr);
972  AverageEffW1far->setBinLabel(indexWheelf[3],camera,1);
973 
974  NoPredictionW1far->setBinContent(indexWheelf[3],nopredictionsratio);
975  NoPredictionW1far->setBinLabel(indexWheelf[3],camera,1);
976 
977  }else if(Ring==2){
978  EffDistroW2far->Fill(averageeff);
979  indexWheelf[4]++;
980  EffGlobW2far->setBinContent(indexWheelf[4],ef);
981  EffGlobW2far->setBinError(indexWheelf[4],er);
982  EffGlobW2far->setBinLabel(indexWheelf[4],camera,1);
983 
984  // BXGlobW2far->setBinContent(indexWheelf[4],mybxhisto);
985 // BXGlobW2far->setBinError(indexWheelf[4],mybxerror);
986 // BXGlobW2far->setBinLabel(indexWheelf[4],camera,1);
987 
988  MaskedGlobW2far->setBinContent(indexWheelf[4],maskedratio);
989  MaskedGlobW2far->setBinLabel(indexWheelf[4],camera,1);
990 
991  AverageEffW2far->setBinContent(indexWheelf[4],averageeff);
992  AverageEffW2far->setBinError(indexWheelf[4],averageerr);
993  AverageEffW2far->setBinLabel(indexWheelf[4],camera,1);
994 
995  NoPredictionW2far->setBinContent(indexWheelf[4],nopredictionsratio);
996  NoPredictionW2far->setBinLabel(indexWheelf[4],camera,1);
997  }
998  }*/
999  }else{//EndCap
1000 
1001  std::stringstream meIdRPC,meIdCSC; //, bxDistroId;
1002  std::string meIdPRO;
1003  // std::string meIdRPC2, meIdCSC2; //, bxDistroId2;
1004 
1005  // RPCBookFolderStructure * folderStr = new RPCBookFolderStructure();
1006 
1007  // std::string folder = folderPath+"MuonSegEff";
1008 
1009  meIdRPC<<folderPath<<"MuonSegEff/RPCDataOccupancyFromCSC_"<<rpcId.rawId();
1010  meIdCSC<<folderPath<<"MuonSegEff/ExpectedOccupancyFromCSC_"<<rpcId.rawId();
1011  // bxDistroId<<folder<<"/BXDistribution_"<<rpcId.rawId();
1012 
1013  // std::string folder2 = folderPath+"RollByRoll/" + folderStr->folderStructure(rpcId);
1014 
1015  // delete folderStr;
1016 
1017 // meIdRPC2 = "RPCDataOccupancyFromCSC_" + rpcsrv.name();
1018 // meIdCSC2 = "ExpectedOccupancyFromCSC_"+ rpcsrv.name();
1019  // bxDistroId2 = "BXDistribution_"+ rpcsrv.name();
1020 
1021  meIdPRO = "Profile_"+ rpcsrv.name();
1022 
1023  histoRPC= dbe->get(meIdRPC.str());
1024  histoCSC= dbe->get(meIdCSC.str());
1025  //BXDistribution = dbe->get(bxDistroId.str());
1026 
1027  int NumberWithOutPrediction=0;
1028  double p = 0;
1029  double o = 0;
1030  // float mybxhisto = 0;
1031  //float mybxerror = 0;
1032  float ef =0;
1033  float er =0;
1034  float buffef = 0;
1035  float buffer = 0;
1036  float sumbuffef = 0;
1037  float sumbuffer = 0;
1038  float averageeff = 0;
1039  float averageerr = 0;
1040  int NumberStripsPointed = 0;
1041 
1042  // if(debug) std::cout<<"Cloning BX"<<std::endl;
1043 
1044 // for(int i=1;i<=11;i++){
1045 // if(debug) std::cout<<i<<"-"<<BXDistribution->getBinContent(i)<<std::endl;
1046 // meMap[bxDistroId2]->setBinContent(i,BXDistribution->getBinContent(i));
1047 // }
1048 
1049  if(histoRPC && histoCSC) {// && BXDistribution){
1050  if(debug) std::cout <<rpcsrv.name()<<std::endl;
1051 
1052  for(int i=1;i<=int((*r)->nstrips());++i){
1053 // if(debug) std::cout<<"Cloning histoCSC "<<meIdCSC2<<std::endl;
1054 // meMap[meIdCSC2]->setBinContent(i,histoCSC->getBinContent(i));
1055 // if(debug) std::cout<<"Cloning histoRPC:"<<meIdRPC2<<std::endl;
1056 // meMap[meIdRPC2]->setBinContent(i,histoRPC->getBinContent(i));
1057 
1058 // if(meMap.find(meIdPRO)==meMap.end()){
1059 // std::cout<<"Empty Map"<<std::endl;
1060 // }
1061 
1062  if(histoCSC->getBinContent(i)!=0){
1063  if(debug) std::cout<<"Inside the If"<<std::endl;
1064  buffef = float(histoRPC->getBinContent(i))/float(histoCSC->getBinContent(i));
1065  // meMap[meIdPRO]->setBinContent(i,buffef);
1066  buffer = sqrt(buffef*(1.-buffef)/float(histoCSC->getBinContent(i)));
1067  // meMap[meIdPRO]->setBinError(i,buffer);
1068  sumbuffef=sumbuffef+buffef;
1069  sumbuffer = sumbuffer + buffer*buffer;
1070  NumberStripsPointed++;
1071  }else{
1072  NumberWithOutPrediction++;
1073  }
1074 
1075  if(debug) std::cout<<"\t Strip="<<i<<" RPC="<<histoRPC->getBinContent(i)<<" CSC="<<histoCSC->getBinContent(i)<<" buffef="<<buffef<<" buffer="<<buffer<<" sumbuffef="<<sumbuffef<<" sumbuffer="<<sumbuffer<<" NumberStripsPointed="<<NumberStripsPointed<<" NumberWithOutPrediction"<<NumberWithOutPrediction<<std::endl;
1076  }
1077  p=histoCSC->getTH1F()->Integral();
1078  o=histoRPC->getTH1F()->Integral();
1079 
1080  if(NumberStripsPointed!=0){
1081  averageeff = (sumbuffef/float(NumberStripsPointed))*100.;
1082  averageerr = sqrt(sumbuffer/float(NumberStripsPointed))*100.;
1083  }
1084 
1085  // mybxhisto = 50.+BXDistribution->getMean()*10;
1086 // mybxerror = BXDistribution->getRMS()*10;
1087  }
1088 
1089  int Disk = rpcId.station()*rpcId.region();
1090 
1091  if(p!=0){
1092  ef = float(o)/float(p);
1093  er = sqrt(ef*(1.-ef)/float(p));
1094  }
1095 
1096  ef=ef*100;
1097  er=er*100;
1098 
1099  //Filling azimutal GregHistograms
1100 
1101  if(rpcId.region()==1){
1102  if(rpcId.station()==1 && rpcId.ring()==2){ ExGregD1R2->Fill(rpcsrv.segment(),p);OcGregD1R2->Fill(rpcsrv.segment(),o);}
1103  else if(rpcId.station()==1 && rpcId.ring()==3){ ExGregD1R3->Fill(rpcsrv.segment(),p);OcGregD1R3->Fill(rpcsrv.segment(),o);}
1104  else if(rpcId.station()==2 && rpcId.ring()==2){ ExGregD2R2->Fill(rpcsrv.segment(),p);OcGregD2R2->Fill(rpcsrv.segment(),o);}
1105  else if(rpcId.station()==2 && rpcId.ring()==3){ ExGregD2R3->Fill(rpcsrv.segment(),p);OcGregD2R3->Fill(rpcsrv.segment(),o);}
1106  else if(rpcId.station()==3 && rpcId.ring()==2){ ExGregD3R2->Fill(rpcsrv.segment(),p);OcGregD3R2->Fill(rpcsrv.segment(),o);}
1107  else if(rpcId.station()==3 && rpcId.ring()==3){ ExGregD3R3->Fill(rpcsrv.segment(),p);OcGregD3R3->Fill(rpcsrv.segment(),o);}
1108  }else if(rpcId.region()==-1){
1109  if(rpcId.station()==1 && rpcId.ring()==2){ ExGregDm1R2->Fill(rpcsrv.segment(),p);OcGregDm1R2->Fill(rpcsrv.segment(),o);}
1110  else if(rpcId.station()==1 && rpcId.ring()==3){ ExGregDm1R3->Fill(rpcsrv.segment(),p);OcGregDm1R3->Fill(rpcsrv.segment(),o);}
1111  else if(rpcId.station()==2 && rpcId.ring()==2){ ExGregDm2R2->Fill(rpcsrv.segment(),p);OcGregDm2R2->Fill(rpcsrv.segment(),o);}
1112  else if(rpcId.station()==2 && rpcId.ring()==3){ ExGregDm2R3->Fill(rpcsrv.segment(),p);OcGregDm2R3->Fill(rpcsrv.segment(),o);}
1113  else if(rpcId.station()==3 && rpcId.ring()==2){ ExGregDm3R2->Fill(rpcsrv.segment(),p);OcGregDm3R2->Fill(rpcsrv.segment(),o);}
1114  else if(rpcId.station()==3 && rpcId.ring()==3){ ExGregDm3R3->Fill(rpcsrv.segment(),p);OcGregDm3R3->Fill(rpcsrv.segment(),o);}
1115  }
1116 
1117  std::string camera = rpcsrv.name();
1118 
1119  //float nopredictionsratio = (float(NumberWithOutPrediction)/float((*r)->nstrips()))*100.;
1120 
1121 
1122  //Efficiency for Pigis Histos
1123 
1124  if(debug) std::cout<<"Pigi "<<camera<<" "<<rpcsrv.shortname()<<" "
1125  <<(*r)->id()<<std::endl;
1126 
1127 
1128 
1129  if(p > 100){ //We need at least 100 predictions to fill the summary plot
1130  RPCGeomServ RPCServ((*r)->id());
1131  int xBin = RPCServ.segment();
1132  int yBin= ((*r)->id().ring()-1)*3-(*r)->id().roll()+1;
1133  if(Disk==-3) Diskm3Summary->setBinContent(xBin, yBin, averageeff);
1134  else if(Disk==-2) Diskm2Summary->setBinContent(xBin, yBin, averageeff);
1135  else if(Disk==-1) Diskm1Summary->setBinContent(xBin, yBin, averageeff);
1136  else if(Disk==1) Disk1Summary->setBinContent(xBin, yBin, averageeff);
1137  else if(Disk==2) Disk2Summary->setBinContent(xBin, yBin, averageeff);
1138  else if(Disk==3) Disk3Summary->setBinContent(xBin, yBin, averageeff);
1139  }
1140 
1141  //Near Side
1142 
1143  //float maskedratio =0;
1144 
1145 // if(sector==1||sector==2||sector==6){
1146 
1147  if(Disk==-3){
1148  EffDistroDm3->Fill(averageeff);
1149  indexDisk[0]++;
1150  EffGlobDm3->setBinContent(indexDisk[0],ef);
1151  EffGlobDm3->setBinError(indexDisk[0],er);
1152  EffGlobDm3->setBinLabel(indexDisk[0],camera,1);
1153 
1154 // BXGlobDm3->setBinContent(indexDisk[0],mybxhisto);
1155 // BXGlobDm3->setBinError(indexDisk[0],mybxerror);
1156 // BXGlobDm3->setBinLabel(indexDisk[0],camera,1);
1157 
1158 // MaskedGlobDm3->setBinContent(indexDisk[0],maskedratio);
1159 // MaskedGlobDm3->setBinLabel(indexDisk[0],camera,1);
1160 
1161 // AverageEffDm3->setBinContent(indexDisk[0],averageeff);
1162 // AverageEffDm3->setBinError(indexDisk[0],averageerr);
1163 // AverageEffDm3->setBinLabel(indexDisk[0],camera,1);
1164 
1165 // NoPredictionDm3->setBinContent(indexDisk[0],nopredictionsratio);
1166 // NoPredictionDm3->setBinLabel(indexDisk[0],camera,1);
1167  }else if(Disk==-2){
1168  EffDistroDm2->Fill(averageeff);
1169  indexDisk[1]++;
1170  EffGlobDm2->setBinContent(indexDisk[1],ef);
1171  EffGlobDm2->setBinError(indexDisk[1],er);
1172  EffGlobDm2->setBinLabel(indexDisk[1],camera,1);
1173 
1174 // BXGlobDm2->setBinContent(indexDisk[1],mybxhisto);
1175 // BXGlobDm2->setBinError(indexDisk[1],mybxerror);
1176 // BXGlobDm2->setBinLabel(indexDisk[1],camera,1);
1177 
1178 // MaskedGlobDm2->setBinContent(indexDisk[1],maskedratio);
1179 // MaskedGlobDm2->setBinLabel(indexDisk[1],camera,1);
1180 
1181 // AverageEffDm2->setBinContent(indexDisk[1],averageeff);
1182 // AverageEffDm2->setBinError(indexDisk[1],averageerr);
1183 // AverageEffDm2->setBinLabel(indexDisk[1],camera,1);
1184 
1185 // NoPredictionDm2->setBinContent(indexDisk[1],nopredictionsratio);
1186 // NoPredictionDm2->setBinLabel(indexDisk[1],camera,1);
1187  }else if(Disk==-1){
1188  EffDistroDm1->Fill(averageeff);
1189  indexDisk[2]++;
1190  EffGlobDm1->setBinContent(indexDisk[2],ef);
1191  EffGlobDm1->setBinError(indexDisk[2],er);
1192  EffGlobDm1->setBinLabel(indexDisk[2],camera,1);
1193 
1194 // BXGlobDm1->setBinContent(indexDisk[2],mybxhisto);
1195 // BXGlobDm1->setBinError(indexDisk[2],mybxerror);
1196 // BXGlobDm1->setBinLabel(indexDisk[2],camera,1);
1197 
1198 // MaskedGlobDm1->setBinContent(indexDisk[2],maskedratio);
1199 // MaskedGlobDm1->setBinLabel(indexDisk[2],camera,1);
1200 
1201 // AverageEffDm1->setBinContent(indexDisk[2],averageeff);
1202 // AverageEffDm1->setBinError(indexDisk[2],averageerr);
1203 // AverageEffDm1->setBinLabel(indexDisk[2],camera,1);
1204 
1205 // NoPredictionDm1->setBinContent(indexDisk[2],nopredictionsratio);
1206 // NoPredictionDm1->setBinLabel(indexDisk[2],camera,1);
1207 
1208  }else if(Disk==1){
1209  EffDistroD1->Fill(averageeff);
1210  indexDisk[3]++;
1211  EffGlobD1->setBinContent(indexDisk[3],ef);
1212  EffGlobD1->setBinError(indexDisk[3],er);
1213  EffGlobD1->setBinLabel(indexDisk[3],camera,1);
1214 
1215 // BXGlobD1->setBinContent(indexDisk[3],mybxhisto);
1216 // BXGlobD1->setBinError(indexDisk[3],mybxerror);
1217 // BXGlobD1->setBinLabel(indexDisk[3],camera,1);
1218 
1219 // MaskedGlobD1->setBinContent(indexDisk[3],maskedratio);
1220 // MaskedGlobD1->setBinLabel(indexDisk[3],camera,1);
1221 
1222 // AverageEffD1->setBinContent(indexDisk[3],averageeff);
1223 // AverageEffD1->setBinError(indexDisk[3],averageerr);
1224 // AverageEffD1->setBinLabel(indexDisk[3],camera,1);
1225 
1226 // NoPredictionD1->setBinContent(indexDisk[3],nopredictionsratio);
1227 // NoPredictionD1->setBinLabel(indexDisk[3],camera,1);
1228  }else if(Disk==2){
1229  EffDistroD2->Fill(averageeff);
1230  indexDisk[4]++;
1231  EffGlobD2->setBinContent(indexDisk[4],ef);
1232  EffGlobD2->setBinError(indexDisk[4],er);
1233  EffGlobD2->setBinLabel(indexDisk[4],camera,1);
1234 
1235 // BXGlobD2->setBinContent(indexDisk[4],mybxhisto);
1236 // BXGlobD2->setBinError(indexDisk[4],mybxerror);
1237 // BXGlobD2->setBinLabel(indexDisk[4],camera,1);
1238 
1239 // MaskedGlobD2->setBinContent(indexDisk[4],maskedratio);
1240 // MaskedGlobD2->setBinLabel(indexDisk[4],camera,1);
1241 
1242 // AverageEffD2->setBinContent(indexDisk[4],averageeff);
1243 // AverageEffD2->setBinError(indexDisk[4],averageerr);
1244 // AverageEffD2->setBinLabel(indexDisk[4],camera,1);
1245 
1246 // NoPredictionD2->setBinContent(indexDisk[4],nopredictionsratio);
1247 // NoPredictionD2->setBinLabel(indexDisk[4],camera,1);
1248  }else if(Disk==3){
1249  EffDistroD3->Fill(averageeff);
1250  indexDisk[5]++;
1251  EffGlobD3->setBinContent(indexDisk[5],ef);
1252  EffGlobD3->setBinError(indexDisk[5],er);
1253  EffGlobD3->setBinLabel(indexDisk[5],camera,1);
1254 
1255 // BXGlobD3->setBinContent(indexDisk[5],mybxhisto);
1256 // BXGlobD3->setBinError(indexDisk[5],mybxerror);
1257 // BXGlobD3->setBinLabel(indexDisk[5],camera,1);
1258 
1259 // MaskedGlobD3->setBinContent(indexDisk[5],maskedratio);
1260 // MaskedGlobD3->setBinLabel(indexDisk[5],camera,1);
1261 
1262 // AverageEffD3->setBinContent(indexDisk[5],averageeff);
1263 // AverageEffD3->setBinError(indexDisk[5],averageerr);
1264 // AverageEffD3->setBinLabel(indexDisk[5],camera,1);
1265 
1266 // NoPredictionD3->setBinContent(indexDisk[5],nopredictionsratio);
1267 // NoPredictionD3->setBinLabel(indexDisk[5],camera,1);
1268  }
1269 /* }else{//Far Side
1270 
1271  if(Disk==-3){
1272  EffDistroDm3far->Fill(averageeff);
1273  indexDiskf[0]++;
1274  EffGlobDm3far->setBinContent(indexDiskf[0],ef);
1275  EffGlobDm3far->setBinError(indexDiskf[0],er);
1276  EffGlobDm3far->setBinLabel(indexDiskf[0],camera,1);
1277 
1278  // BXGlobDm3far->setBinContent(indexDiskf[0],mybxhisto);
1279 // BXGlobDm3far->setBinError(indexDiskf[0],mybxerror);
1280 // BXGlobDm3far->setBinLabel(indexDiskf[0],camera);
1281 
1282  MaskedGlobDm3far->setBinContent(indexDiskf[0],maskedratio);
1283  MaskedGlobDm3far->setBinLabel(indexDiskf[0],camera,1);
1284 
1285  AverageEffDm3far->setBinContent(indexDiskf[0],averageeff);
1286  AverageEffDm3far->setBinError(indexDiskf[0],averageerr);
1287  AverageEffDm3far->setBinLabel(indexDiskf[0],camera,1);
1288 
1289  NoPredictionDm3->setBinContent(indexDisk[0],nopredictionsratio);
1290  NoPredictionDm3->setBinLabel(indexDisk[0],camera,1);
1291 
1292  }
1293  else if(Disk==-2){
1294  EffDistroDm2far->Fill(averageeff);
1295  indexDiskf[1]++;
1296  EffGlobDm2far->setBinContent(indexDiskf[1],ef);
1297  EffGlobDm2far->setBinError(indexDiskf[1],er);
1298  EffGlobDm2far->setBinLabel(indexDiskf[1],camera,1);
1299 
1300  // BXGlobDm2far->setBinContent(indexDiskf[1],mybxhisto);
1301 // BXGlobDm2far->setBinError(indexDiskf[1],mybxerror);
1302 // BXGlobDm2far->setBinLabel(indexDiskf[1],camera);
1303 
1304  MaskedGlobDm2far->setBinContent(indexDiskf[1],maskedratio);
1305  MaskedGlobDm2far->setBinLabel(indexDiskf[1],camera,1);
1306 
1307  AverageEffDm2far->setBinContent(indexDiskf[1],averageeff);
1308  AverageEffDm2far->setBinError(indexDiskf[1],averageerr);
1309  AverageEffDm2far->setBinLabel(indexDiskf[1],camera,1);
1310 
1311  NoPredictionDm2->setBinContent(indexDisk[1],nopredictionsratio);
1312  NoPredictionDm2->setBinLabel(indexDisk[1],camera,1);
1313 
1314  }else if(Disk==-1){
1315  EffDistroDm1far->Fill(averageeff);
1316  indexDiskf[2]++;
1317  EffGlobDm1far->setBinContent(indexDiskf[2],ef);
1318  EffGlobDm1far->setBinError(indexDiskf[2],er);
1319  EffGlobDm1far->setBinLabel(indexDiskf[2],camera,1);
1320 
1321 // BXGlobDm1far->setBinContent(indexDiskf[2],mybxhisto);
1322 // BXGlobDm1far->setBinError(indexDiskf[2],mybxerror);
1323 // BXGlobDm1far->setBinLabel(indexDiskf[2],camera,1);
1324 
1325  MaskedGlobDm1far->setBinContent(indexDiskf[2],maskedratio);
1326  MaskedGlobDm1far->setBinLabel(indexDiskf[2],camera,1);
1327 
1328  AverageEffDm1far->setBinContent(indexDiskf[2],averageeff);
1329  AverageEffDm1far->setBinError(indexDiskf[2],averageerr);
1330  AverageEffDm1far->setBinLabel(indexDiskf[2],camera,1);
1331 
1332  NoPredictionDm1far->setBinContent(indexDiskf[2],nopredictionsratio);
1333  NoPredictionDm1far->setBinLabel(indexDiskf[2],camera,1);
1334 
1335  }else if(Disk==1){
1336  EffDistroD1far->Fill(averageeff);
1337  indexDiskf[3]++;
1338  EffGlobD1far->setBinContent(indexDiskf[3],ef);
1339  EffGlobD1far->setBinError(indexDiskf[3],er);
1340  EffGlobD1far->setBinLabel(indexDiskf[3],camera,1);
1341 
1342 // BXGlobD1far->setBinContent(indexDiskf[3],mybxhisto);
1343 // BXGlobD1far->setBinError(indexDiskf[3],mybxerror);
1344 // BXGlobD1far->setBinLabel(indexDiskf[3],camera,1);
1345 
1346  MaskedGlobD1far->setBinContent(indexDiskf[3],maskedratio);
1347  MaskedGlobD1far->setBinLabel(indexDiskf[3],camera,1);
1348 
1349  AverageEffD1far->setBinContent(indexDiskf[3],averageeff);
1350  AverageEffD1far->setBinError(indexDiskf[3],averageerr);
1351  AverageEffD1far->setBinLabel(indexDiskf[3],camera,1);
1352 
1353  NoPredictionD1far->setBinContent(indexDiskf[3],nopredictionsratio);
1354  NoPredictionD1far->setBinLabel(indexDiskf[3],camera,1);
1355 
1356  }else if(Disk==2){
1357  EffDistroD2far->Fill(averageeff);
1358  indexDiskf[4]++;
1359  EffGlobD2far->setBinContent(indexDiskf[4],ef);
1360  EffGlobD2far->setBinError(indexDiskf[4],er);
1361  EffGlobD2far->setBinLabel(indexDiskf[4],camera,1);
1362 
1363 // BXGlobD2far->setBinContent(indexDiskf[4],mybxhisto);
1364 // BXGlobD2far->setBinError(indexDiskf[4],mybxerror);
1365 // BXGlobD2far->setBinLabel(indexDiskf[4],camera,1);
1366 
1367  MaskedGlobD2far->setBinContent(indexDiskf[4],maskedratio);
1368  MaskedGlobD2far->setBinLabel(indexDiskf[4],camera,1);
1369 
1370  AverageEffD2far->setBinContent(indexDiskf[4],averageeff);
1371  AverageEffD2far->setBinError(indexDiskf[4],averageerr);
1372  AverageEffD2far->setBinLabel(indexDiskf[4],camera,1);
1373 
1374  NoPredictionD2far->setBinContent(indexDiskf[4],nopredictionsratio);
1375  NoPredictionD2far->setBinLabel(indexDiskf[4],camera,1);
1376  }else if(Disk==3){
1377  EffDistroD3far->Fill(averageeff);
1378  indexDiskf[5]++;
1379  EffGlobD3far->setBinContent(indexDiskf[5],ef);
1380  EffGlobD3far->setBinError(indexDiskf[5],er);
1381  EffGlobD3far->setBinLabel(indexDiskf[5],camera,1);
1382 
1383 // BXGlobD3far->setBinContent(indexDiskf[5],mybxhisto);
1384 // BXGlobD3far->setBinError(indexDiskf[5],mybxerror);
1385 // BXGlobD3far->setBinLabel(indexDiskf[5],camera,1);
1386 
1387  MaskedGlobD3far->setBinContent(indexDiskf[5],maskedratio);
1388  MaskedGlobD3far->setBinLabel(indexDiskf[5],camera,1);
1389 
1390  AverageEffD3far->setBinContent(indexDiskf[5],averageeff);
1391  AverageEffD3far->setBinError(indexDiskf[5],averageerr);
1392  AverageEffD3far->setBinLabel(indexDiskf[5],camera,1);
1393 
1394  NoPredictionD3far->setBinContent(indexDiskf[5],nopredictionsratio);
1395  NoPredictionD3far->setBinLabel(indexDiskf[5],camera,1);
1396  }
1397  }//Finishing EndCap*/
1398  }
1399  }
1400  }
1401  }
1402 
1403  float eff,N,err;
1404  int k;
1405  for(k=1;k<=36;k++){
1406  err=0; eff=0; N=ExGregD1R2->getBinContent(k);
1407  if(N!=0.){ eff = OcGregD1R2->getBinContent(k)/N; err=sqrt(eff*(1-eff)/N);}
1408  GregD1R2->setBinContent(k,eff); GregD1R2->setBinError(k,err);
1409 
1410  err=0; eff=0; N=ExGregD1R3->getBinContent(k);
1411  if(N!=0.){eff = OcGregD1R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1412  GregD1R3->setBinContent(k,eff); GregD1R3->setBinError(k,err);
1413 
1414  err=0; eff=0; N=ExGregD2R2->getBinContent(k);
1415  if(N!=0.){ eff = OcGregD2R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1416  GregD2R2->setBinContent(k,eff); GregD2R2->setBinError(k,err);
1417 
1418  err=0; eff=0; N=ExGregD2R3->getBinContent(k);
1419  if(N!=0.){ eff = OcGregD2R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1420  GregD2R3->setBinContent(k,eff); GregD2R3->setBinError(k,err);
1421 
1422  err=0; eff=0; N=ExGregD3R2->getBinContent(k);
1423  if(N!=0.){ eff = OcGregD3R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1424  GregD3R2->setBinContent(k,eff); GregD3R2->setBinError(k,err);
1425 
1426  err=0; eff=0; N=ExGregD3R3->getBinContent(k);
1427  if(N!=0.){ eff = OcGregD3R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1428  GregD3R3->setBinContent(k,eff); GregD3R3->setBinError(k,err);
1429 
1430  err=0; eff=0; N=ExGregDm1R2->getBinContent(k);
1431  if(N!=0.){ eff = OcGregDm1R2->getBinContent(k)/N; err=sqrt(eff*(1-eff)/N);}
1432  GregDm1R2->setBinContent(k,eff); GregDm1R2->setBinError(k,err);
1433 
1434  err=0; eff=0; N=ExGregDm1R3->getBinContent(k);
1435  if(N!=0.){eff = OcGregDm1R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1436  GregDm1R3->setBinContent(k,eff); GregDm1R3->setBinError(k,err);
1437 
1438  err=0; eff=0; N=ExGregDm2R2->getBinContent(k);
1439  if(N!=0.){ eff = OcGregDm2R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1440  GregDm2R2->setBinContent(k,eff); GregDm2R2->setBinError(k,err);
1441 
1442  err=0; eff=0; N=ExGregDm2R3->getBinContent(k);
1443  if(N!=0.){ eff = OcGregDm2R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1444  GregDm2R3->setBinContent(k,eff); GregDm2R3->setBinError(k,err);
1445 
1446  err=0; eff=0; N=ExGregDm3R2->getBinContent(k);
1447  if(N!=0.){ eff = OcGregDm3R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1448  GregDm3R2->setBinContent(k,eff); GregDm3R2->setBinError(k,err);
1449 
1450  err=0; eff=0; N=ExGregDm3R3->getBinContent(k);
1451  if(N!=0.){ eff = OcGregDm3R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1452  GregDm3R3->setBinContent(k,eff); GregDm3R3->setBinError(k,err);
1453  }
1454 
1455  for(k=1;k<=12;k++){
1456  err=0; eff=0; N=ExsectorEffWm2->getBinContent(k);
1457  if(N!=0.){ eff = OcsectorEffWm2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1458  sectorEffWm2->setBinContent(k,eff); sectorEffWm2->setBinError(k,err);
1459  //std::cout<<N<<" "<<OcsectorEffWm2->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
1460 
1461  err=0; eff=0; N=ExsectorEffWm1->getBinContent(k);
1462  if(N!=0.){ eff = OcsectorEffWm1->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1463  sectorEffWm1->setBinContent(k,eff); sectorEffWm1->setBinError(k,err);
1464  //std::cout<<N<<" "<<OcsectorEffWm1->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
1465 
1466  err=0; eff=0; N=ExsectorEffW0->getBinContent(k);
1467  if(N!=0.){ eff = OcsectorEffW0->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1468  sectorEffW0->setBinContent(k,eff); sectorEffW0->setBinError(k,err);
1469  //std::cout<<N<<" "<<OcsectorEffW0->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
1470 
1471  err=0; eff=0; N=ExsectorEffW1->getBinContent(k);
1472  if(N!=0.){ eff = OcsectorEffW1->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1473  sectorEffW1->setBinContent(k,eff); sectorEffW1->setBinError(k,err);
1474  //std::cout<<N<<" "<<OcsectorEffW1->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
1475 
1476  err=0; eff=0; N=ExsectorEffW2->getBinContent(k);
1477  if(N!=0.){ eff = OcsectorEffW2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
1478  sectorEffW2->setBinContent(k,eff); sectorEffW2->setBinError(k,err);
1479  //std::cout<<N<<" "<<OcsectorEffW2->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
1480  }
1481 
1482  //Ranges for Both
1483  //Barrel
1484 
1485  if(barrel){
1486  EffGlobWm2->setAxisRange(-4.,100.,2);
1487  EffGlobWm1->setAxisRange(-4.,100.,2);
1488  EffGlobW0->setAxisRange(-4.,100.,2);
1489  EffGlobW1->setAxisRange(-4.,100.,2);
1490  EffGlobW2->setAxisRange(-4.,100.,2);
1491 
1492 // EffGlobWm2far->setAxisRange(-4.,100.,2);
1493 // EffGlobWm1far->setAxisRange(-4.,100.,2);
1494 // EffGlobW0far->setAxisRange(-4.,100.,2);
1495 // EffGlobW1far->setAxisRange(-4.,100.,2);
1496 // EffGlobW2far->setAxisRange(-4.,100.,2);
1497 
1498 // AverageEffWm2->setAxisRange(-4.,100.,2);
1499 // AverageEffWm1->setAxisRange(-4.,100.,2);
1500 // AverageEffW0->setAxisRange(-4.,100.,2);
1501 // AverageEffW1->setAxisRange(-4.,100.,2);
1502 // AverageEffW2->setAxisRange(-4.,100.,2);
1503 
1504 // AverageEffWm2far->setAxisRange(-4.,100.,2);
1505 // AverageEffWm1far->setAxisRange(-4.,100.,2);
1506 // AverageEffW0far->setAxisRange(-4.,100.,2);
1507 // AverageEffW1far->setAxisRange(-4.,100.,2);
1508 // AverageEffW2far->setAxisRange(-4.,100.,2);
1509 
1510 // MaskedGlobWm2->setAxisRange(-4.,100.,2);
1511 // MaskedGlobWm1->setAxisRange(-4.,100.,2);
1512 // MaskedGlobW0->setAxisRange(-4.,100.,2);
1513 // MaskedGlobW1->setAxisRange(-4.,100.,2);
1514 // MaskedGlobW2->setAxisRange(-4.,100.,2);
1515 
1516 // MaskedGlobWm2far->setAxisRange(-4.,100.,2);
1517 // MaskedGlobWm1far->setAxisRange(-4.,100.,2);
1518 // MaskedGlobW0far->setAxisRange(-4.,100.,2);
1519 // MaskedGlobW1far->setAxisRange(-4.,100.,2);
1520 // MaskedGlobW2far->setAxisRange(-4.,100.,2);
1521 
1522 // NoPredictionWm2->setAxisRange(-4.,100.,2);
1523 // NoPredictionWm1->setAxisRange(-4.,100.,2);
1524 // NoPredictionW0->setAxisRange(-4.,100.,2);
1525 // NoPredictionW1->setAxisRange(-4.,100.,2);
1526 // NoPredictionW2->setAxisRange(-4.,100.,2);
1527 
1528 // NoPredictionWm2far->setAxisRange(-4.,100.,2);
1529 // NoPredictionWm1far->setAxisRange(-4.,100.,2);
1530 // NoPredictionW0far->setAxisRange(-4.,100.,2);
1531 // NoPredictionW1far->setAxisRange(-4.,100.,2);
1532 // NoPredictionW2far->setAxisRange(-4.,100.,2);
1533  }
1534  //EndCap
1535 
1536  if(endcap){
1537  EffGlobDm3->setAxisRange(-4.,100.,2);
1538  EffGlobDm2->setAxisRange(-4.,100.,2);
1539  EffGlobDm1->setAxisRange(-4.,100.,2);
1540  EffGlobD1->setAxisRange(-4.,100.,2);
1541  EffGlobD2->setAxisRange(-4.,100.,2);
1542  EffGlobD3->setAxisRange(-4.,100.,2);
1543 
1544 // EffGlobDm3far->setAxisRange(-4.,100.,2);
1545 // EffGlobDm2far->setAxisRange(-4.,100.,2);
1546 // EffGlobDm1far->setAxisRange(-4.,100.,2);
1547 // EffGlobD1far->setAxisRange(-4.,100.,2);
1548 // EffGlobD2far->setAxisRange(-4.,100.,2);
1549 // EffGlobD3far->setAxisRange(-4.,100.,2);
1550 
1551 // BXGlobDm3->setAxisRange(-4.,100.,2);
1552 // BXGlobDm2->setAxisRange(-4.,100.,2);
1553 // BXGlobDm1->setAxisRange(-4.,100.,2);
1554 // BXGlobD1->setAxisRange(-4.,100.,2);
1555 // BXGlobD2->setAxisRange(-4.,100.,2);
1556 // BXGlobD3->setAxisRange(-4.,100.,2);
1557 
1558 // BXGlobDm3far->setAxisRange(-4.,100.,2);
1559 // BXGlobDm2far->setAxisRange(-4.,100.,2);
1560 // BXGlobDm1far->setAxisRange(-4.,100.,2);
1561 // BXGlobD1far->setAxisRange(-4.,100.,2);
1562 // BXGlobD2far->setAxisRange(-4.,100.,2);
1563 // BXGlobD3far->setAxisRange(-4.,100.,2);
1564 
1565 // MaskedGlobDm3->setAxisRange(-4.,100.,2);
1566 // MaskedGlobDm2->setAxisRange(-4.,100.,2);
1567 // MaskedGlobDm1->setAxisRange(-4.,100.,2);
1568 // MaskedGlobD1->setAxisRange(-4.,100.,2);
1569 // MaskedGlobD2->setAxisRange(-4.,100.,2);
1570 // MaskedGlobD3->setAxisRange(-4.,100.,2);
1571 
1572 // MaskedGlobDm3far->setAxisRange(-4.,100.,2);
1573 // MaskedGlobDm2far->setAxisRange(-4.,100.,2);
1574 // MaskedGlobDm1far->setAxisRange(-4.,100.,2);
1575 // MaskedGlobD1far->setAxisRange(-4.,100.,2);
1576 // MaskedGlobD2far->setAxisRange(-4.,100.,2);
1577 // MaskedGlobD3far->setAxisRange(-4.,100.,2);
1578 
1579 // AverageEffDm3->setAxisRange(-4.,100.,2);
1580 // AverageEffDm2->setAxisRange(-4.,100.,2);
1581 // AverageEffDm1->setAxisRange(-4.,100.,2);
1582 // AverageEffD1->setAxisRange(-4.,100.,2);
1583 // AverageEffD2->setAxisRange(-4.,100.,2);
1584 // AverageEffD3->setAxisRange(-4.,100.,2);
1585 
1586 // AverageEffDm3far->setAxisRange(-4.,100.,2);
1587 // AverageEffDm2far->setAxisRange(-4.,100.,2);
1588 // AverageEffDm1far->setAxisRange(-4.,100.,2);
1589 // AverageEffD1far->setAxisRange(-4.,100.,2);
1590 // AverageEffD2far->setAxisRange(-4.,100.,2);
1591 // AverageEffD3far->setAxisRange(-4.,100.,2);
1592 
1593 // NoPredictionDm3->setAxisRange(-4.,100.,2);
1594 // NoPredictionDm2->setAxisRange(-4.,100.,2);
1595 // NoPredictionDm1->setAxisRange(-4.,100.,2);
1596 // NoPredictionD1->setAxisRange(-4.,100.,2);
1597 // NoPredictionD2->setAxisRange(-4.,100.,2);
1598 // NoPredictionD3->setAxisRange(-4.,100.,2);
1599 
1600 // NoPredictionDm3far->setAxisRange(-4.,100.,2);
1601 // NoPredictionDm2far->setAxisRange(-4.,100.,2);
1602 // NoPredictionDm1far->setAxisRange(-4.,100.,2);
1603 // NoPredictionD1far->setAxisRange(-4.,100.,2);
1604 // NoPredictionD2far->setAxisRange(-4.,100.,2);
1605 // NoPredictionD3far->setAxisRange(-4.,100.,2);
1606  }
1607 
1608  //Title for Both
1609 
1610  //Barrel
1611  if(barrel){
1612  EffGlobWm2->setAxisTitle("%",2);
1613  EffGlobWm1->setAxisTitle("%",2);
1614  EffGlobW0->setAxisTitle("%",2);
1615  EffGlobW1->setAxisTitle("%",2);
1616  EffGlobW2->setAxisTitle("%",2);
1617 
1618 // EffGlobWm2far->setAxisTitle("%",2);
1619 // EffGlobWm1far->setAxisTitle("%",2);
1620 // EffGlobW0far->setAxisTitle("%",2);
1621 // EffGlobW1far->setAxisTitle("%",2);
1622 // EffGlobW2far->setAxisTitle("%",2);
1623 
1624 // AverageEffWm2->setAxisTitle("%",2);
1625 // AverageEffWm1->setAxisTitle("%",2);
1626 // AverageEffW0->setAxisTitle("%",2);
1627 // AverageEffW1->setAxisTitle("%",2);
1628 // AverageEffW2->setAxisTitle("%",2);
1629 
1630 // AverageEffWm2far->setAxisTitle("%",2);
1631 // AverageEffWm1far->setAxisTitle("%",2);
1632 // AverageEffW0far->setAxisTitle("%",2);
1633 // AverageEffW1far->setAxisTitle("%",2);
1634 // AverageEffW2far->setAxisTitle("%",2);
1635 
1636 // MaskedGlobWm2->setAxisTitle("%",2);
1637 // MaskedGlobWm1->setAxisTitle("%",2);
1638 // MaskedGlobW0->setAxisTitle("%",2);
1639 // MaskedGlobW1->setAxisTitle("%",2);
1640 // MaskedGlobW2->setAxisTitle("%",2);
1641 
1642 // MaskedGlobWm2far->setAxisTitle("%",2);
1643 // MaskedGlobWm1far->setAxisTitle("%",2);
1644 // MaskedGlobW0far->setAxisTitle("%",2);
1645 // MaskedGlobW1far->setAxisTitle("%",2);
1646 // MaskedGlobW2far->setAxisTitle("%",2);
1647 
1648 // NoPredictionWm2->setAxisTitle("%",2);
1649 // NoPredictionWm1->setAxisTitle("%",2);
1650 // NoPredictionW0->setAxisTitle("%",2);
1651 // NoPredictionW1->setAxisTitle("%",2);
1652 // NoPredictionW2->setAxisTitle("%",2);
1653 
1654 // NoPredictionWm2far->setAxisTitle("%",2);
1655 // NoPredictionWm1far->setAxisTitle("%",2);
1656 // NoPredictionW0far->setAxisTitle("%",2);
1657 // NoPredictionW1far->setAxisTitle("%",2);
1658 // NoPredictionW2far->setAxisTitle("%",2);
1659  }
1660  //EndCap
1661 
1662  if(endcap){
1663  EffGlobDm3->setAxisTitle("%",2);
1664  EffGlobDm2->setAxisTitle("%",2);
1665  EffGlobDm1->setAxisTitle("%",2);
1666  EffGlobD1->setAxisTitle("%",2);
1667  EffGlobD2->setAxisTitle("%",2);
1668  EffGlobD3->setAxisTitle("%",2);
1669 
1670 // EffGlobDm3far->setAxisTitle("%",2);
1671 // EffGlobDm2far->setAxisTitle("%",2);
1672 // EffGlobDm1far->setAxisTitle("%",2);
1673 // EffGlobD1far->setAxisTitle("%",2);
1674 // EffGlobD2far->setAxisTitle("%",2);
1675 // EffGlobD3far->setAxisTitle("%",2);
1676 
1677 // BXGlobDm3->setAxisTitle("%",2);
1678 // BXGlobDm2->setAxisTitle("%",2);
1679 // BXGlobDm1->setAxisTitle("%",2);
1680 // BXGlobD1->setAxisTitle("%",2);
1681 // BXGlobD2->setAxisTitle("%",2);
1682 // BXGlobD3->setAxisTitle("%",2);
1683 
1684 // BXGlobDm3far->setAxisTitle("%",2);
1685 // BXGlobDm2far->setAxisTitle("%",2);
1686 // BXGlobDm1far->setAxisTitle("%",2);
1687 // BXGlobD1far->setAxisTitle("%",2);
1688 // BXGlobD2far->setAxisTitle("%",2);
1689 // BXGlobD3far->setAxisTitle("%",2);
1690 
1691 // MaskedGlobDm3->setAxisTitle("%",2);
1692 // MaskedGlobDm2->setAxisTitle("%",2);
1693 // MaskedGlobDm1->setAxisTitle("%",2);
1694 // MaskedGlobD1->setAxisTitle("%",2);
1695 // MaskedGlobD2->setAxisTitle("%",2);
1696 // MaskedGlobD3->setAxisTitle("%",2);
1697 
1698 // MaskedGlobDm3far->setAxisTitle("%",2);
1699 // MaskedGlobDm2far->setAxisTitle("%",2);
1700 // MaskedGlobDm1far->setAxisTitle("%",2);
1701 // MaskedGlobD1far->setAxisTitle("%",2);
1702 // MaskedGlobD2far->setAxisTitle("%",2);
1703 // MaskedGlobD3far->setAxisTitle("%",2);
1704 
1705 // AverageEffDm3->setAxisTitle("%",2);
1706 // AverageEffDm2->setAxisTitle("%",2);
1707 // AverageEffDm1->setAxisTitle("%",2);
1708 // AverageEffD1->setAxisTitle("%",2);
1709 // AverageEffD2->setAxisTitle("%",2);
1710 // AverageEffD3->setAxisTitle("%",2);
1711 
1712 // AverageEffDm3far->setAxisTitle("%",2);
1713 // AverageEffDm2far->setAxisTitle("%",2);
1714 // AverageEffDm1far->setAxisTitle("%",2);
1715 // AverageEffD1far->setAxisTitle("%",2);
1716 // AverageEffD2far->setAxisTitle("%",2);
1717 // AverageEffD3far->setAxisTitle("%",2);
1718 
1719 // NoPredictionDm3->setAxisTitle("%",2);
1720 // NoPredictionDm2->setAxisTitle("%",2);
1721 // NoPredictionDm1->setAxisTitle("%",2);
1722 // NoPredictionD1->setAxisTitle("%",2);
1723 // NoPredictionD2->setAxisTitle("%",2);
1724 // NoPredictionD3->setAxisTitle("%",2);
1725 
1726 // NoPredictionDm3far->setAxisTitle("%",2);
1727 // NoPredictionDm2far->setAxisTitle("%",2);
1728 // NoPredictionDm1far->setAxisTitle("%",2);
1729 // NoPredictionD1far->setAxisTitle("%",2);
1730 // NoPredictionD2far->setAxisTitle("%",2);
1731 // NoPredictionD3far->setAxisTitle("%",2);
1732  }
1733 
1734 
1735  if(SaveFile){
1736  std::cout<<"Saving RootFile"<<std::endl;
1737  dbe->save(NameFile);
1738  }
1739 
1740  if(debug) std::cout<<"RPCEFFICIENCY SECOND DONE"<<std::endl;
1741 
1742 }
1743 
1744 void RPCEfficiencySecond::endJob(){}
1745 
RPCEfficiencySecond::EffGlobD1
MonitorElement * EffGlobD1
Definition: RPCEfficiencySecond.h:242
RPCEfficiencySecond::ExpLayerW1
MonitorElement * ExpLayerW1
Definition: RPCEfficiencySecond.h:404
RPCEfficiencySecond::ExpLayerWm1
MonitorElement * ExpLayerWm1
Definition: RPCEfficiencySecond.h:402
RPCEfficiencySecond::OcGregDm2R3
MonitorElement * OcGregDm2R3
Definition: RPCEfficiencySecond.h:384
RPCEfficiencySecond::GregD3R2
MonitorElement * GregD3R2
Definition: RPCEfficiencySecond.h:366
RPCEfficiencySecond::GregDm1R3
MonitorElement * GregDm1R3
Definition: RPCEfficiencySecond.h:369
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
RPCEfficiencySecond::ExGregD1R3
MonitorElement * ExGregD1R3
Definition: RPCEfficiencySecond.h:389
RPCEfficiencySecond::ExGregDm3R3
MonitorElement * ExGregDm3R3
Definition: RPCEfficiencySecond.h:399
i
int i
Definition: DBlmapReader.cc:9
RPCEfficiencySecond::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: RPCEfficiencySecond.cc:404
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:800
RPCEfficiencySecond::ExGregDm2R3
MonitorElement * ExGregDm2R3
Definition: RPCEfficiencySecond.h:397
RPCEfficiencySecond::OcGregD3R2
MonitorElement * OcGregD3R2
Definition: RPCEfficiencySecond.h:379
RPCEfficiencySecond::OcGregD1R3
MonitorElement * OcGregD1R3
Definition: RPCEfficiencySecond.h:376
RPCEfficiencySecond::ExGregD3R2
MonitorElement * ExGregD3R2
Definition: RPCEfficiencySecond.h:392
RPCEfficiencySecond::RPCEfficiencySecond
RPCEfficiencySecond(const edm::ParameterSet &)
Definition: RPCEfficiencySecond.cc:37
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:514
RPCEfficiencySecond::histoCSC
MonitorElement * histoCSC
Definition: RPCEfficiencySecond.h:143
MonitorElement::setAxisRange
void setAxisRange(double xmin, double xmax, int axis=1)
set x-, y- or z-axis range (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:894
RPCEfficiencySecond::EffDistroD2
MonitorElement * EffDistroD2
Definition: RPCEfficiencySecond.h:318
RPCEfficiencySecond::GregD2R3
MonitorElement * GregD2R3
Definition: RPCEfficiencySecond.h:365
RPCEfficiencySecond::EffDistroD1
MonitorElement * EffDistroD1
Definition: RPCEfficiencySecond.h:317
RPCEfficiencySecond::Diskm2Summary
MonitorElement * Diskm2Summary
Definition: RPCEfficiencySecond.h:336
RPCEfficiencySecond::sectorEffWm2
MonitorElement * sectorEffWm2
Definition: RPCEfficiencySecond.h:344
RPCEfficiencySecond::OcGregDm3R3
MonitorElement * OcGregDm3R3
Definition: RPCEfficiencySecond.h:386
DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE")
Definition: DQMStore.cc:1898
RPCEfficiencySecond::ExGregDm1R2
MonitorElement * ExGregDm1R2
Definition: RPCEfficiencySecond.h:394
RPCEfficiencySecond::OcGregD2R2
MonitorElement * OcGregD2R2
Definition: RPCEfficiencySecond.h:377
RPCEfficiencySecond::histoDT
MonitorElement * histoDT
Definition: RPCEfficiencySecond.h:141
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:876
RPCEfficiencySecond::EffDistroWm2
MonitorElement * EffDistroWm2
Definition: RPCEfficiencySecond.h:224
rpcdqm::utils::labelXAxisSegment
void labelXAxisSegment(MonitorElement *myMe)
Definition: utils.h:221
RPCEfficiencySecond::Disk3Summary
MonitorElement * Disk3Summary
Definition: RPCEfficiencySecond.h:340
RPCEfficiencySecond::GregDm3R3
MonitorElement * GregDm3R3
Definition: RPCEfficiencySecond.h:373
RPCEfficiencySecond::ExsectorEffW2
MonitorElement * ExsectorEffW2
Definition: RPCEfficiencySecond.h:360
RPCEfficiencySecond::GregDm2R2
MonitorElement * GregDm2R2
Definition: RPCEfficiencySecond.h:370
RPCEfficiencySecond::EffGlobW1
MonitorElement * EffGlobW1
Definition: RPCEfficiencySecond.h:162
RPCEfficiencySecond::GregD3R3
MonitorElement * GregD3R3
Definition: RPCEfficiencySecond.h:367
RPCEfficiencySecond::EffGlobD2
MonitorElement * EffGlobD2
Definition: RPCEfficiencySecond.h:243
RPCEfficiencySecond::OcsectorEffWm2
MonitorElement * OcsectorEffWm2
Definition: RPCEfficiencySecond.h:350
RPCEfficiencySecond::ExsectorEffW1
MonitorElement * ExsectorEffW1
Definition: RPCEfficiencySecond.h:359
RPCEfficiencySecond::EffDistroDm1
MonitorElement * EffDistroDm1
Definition: RPCEfficiencySecond.h:316
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:147
RPCEfficiencySecond::EffGlobW0
MonitorElement * EffGlobW0
Definition: RPCEfficiencySecond.h:161
RPCEfficiencySecond::ObsLayerWm1
MonitorElement * ObsLayerWm1
Definition: RPCEfficiencySecond.h:408
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:45
RPCEfficiencySecond::ExpLayerWm2
MonitorElement * ExpLayerWm2
Definition: RPCEfficiencySecond.h:401
RPCEfficiencySecond::ExGregDm2R2
MonitorElement * ExGregDm2R2
Definition: RPCEfficiencySecond.h:396
RPCEfficiencySecond::EffDistroDm3
MonitorElement * EffDistroDm3
Definition: RPCEfficiencySecond.h:314
RPCEfficiencySecond::ExsectorEffWm2
MonitorElement * ExsectorEffWm2
Definition: RPCEfficiencySecond.h:356
RPCEfficiencySecond::EffDistroWm1
MonitorElement * EffDistroWm1
Definition: RPCEfficiencySecond.h:225
RPCEfficiencySecond::endRun
virtual void endRun(const edm::Run &, const edm::EventSetup &)
Definition: RPCEfficiencySecond.cc:406
RPCEfficiencySecond::Diskm3Summary
MonitorElement * Diskm3Summary
Definition: RPCEfficiencySecond.h:335
iEvent
int iEvent
Definition: GenABIO.cc:243
RPCGeomServ::name
virtual std::string name()
Definition: RPCGeomServ.cc:15
RPCEfficiencySecond::Wheelm1Summary
MonitorElement * Wheelm1Summary
Definition: RPCEfficiencySecond.h:330
RPCEfficiencySecond::ObsLayerW0
MonitorElement * ObsLayerW0
Definition: RPCEfficiencySecond.h:409
Ring
Definition: Ring.h:31
RPCEfficiencySecond::EffGlobW2
MonitorElement * EffGlobW2
Definition: RPCEfficiencySecond.h:163
RPCDetId::ring
int ring() const
Definition: RPCDetId.h:74
RPCEfficiencySecond::OcGregD3R3
MonitorElement * OcGregD3R3
Definition: RPCEfficiencySecond.h:380
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:28
RPCEfficiencySecond::EffDistroD3
MonitorElement * EffDistroD3
Definition: RPCEfficiencySecond.h:319
RPCEfficiencySecond::Wheel1Summary
MonitorElement * Wheel1Summary
Definition: RPCEfficiencySecond.h:332
RPCEfficiencySecond::sectorEffW2
MonitorElement * sectorEffW2
Definition: RPCEfficiencySecond.h:348
RPCEfficiencySecond::EffGlobDm2
MonitorElement * EffGlobDm2
Definition: RPCEfficiencySecond.h:240
RPCChamber::rolls
const std::vector< const RPCRoll * > & rolls() const
Return the Rolls.
Definition: RPCChamber.cc:70
j
int j
Definition: DBlmapReader.cc:9
MonitorElement::setBinError
void setBinError(int binx, double error)
set uncertainty on content of bin (1-D)
Definition: MonitorElement.cc:825
RPCEfficiencySecond::OcGregD1R2
MonitorElement * OcGregD1R2
Definition: RPCEfficiencySecond.h:375
DQMStore::get
MonitorElement * get(const std::string &path) const
get ME from full pathname (e.g. &quot;my/long/dir/my_histo&quot;)
Definition: DQMStore.cc:1265
RPCEfficiencySecond::OcsectorEffW0
MonitorElement * OcsectorEffW0
Definition: RPCEfficiencySecond.h:352
RPCEfficiencySecond::GregDm1R2
MonitorElement * GregDm1R2
Definition: RPCEfficiencySecond.h:368
RPCGeomServ::shortname
virtual std::string shortname()
Definition: RPCGeomServ.cc:222
RPCEfficiencySecond::Disk1Summary
MonitorElement * Disk1Summary
Definition: RPCEfficiencySecond.h:338
rpcdqm::utils::labelXAxisSector
void labelXAxisSector(MonitorElement *myMe)
Definition: utils.h:206
RPCEfficiencySecond::GregD1R3
MonitorElement * GregD1R3
Definition: RPCEfficiencySecond.h:363
RPCEfficiencySecond::meCollection
std::map< int, std::map< std::string, MonitorElement * > > meCollection
Definition: RPCEfficiencySecond.h:422
RPCEfficiencySecond::EffDistroW2
MonitorElement * EffDistroW2
Definition: RPCEfficiencySecond.h:228
RPCEfficiencySecond::sectorEffW1
MonitorElement * sectorEffW1
Definition: RPCEfficiencySecond.h:347
gen::k
int k[5][pyjets_maxn]
Definition: Pythia6Hadronizer.cc:86
RPCEfficiencySecond::ObsLayerWm2
MonitorElement * ObsLayerWm2
Definition: RPCEfficiencySecond.h:407
RPCEfficiencySecond::GregDm2R3
MonitorElement * GregDm2R3
Definition: RPCEfficiencySecond.h:371
RPCEfficiencySecond::OcGregDm1R3
MonitorElement * OcGregDm1R3
Definition: RPCEfficiencySecond.h:382
RPCDetId::layer
int layer() const
Definition: RPCDetId.h:110
RPCEfficiencySecond::ExsectorEffW0
MonitorElement * ExsectorEffW0
Definition: RPCEfficiencySecond.h:358
RPCEfficiencySecond::ObsLayerW1
MonitorElement * ObsLayerW1
Definition: RPCEfficiencySecond.h:410
RPCGeomServ::segment
virtual int segment()
Definition: RPCGeomServ.cc:467
rpcdqm::utils::detId2RollNr
int detId2RollNr(const RPCDetId &_id)
Definition: utils.h:18
RPCEfficiencySecond::EffGlobD3
MonitorElement * EffGlobD3
Definition: RPCEfficiencySecond.h:244
RPCEfficiencySecond::OcGregDm1R2
MonitorElement * OcGregDm1R2
Definition: RPCEfficiencySecond.h:381
RPCEfficiencySecond::EffDistroW1
MonitorElement * EffDistroW1
Definition: RPCEfficiencySecond.h:227
RPCEfficiencySecond::Diskm1Summary
MonitorElement * Diskm1Summary
Definition: RPCEfficiencySecond.h:337
RPCEfficiencySecond::GregD1R2
MonitorElement * GregD1R2
Definition: RPCEfficiencySecond.h:362
RPCEfficiencySecond::OcGregD2R3
MonitorElement * OcGregD2R3
Definition: RPCEfficiencySecond.h:378
RPCEfficiencySecond::GregDm3R2
MonitorElement * GregDm3R2
Definition: RPCEfficiencySecond.h:372
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1473
RPCEfficiencySecond::ExGregD2R2
MonitorElement * ExGregD2R2
Definition: RPCEfficiencySecond.h:390
RPCEfficiencySecond::Wheel2Summary
MonitorElement * Wheel2Summary
Definition: RPCEfficiencySecond.h:333
L1TEmulatorMonitor_cff.p
tuple p
Definition: L1TEmulatorMonitor_cff.py:48
RPCEfficiencySecond::Disk2Summary
MonitorElement * Disk2Summary
Definition: RPCEfficiencySecond.h:339
RPCEfficiencySecond::ExpLayerW0
MonitorElement * ExpLayerW0
Definition: RPCEfficiencySecond.h:403
RPCDetId::sector
int sector() const
Sector id: the group of chambers at same phi (and increasing r)
Definition: RPCDetId.h:104
RPCEfficiencySecond::EffGlobWm1
MonitorElement * EffGlobWm1
Definition: RPCEfficiencySecond.h:160
rpcdqm::utils::labelYAxisRoll
void labelYAxisRoll(MonitorElement *myMe, int region, int ring)
Definition: utils.h:239
RPCEfficiencySecond::GregD2R2
MonitorElement * GregD2R2
Definition: RPCEfficiencySecond.h:364
RPCEfficiencySecond::EffGlobWm2
MonitorElement * EffGlobWm2
Definition: RPCEfficiencySecond.h:159
RPCEfficiencySecond::beginRun
virtual void beginRun(const edm::Run &, const edm::EventSetup &iSetup)
Definition: RPCEfficiencySecond.cc:48
RPCEfficiencySecond::EffDistroDm2
MonitorElement * EffDistroDm2
Definition: RPCEfficiencySecond.h:315
MonitorElement::getBinContent
double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:699
RPCEfficiencySecond::ExGregDm1R3
MonitorElement * ExGregDm1R3
Definition: RPCEfficiencySecond.h:395
RPCEfficiencySecond::EffDistroW0
MonitorElement * EffDistroW0
Definition: RPCEfficiencySecond.h:226
RPCEfficiencySecond::Wheel0Summary
MonitorElement * Wheel0Summary
Definition: RPCEfficiencySecond.h:331
RPCEfficiencySecond::OcsectorEffW2
MonitorElement * OcsectorEffW2
Definition: RPCEfficiencySecond.h:354
RPCEfficiencySecond::EffGlobDm3
MonitorElement * EffGlobDm3
Definition: RPCEfficiencySecond.h:239
RPCEfficiencySecond::ExsectorEffWm1
MonitorElement * ExsectorEffWm1
Definition: RPCEfficiencySecond.h:357
RPCEfficiencySecond::ExpLayerW2
MonitorElement * ExpLayerW2
Definition: RPCEfficiencySecond.h:405
RPCEfficiencySecond::OcsectorEffW1
MonitorElement * OcsectorEffW1
Definition: RPCEfficiencySecond.h:353
RPCEfficiencySecond::Wheelm2Summary
MonitorElement * Wheelm2Summary
Definition: RPCEfficiencySecond.h:329
RPCEfficiencySecond::sectorEffW0
MonitorElement * sectorEffW0
Definition: RPCEfficiencySecond.h:346
RPCEfficiencySecond::ExGregD1R2
MonitorElement * ExGregD1R2
Definition: RPCEfficiencySecond.h:388
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:41
RPCEfficiencySecond::ExGregD3R3
MonitorElement * ExGregD3R3
Definition: RPCEfficiencySecond.h:393
RPCEfficiencySecond::OcsectorEffWm1
MonitorElement * OcsectorEffWm1
Definition: RPCEfficiencySecond.h:351
x
Definition: DDAxes.h:10
RPCEfficiencySecond::ExGregD2R3
MonitorElement * ExGregD2R3
Definition: RPCEfficiencySecond.h:391
RPCEfficiencySecond::OcGregDm2R2
MonitorElement * OcGregDm2R2
Definition: RPCEfficiencySecond.h:383
DQMStore::book2D
MonitorElement * book2D(const char *name, const char *title, int nchX, double lowX, double highX, int nchY, double lowY, double highY)
Book 2D histogram.
Definition: DQMStore.cc:642
RPCEfficiencySecond::EffGlobDm1
MonitorElement * EffGlobDm1
Definition: RPCEfficiencySecond.h:241
RPCEfficiencySecond::ObsLayerW2
MonitorElement * ObsLayerW2
Definition: RPCEfficiencySecond.h:411
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:903
RPCEfficiencySecond::histoRPC
MonitorElement * histoRPC
Definition: RPCEfficiencySecond.h:140
RPCEfficiencySecond::sectorEffWm1
MonitorElement * sectorEffWm1
Definition: RPCEfficiencySecond.h:345
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:232
rpcdqm::utils::labelYAxisRing
void labelYAxisRing(MonitorElement *myMe, int numberOfRings)
Definition: utils.h:266
edm::Run
Definition: Run.h:32
RPCEfficiencySecond::ExGregDm3R2
MonitorElement * ExGregDm3R2
Definition: RPCEfficiencySecond.h:398
RPCDetId::region
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:65
RPCEfficiencySecond::OcGregDm3R2
MonitorElement * OcGregDm3R2
Definition: RPCEfficiencySecond.h:385
RPCDetId::station
int station() const
Definition: RPCDetId.h:98
Generated for CMSSW Reference Manual by doxygen 1.8.5