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