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 #include <FWCore/MessageLogger/interface/MessageLogger.h>
25 
26 RPCEfficiencySecond::RPCEfficiencySecond(const edm::ParameterSet& iConfig){
27  SaveFile = iConfig.getUntrackedParameter<bool>("SaveFile", false);
28  NameFile = iConfig.getUntrackedParameter<std::string>("NameFile","RPCEfficiency.root");
29  folderPath = iConfig.getUntrackedParameter<std::string>("folderPath","RPC/RPCEfficiency/");
30  debug = iConfig.getUntrackedParameter<bool>("debug",false);
31  barrel = iConfig.getUntrackedParameter<bool>("barrel");
32  endcap = iConfig.getUntrackedParameter<bool>("endcap");
33 }
34 
35 RPCEfficiencySecond::~RPCEfficiencySecond(){}
36 
37 void RPCEfficiencySecond::beginRun(const edm::Run&, const edm::EventSetup& iSetup){
38 
39  dbe = edm::Service<DQMStore>().operator->();
40 
41  //Barrel
42 
43  dbe->setCurrentFolder(folderPath+"Wheel_-2");
44  EffDistroWm2=dbe->book1D("EffDistroWheel_-2","Efficiency Distribution for Wheel -2 ",20,0.5,100.5);
45  EffGlobWm2=dbe->book1D("GlobEfficiencyWheel_-2","Efficiency Wheel -2 ",206,0.5,206.5);
46 
47  dbe->setCurrentFolder(folderPath+"Wheel_-1");
48  EffDistroWm1=dbe->book1D("EffDistroWheel_-1","Efficiency Distribution for Wheel -1 ",20,0.5,100.5);
49  EffGlobWm1= dbe->book1D("GlobEfficiencyWheel_-1","Efficiency Wheel -1",206,0.5,206.5);
50 
51 
52  dbe->setCurrentFolder(folderPath+"Wheel_0");
53  EffDistroW0=dbe->book1D("EffDistroWheel_0","Efficiency Distribution for Wheel 0 ",20,0.5,100.5);
54  EffGlobW0 = dbe->book1D("GlobEfficiencyWheel_0","Efficiency Wheel 0",206,0.5,206.5);
55 
56 
57  dbe->setCurrentFolder(folderPath+"Wheel_1");
58  EffDistroW1=dbe->book1D("EffDistroWheel_1","Efficiency Distribution for Wheel 1 ",20,0.5,100.5);
59  EffGlobW1 = dbe->book1D("GlobEfficiencyWheel_1","Efficiency Wheel 1",206,0.5,206.5);
60 
61 
62  dbe->setCurrentFolder(folderPath+"Wheel_2");
63  EffDistroW2=dbe->book1D("EffDistroWheel_2","Efficiency Distribution for Wheel 2 ",20,0.5,100.5);
64  EffGlobW2 = dbe->book1D("GlobEfficiencyWheel_2","Efficiency Wheel 2",206,0.5,206.5);
65 
66 
67  //EndCap
68  dbe->setCurrentFolder(folderPath+"Disk_3");
69  EffDistroD3=dbe->book1D("EffDistroDisk_3","Efficiency Distribution Disk 3 ",20,0.5,100.5);
70  EffGlobD3 = dbe->book1D("GlobEfficiencyDisk_3","Efficiency Disk 3",218,0.5,218.5);
71 
72  dbe->setCurrentFolder(folderPath+"Disk_2");
73  EffDistroD2=dbe->book1D("EffDistroDisk_2","Efficiency Distribution Disk 2 ",20,0.5,100.5);
74  EffGlobD2 = dbe->book1D("GlobEfficiencyDisk_2","Efficiency Disk 2",218,0.5,218.5);
75 
76 
77  dbe->setCurrentFolder(folderPath+"Disk_1");
78  EffDistroD1=dbe->book1D("EffDistroDisk_1","Efficiency Distribution Disk 1 ",20,0.5,100.5);
79  EffGlobD1 = dbe->book1D("GlobEfficiencyDisk_1","Efficiency Disk 1",218,0.5,218.5);
80 
81 
82  dbe->setCurrentFolder(folderPath+"Disk_-1");
83  EffDistroDm1=dbe->book1D("EffDistroDisk_m1","Efficiency Distribution Disk - 1 ",20,0.5,100.5);
84  EffGlobDm1 = dbe->book1D("GlobEfficiencyDisk_m1","Efficiency Disk -1",218,0.5,218.5);
85 
86  dbe->setCurrentFolder(folderPath+"Disk_-2");
87  EffDistroDm2=dbe->book1D("EffDistroDisk_m2","Efficiency Distribution Disk - 2 ",20,0.5,100.5);
88  EffGlobDm2 = dbe->book1D("GlobEfficiencyDisk_m2","Efficiency Disk -2",218,0.5,218.5);
89 
90 
91  dbe->setCurrentFolder(folderPath+"Disk_-3");
92  EffDistroDm3=dbe->book1D("EffDistroDisk_m3","Efficiency Distribution Disk - 3 ",20,0.5,100.5);
93  EffGlobDm3 = dbe->book1D("GlobEfficiencyDisk_m3","Efficiency Disk -3",218,0.5,218.5);
94 
95 
96  //Summary Histograms
97  dbe->setCurrentFolder(folderPath);
98  std::string os;
99  os="Efficiency_Roll_vs_Sector_Wheel_-2";
100  Wheelm2Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
101  os="Efficiency_Roll_vs_Sector_Wheel_-1";
102  Wheelm1Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
103  os="Efficiency_Roll_vs_Sector_Wheel_0";
104  Wheel0Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
105  os="Efficiency_Roll_vs_Sector_Wheel_+1";
106  Wheel1Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
107  os="Efficiency_Roll_vs_Sector_Wheel_+2";
108  Wheel2Summary = dbe->book2D(os, os, 12, 0.5,12.5, 21, 0.5, 21.5);
109 
110  rpcdqm::utils rpcUtils;
111  rpcUtils.labelXAxisSector( Wheel2Summary );
112  rpcUtils.labelYAxisRoll( Wheel2Summary, 0, 2, true);
113 
114  rpcUtils.labelXAxisSector( Wheel1Summary );
115  rpcUtils.labelYAxisRoll( Wheel1Summary, 0, 1, true);
116 
117  rpcUtils.labelXAxisSector( Wheel0Summary );
118  rpcUtils.labelYAxisRoll( Wheel0Summary, 0, 0, true);
119 
120  rpcUtils.labelXAxisSector( Wheelm1Summary );
121  rpcUtils.labelYAxisRoll( Wheelm1Summary, 0, -1, true);
122 
123  rpcUtils.labelXAxisSector( Wheelm2Summary );
124  rpcUtils.labelYAxisRoll( Wheelm2Summary, 0, -2, true);
125 
126  os="Efficiency_Roll_vs_Segment_Disk_-3";
127  Diskm3Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
128  os="Efficiency_Roll_vs_Segment_Disk_-2";
129  Diskm2Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
130  os="Efficiency_Roll_vs_Segment_Disk_-1";
131  Diskm1Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
132  os="Efficiency_Roll_vs_Segment_Disk_1";
133  Disk1Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
134  os="Efficiency_Roll_vs_Segment_Disk_2";
135  Disk2Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
136  os="Efficiency_Roll_vs_Segment_Disk_3";
137  Disk3Summary = dbe->book2D(os,os,36,0.5,36.5,6,0.5,6.5);
138 
139  rpcUtils.labelXAxisSegment(Diskm3Summary);
140  rpcUtils.labelYAxisRing(Diskm3Summary, 2, true);
141 
142  rpcUtils.labelXAxisSegment(Diskm2Summary);
143  rpcUtils.labelYAxisRing(Diskm2Summary, 2, true);
144 
145  rpcUtils.labelXAxisSegment(Diskm1Summary);
146  rpcUtils.labelYAxisRing(Diskm1Summary, 2, true);
147 
148  rpcUtils.labelXAxisSegment(Disk1Summary);
149  rpcUtils.labelYAxisRing(Disk1Summary, 2, true);
150 
151  rpcUtils.labelXAxisSegment(Disk2Summary);
152  rpcUtils.labelYAxisRing(Disk2Summary, 2, true);
153 
154  rpcUtils.labelXAxisSegment(Disk3Summary);
155  rpcUtils.labelYAxisRing(Disk3Summary, 2, true);
156 
157  //Azimutal Histograms
158 
159  dbe->setCurrentFolder(folderPath+"Azimutal/");
160  sectorEffWm2= dbe->book1D("AzimutalDistroWm2","Efficiency per Sector Wheel -2",12,0.5,12.5);
161  sectorEffWm1= dbe->book1D("AzimutalDistroWm1","Efficiency per Sector Wheel -1",12,0.5,12.5);
162  sectorEffW0= dbe->book1D("AzimutalDistroW0","Efficiency per Sector Wheel 0",12,0.5,12.5);
163  sectorEffW1= dbe->book1D("AzimutalDistroW1","Efficiency per Sector Wheel 1",12,0.5,12.5);
164  sectorEffW2= dbe->book1D("AzimutalDistroW2","Efficiency per Sector Wheel 2",12,0.5,12.5);
165 
166  OcsectorEffWm2= dbe->book1D("AzimutalDistroWm2Oc","Occupancy per Sector Wheel -2",12,0.5,12.5);
167  OcsectorEffWm1= dbe->book1D("AzimutalDistroWm1Oc","Occupancy per Sector Wheel -1",12,0.5,12.5);
168  OcsectorEffW0= dbe->book1D("AzimutalDistroW0Oc","Ocuppancy per Sector Wheel 0",12,0.5,12.5);
169  OcsectorEffW1= dbe->book1D("AzimutalDistroW1Oc","Ocuppancy per Sector Wheel 1",12,0.5,12.5);
170  OcsectorEffW2= dbe->book1D("AzimutalDistroW2Oc","Ocupancy per Sector Wheel 2",12,0.5,12.5);
171 
172  ExsectorEffWm2= dbe->book1D("AzimutalDistroWm2Ex","Expected per Sector Wheel -2",12,0.5,12.5);
173  ExsectorEffWm1= dbe->book1D("AzimutalDistroWm1Ex","Expected per Sector Wheel -1",12,0.5,12.5);
174  ExsectorEffW0= dbe->book1D("AzimutalDistroW0Ex","Expected per Sector Wheel 0",12,0.5,12.5);
175  ExsectorEffW1= dbe->book1D("AzimutalDistroW1Ex","Expected per Sector Wheel 1",12,0.5,12.5);
176  ExsectorEffW2= dbe->book1D("AzimutalDistroW2Ex","Expected per Sector Wheel 2",12,0.5,12.5);
177 
178  GregD1R2= dbe->book1D("GregDistroD1R2","Efficiency for Station 1 Ring 2",36,0.5,36.5);
179  GregD1R3= dbe->book1D("GregDistroD1R3","Efficiency for Station 1 Ring 3",36,0.5,36.5);
180  GregD2R2= dbe->book1D("GregDistroD2R2","Efficiency for Station 2 Ring 2",36,0.5,36.5);
181  GregD2R3= dbe->book1D("GregDistroD2R3","Efficiency for Station 2 Ring 3",36,0.5,36.5);
182  GregD3R2= dbe->book1D("GregDistroD3R2","Efficiency for Station 3 Ring 2",36,0.5,36.5);
183  GregD3R3= dbe->book1D("GregDistroD3R3","Efficiency for Station 3 Ring 3",36,0.5,36.5);
184  GregDm1R2= dbe->book1D("GregDistroDm1R2","Efficiency for Station -1 Ring 2",36,0.5,36.5);
185  GregDm1R3= dbe->book1D("GregDistroDm1R3","Efficiency for Station -1 Ring 3",36,0.5,36.5);
186  GregDm2R2= dbe->book1D("GregDistroDm2R2","Efficiency for Station -2 Ring 2",36,0.5,36.5);
187  GregDm2R3= dbe->book1D("GregDistroDm2R3","Efficiency for Station -2 Ring 3",36,0.5,36.5);
188  GregDm3R2= dbe->book1D("GregDistroDm3R2","Efficiency for Station -3 Ring 2",36,0.5,36.5);
189  GregDm3R3= dbe->book1D("GregDistroDm3R3","Efficiency for Station -3 Ring 3",36,0.5,36.5);
190 
191  OcGregD1R2= dbe->book1D("OcGregDistroD1R2","Occupancy Distribution for Station 1 Ring 2",36,0.5,36.5);
192  OcGregD1R3= dbe->book1D("OcGregDistroD1R3","Occupancy Distribution for Station 1 Ring 3",36,0.5,36.5);
193  OcGregD2R2= dbe->book1D("OcGregDistroD2R2","Occupancy Distribution for Station 2 Ring 2",36,0.5,36.5);
194  OcGregD2R3= dbe->book1D("OcGregDistroD2R3","Occupancy Distribution for Station 2 Ring 3",36,0.5,36.5);
195  OcGregD3R2= dbe->book1D("OcGregDistroD3R2","Occupancy Distribution for Station 3 Ring 2",36,0.5,36.5);
196  OcGregD3R3= dbe->book1D("OcGregDistroD3R3","Occupancy Distribution for Station 3 Ring 3",36,0.5,36.5);
197  OcGregDm1R2= dbe->book1D("OcGregDistroDm1R2","Occupancy Distribution for Station -1 Ring 2",36,0.5,36.5);
198  OcGregDm1R3= dbe->book1D("OcGregDistroDm1R3","Occupancy Distribution for Station -1 Ring 3",36,0.5,36.5);
199  OcGregDm2R2= dbe->book1D("OcGregDistroDm2R2","Occupancy Distribution for Station -2 Ring 2",36,0.5,36.5);
200  OcGregDm2R3= dbe->book1D("OcGregDistroDm2R3","Occupancy Distribution for Station -2 Ring 3",36,0.5,36.5);
201  OcGregDm3R2= dbe->book1D("OcGregDistroDm3R2","Occupancy Distribution for Station -3 Ring 2",36,0.5,36.5);
202  OcGregDm3R3= dbe->book1D("OcGregDistroDm3R3","Occupancy Distribution for Station -3 Ring 3",36,0.5,36.5);
203 
204  ExGregD1R2= dbe->book1D("ExGregDistroD1R2","Expected Distribution for Station 1 Ring 2",36,0.5,36.5);
205  ExGregD1R3= dbe->book1D("ExGregDistroD1R3","Expected Distribution for Station 1 Ring 3",36,0.5,36.5);
206  ExGregD2R2= dbe->book1D("ExGregDistroD2R2","Expected Distribution for Station 2 Ring 2",36,0.5,36.5);
207  ExGregD2R3= dbe->book1D("ExGregDistroD2R3","Expected Distribution for Station 2 Ring 3",36,0.5,36.5);
208  ExGregD3R2= dbe->book1D("ExGregDistroD3R2","Expected Distribution for Station 3 Ring 2",36,0.5,36.5);
209  ExGregD3R3= dbe->book1D("ExGregDistroD3R3","Expected Distribution for Station 3 Ring 3",36,0.5,36.5);
210  ExGregDm1R2= dbe->book1D("ExGregDistroDm1R2","Expected Distribution for Station -1 Ring 2",36,0.5,36.5);
211  ExGregDm1R3= dbe->book1D("ExGregDistroDm1R3","Expected Distribution for Station -1 Ring 3",36,0.5,36.5);
212  ExGregDm2R2= dbe->book1D("ExGregDistroDm2R2","Expected Distribution for Station -2 Ring 2",36,0.5,36.5);
213  ExGregDm2R3= dbe->book1D("ExGregDistroDm2R3","Expected Distribution for Station -2 Ring 3",36,0.5,36.5);
214  ExGregDm3R2= dbe->book1D("ExGregDistroDm3R2","Expected Distribution for Station -3 Ring 2",36,0.5,36.5);
215  ExGregDm3R3= dbe->book1D("ExGregDistroDm3R3","Expected Distribution for Station -3 Ring 3",36,0.5,36.5);
216 
217  dbe->setCurrentFolder(folderPath+"BarrelPerLayer/");
218  ExpLayerWm2= dbe->book1D("ExpLayerWm2","Expected Wheel - 2",6,0.5,6.5);
219  ExpLayerWm1= dbe->book1D("ExpLayerWm1","Expected Wheel - 1",6,0.5,6.5);
220  ExpLayerW0= dbe->book1D("ExpLayerW0","Expected Wheel 0",6,0.5,6.5);
221  ExpLayerW1= dbe->book1D("ExpLayerW1","Expected Wheel 1",6,0.5,6.5);
222  ExpLayerW2= dbe->book1D("ExpLayerW2","Expected Wheel 2",6,0.5,6.5);
223 
224  ObsLayerWm2= dbe->book1D("ObsLayerWm2","Observed Wheel - 2",6,0.5,6.5);
225  ObsLayerWm1= dbe->book1D("ObsLayerWm1","Observed Wheel - 1",6,0.5,6.5);
226  ObsLayerW0= dbe->book1D("ObsLayerW0","Observed Wheel 0",6,0.5,6.5);
227  ObsLayerW1= dbe->book1D("ObsLayerW1","Observed Wheel 1",6,0.5,6.5);
228  ObsLayerW2= dbe->book1D("ObsLayerW2","Observed Wheel 2",6,0.5,6.5);
229 }
230 
231 void RPCEfficiencySecond::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup){ }
232 
233 void RPCEfficiencySecond::endRun(const edm::Run& r, const edm::EventSetup& iSetup){
234 
235  LogDebug("rpcefficiencysecond")<<"Getting the RPC Geometry";
236 
237  edm::ESHandle<RPCGeometry> rpcGeo;
238  iSetup.get<MuonGeometryRecord>().get(rpcGeo);
239 
240 
241  //Setting Labels in Summary Label.
242  std::stringstream binLabel;
243 
244  LogDebug("rpcefficiencysecond")<<"Default -1 for Barrel GUI";
245 
246  for(int x = 1;x<=12;x++){
247  for(int y = 1;y<=21;y++){
248  Wheelm2Summary->setBinContent(x,y,-1);
249  Wheelm1Summary->setBinContent(x,y,-1);
250  Wheel0Summary->setBinContent(x,y,-1);
251  Wheel1Summary->setBinContent(x,y,-1);
252  Wheel2Summary->setBinContent(x,y,-1);
253  }
254  }
255 
256  LogDebug("rpcefficiencysecond")<<"Default -1 for EndCap GUI";
257 
258  for(int x = 1;x<=36;x++){
259  for(int y = 1;y<=6;y++){
260  Diskm3Summary->setBinContent(x,y,-1);
261  Diskm2Summary->setBinContent(x,y,-1);
262  Diskm1Summary->setBinContent(x,y,-1);
263  Disk1Summary->setBinContent(x,y,-1);
264  Disk2Summary->setBinContent(x,y,-1);
265  Disk3Summary->setBinContent(x,y,-1);
266  }
267  }
268 
269  binLabel.str("");
270 
271  int indexWheel[5];
272  for(int j=0;j<5;j++){
273  indexWheel[j]=0;
274  }
275 
276  // int indexWheelf[5];
277  // for(int j=0;j<5;j++){
278  // indexWheelf[j]=0;
279  // }
280 
281  int indexDisk[6];
282  for(int j=0;j<6;j++){
283  indexDisk[j]=0;
284  }
285 
286  // int indexDiskf[6];
287  // for(int j=0;j<6;j++){
288  // indexDiskf[j]=0;
289  // }
290 
291 
292  for(TrackingGeometry::DetContainer::const_iterator it=rpcGeo->dets().begin();it<rpcGeo->dets().end();it++){
293  if(dynamic_cast< RPCChamber* >( *it ) != 0 ){
294  RPCChamber* ch = dynamic_cast< RPCChamber* >( *it );
295  std::vector< const RPCRoll*> roles = (ch->rolls());
296  for(std::vector<const RPCRoll*>::const_iterator r = roles.begin();r != roles.end(); ++r){
297  RPCDetId rpcId = (*r)->id();
298  RPCGeomServ rpcsrv(rpcId);
299 // int sector = rpcId.sector();
300  std::string nameRoll = rpcsrv.name();
301 
302 
303 // if(debug){
304  // if(meCollection.find(rpcId.rawId())==meCollection.end()){
305  // std::cout<<"WARNING!!! Empty RecHit collection map"<<std::endl;
306  // }
307  // std::cout<<rpcId<<std::endl;
308  // //printing indexes
309 // std::cout<<"indexWheel=";
310 // for(int j=0;j<5;j++){
311 // std::cout<<indexWheel[j]<<" ";
312 // }
313 // std::cout<<std::endl;
314 // std::cout<<"indexWheelf=";
315 // for(int j=0;j<5;j++){
316 // std::cout<<indexWheelf[j]<<" ";
317 // }
318 // std::cout<<std::endl;
319 // std::cout<<"indexDisk=";
320 // for(int j=0;j<6;j++){
321 // std::cout<<indexDisk[j]<<" ";
322 // }
323 // std::cout<<std::endl;
324 // std::cout<<"indexDiskf=";
325 // for(int j=0;j<6;j++){
326 // std::cout<<indexDiskf[j]<<" ";
327 // }
328 // std::cout<<std::endl;
329 // }
330 
331  if(rpcId.region()==0){
332  std::stringstream meIdRPC, meIdDT; //, bxDistroId;
333 
334 
335  meIdRPC<<folderPath<<"MuonSegEff/RPCDataOccupancyFromDT_"<<rpcId.rawId();
336  meIdDT<<folderPath<<"MuonSegEff/ExpectedOccupancyFromDT_"<<rpcId.rawId();
337 
338  histoRPC = dbe->get(meIdRPC.str());
339  histoDT = dbe->get(meIdDT.str());
340  // histoPRO = dbe->get(meIdPRO);
341 
342  int NumberWithOutPrediction=0;
343  double p = 0.;
344  double o = 0.;
345 // float mybxhisto = 0.;
346 // float mybxerror = 0.;
347  float ef = 0.;
348  float er = 0.;
349  float buffef = 0.;
350  float buffer = 0.;
351  float sumbuffef = 0.;
352  float sumbuffer = 0.;
353  float averageeff = 0.;
354  //float averageerr = 0.;
355  int NumberStripsPointed = 0;
356 
357 
358  if(histoRPC && histoDT){ // && BXDistribution){
359  LogDebug("rpcefficiencysecond")<<rpcsrv.name();
360 
361  for(int i=1;i<=int((*r)->nstrips());++i){
362 
363  if(histoDT->getBinContent(i)!=0){
364  LogDebug("rpcefficiencysecond")<<"Inside the If";
365  buffef = float(histoRPC->getBinContent(i))/float(histoDT->getBinContent(i));
366  // meMap[meIdPRO]->setBinContent(i,buffef);
367  buffer = sqrt(buffef*(1.-buffef)/float(histoDT->getBinContent(i)));
368  // meMap[meIdPRO]->setBinError(i,buffer);
369  sumbuffef=sumbuffef+buffef;
370  sumbuffer = sumbuffer + buffer*buffer;
371  NumberStripsPointed++;
372  }else{
373  NumberWithOutPrediction++;
374  }
375  LogDebug("rpcefficiencysecond")<<"Strip="<<i<<" RPC="<<histoRPC->getBinContent(i)<<" DT="<<histoDT->getBinContent(i)<<" buffef="<<buffef<<" buffer="<<buffer<<" sumbuffef="<<sumbuffef<<" sumbuffer="<<sumbuffer<<" NumberStripsPointed="<<NumberStripsPointed<<" NumberWithOutPrediction"<<NumberWithOutPrediction;
376  }
377 
378  p=histoDT->getTH1F()->Integral();
379  o=histoRPC->getTH1F()->Integral();
380 
381  if(NumberStripsPointed!=0){
382  averageeff = (sumbuffef/float(NumberStripsPointed))*100.;
383  //averageerr = sqrt(sumbuffer/float(NumberStripsPointed))*100.;
384  }
385 
386  }
387 
388  int Ring = rpcId.ring();
389 
390  if(p!=0){
391  ef = float(o)/float(p);
392  er = sqrt(ef*(1.-ef)/float(p));
393  }
394 
395  ef=ef*100;
396  er=er*100;
397 
398 
399  //Filling azimutal Wheel Histograms
400 
401  int wheel = rpcId.ring();
402  int sector = rpcId.sector();
403  int region = rpcId.region();
404 
405 
406  if(region ==0){
407 
408  int layer = 0;
409 
410  if(rpcId.station()==1&&rpcId.layer()==1) layer = 1;
411  else if(rpcId.station()==1&&rpcId.layer()==2) layer = 2;
412  else if(rpcId.station()==2&&rpcId.layer()==1) layer = 3;
413  else if(rpcId.station()==2&&rpcId.layer()==2) layer = 4;
414  else if(rpcId.station()==3) layer = 5;
415  else if(rpcId.station()==4) layer = 6;
416 
417  if(wheel==-2){ExsectorEffWm2->Fill(sector,p); OcsectorEffWm2->Fill(sector,o); ExpLayerWm2->Fill(layer, p); ObsLayerWm2->Fill(layer, o);}
418  else if(wheel==-1){ExsectorEffWm1->Fill(sector,p); OcsectorEffWm1->Fill(sector,o); ExpLayerWm1->Fill(layer, p); ObsLayerWm1->Fill(layer, o);}
419  else if(wheel==0){ExsectorEffW0->Fill(sector,p); OcsectorEffW0->Fill(sector,o); ExpLayerW0->Fill(layer, p); ObsLayerW0->Fill(layer, o);}
420  else if(wheel==1){ExsectorEffW1->Fill(sector,p); OcsectorEffW1->Fill(sector,o); ExpLayerW1->Fill(layer, p); ObsLayerW1->Fill(layer, o);}
421  else if(wheel==2){ExsectorEffW2->Fill(sector,p); OcsectorEffW2->Fill(sector,o); ExpLayerW2->Fill(layer, p); ObsLayerW2->Fill(layer, o);}
422  }
423 
424 
425  std::string camera = rpcsrv.name();
426 
427  //float nopredictionsratio = (float(NumberWithOutPrediction)/float((*r)->nstrips()))*100.;
428 
429  //Efficiency for Pigis Histos
430 
431  LogDebug("rpcefficiencysecond")<<"Pigi "<<camera<<" "<<rpcsrv.shortname()<<" "
432  <<(*r)->id();
433 
434  if(p > 100){//We need at least 100 predictions to fill the summary plot
435 
436  int xBin,yBin;
437  xBin= (*r)->id().sector();
438  rpcdqm::utils rollNumber;
439  yBin = rollNumber.detId2RollNr((*r)->id());
440 
441  if((*r)->id().ring()==2) Wheel2Summary->setBinContent(xBin,yBin,averageeff);
442  else if((*r)->id().ring()==1) Wheel1Summary->setBinContent(xBin,yBin,averageeff);
443  else if((*r)->id().ring()==0) Wheel0Summary->setBinContent(xBin,yBin,averageeff);
444  else if((*r)->id().ring()==-1) Wheelm1Summary->setBinContent(xBin,yBin,averageeff);
445  else if((*r)->id().ring()==-2) Wheelm2Summary->setBinContent(xBin,yBin,averageeff);
446 
447  }
448 
449  //Near Side
450 
451  //float maskedratio =0;
452 
453 // if((sector==1||sector==2||sector==3||sector==10||sector==11||sector==12)){
454  if(Ring==-2){
455  EffDistroWm2->Fill(averageeff);
456  indexWheel[0]++;
457  EffGlobWm2->setBinContent(indexWheel[0],ef);
458  EffGlobWm2->setBinError(indexWheel[0],er);
459  EffGlobWm2->setBinLabel(indexWheel[0],camera,1);
460 
461  }else if(Ring==-1){
462  EffDistroWm1->Fill(averageeff);
463  indexWheel[1]++;
464  EffGlobWm1->setBinContent(indexWheel[1],ef);
465  EffGlobWm1->setBinError(indexWheel[1],er);
466  EffGlobWm1->setBinLabel(indexWheel[1],camera,1);
467 
468  }else if(Ring==0){
469  EffDistroW0->Fill(averageeff);
470  indexWheel[2]++;
471  EffGlobW0->setBinContent(indexWheel[2],ef);
472  EffGlobW0->setBinError(indexWheel[2],er);
473  EffGlobW0->setBinLabel(indexWheel[2],camera,1);
474 
475  }else if(Ring==1){
476  EffDistroW1->Fill(averageeff);
477  indexWheel[3]++;
478  EffGlobW1->setBinContent(indexWheel[3],ef);
479  EffGlobW1->setBinError(indexWheel[3],er);
480  EffGlobW1->setBinLabel(indexWheel[3],camera,1);
481 
482  }else if(Ring==2){
483  EffDistroW2->Fill(averageeff);
484  indexWheel[4]++;
485  EffGlobW2->setBinContent(indexWheel[4],ef);
486  EffGlobW2->setBinError(indexWheel[4],er);
487  EffGlobW2->setBinLabel(indexWheel[4],camera,1);
488  }
489 
490  }else{//EndCap
491 
492  std::stringstream meIdRPC,meIdCSC; //, bxDistroId;
493  std::string meIdPRO;
494 
495 
496  meIdRPC<<folderPath<<"MuonSegEff/RPCDataOccupancyFromCSC_"<<rpcId.rawId();
497  meIdCSC<<folderPath<<"MuonSegEff/ExpectedOccupancyFromCSC_"<<rpcId.rawId();
498 
499  meIdPRO = "Profile_"+ rpcsrv.name();
500 
501  histoRPC= dbe->get(meIdRPC.str());
502  histoCSC= dbe->get(meIdCSC.str());
503  //BXDistribution = dbe->get(bxDistroId.str());
504 
505  int NumberWithOutPrediction=0;
506  double p = 0;
507  double o = 0;
508  // float mybxhisto = 0;
509  //float mybxerror = 0;
510  float ef =0;
511  float er =0;
512  float buffef = 0;
513  float buffer = 0;
514  float sumbuffef = 0;
515  float sumbuffer = 0;
516  float averageeff = 0;
517  //float averageerr = 0;
518  int NumberStripsPointed = 0;
519 
520 
521  if(histoRPC && histoCSC) {// && BXDistribution){
522  LogDebug("rpcefficiencysecond")<<rpcsrv.name();
523 
524  for(int i=1;i<=int((*r)->nstrips());++i){
525  if(histoCSC->getBinContent(i)!=0){
526  LogDebug("rpcefficiencysecond")<<"Inside the If";
527  buffef = float(histoRPC->getBinContent(i))/float(histoCSC->getBinContent(i));
528  // meMap[meIdPRO]->setBinContent(i,buffef);
529  buffer = sqrt(buffef*(1.-buffef)/float(histoCSC->getBinContent(i)));
530  // meMap[meIdPRO]->setBinError(i,buffer);
531  sumbuffef=sumbuffef+buffef;
532  sumbuffer = sumbuffer + buffer*buffer;
533  NumberStripsPointed++;
534  }else{
535  NumberWithOutPrediction++;
536  }
537 
538  LogDebug("rpcefficiencysecond")<<"Strip="<<i<<" RPC="<<histoRPC->getBinContent(i)<<" CSC="<<histoCSC->getBinContent(i)<<" buffef="<<buffef<<" buffer="<<buffer<<" sumbuffef="<<sumbuffef<<" sumbuffer="<<sumbuffer<<" NumberStripsPointed="<<NumberStripsPointed<<" NumberWithOutPrediction"<<NumberWithOutPrediction;
539  }
540  p=histoCSC->getTH1F()->Integral();
541  o=histoRPC->getTH1F()->Integral();
542 
543  if(NumberStripsPointed!=0){
544  averageeff = (sumbuffef/float(NumberStripsPointed))*100.;
545  //averageerr = sqrt(sumbuffer/float(NumberStripsPointed))*100.;
546  }
547 
548  // mybxhisto = 50.+BXDistribution->getMean()*10;
549 // mybxerror = BXDistribution->getRMS()*10;
550  }
551 
552  int Disk = rpcId.station()*rpcId.region();
553 
554  if(p!=0){
555  ef = float(o)/float(p);
556  er = sqrt(ef*(1.-ef)/float(p));
557  }
558 
559  ef=ef*100;
560  er=er*100;
561 
562  //Filling azimutal GregHistograms
563 
564  if(rpcId.region()==1){
565  if(rpcId.station()==1 && rpcId.ring()==2){ ExGregD1R2->Fill(rpcsrv.segment(),p);OcGregD1R2->Fill(rpcsrv.segment(),o);}
566  else if(rpcId.station()==1 && rpcId.ring()==3){ ExGregD1R3->Fill(rpcsrv.segment(),p);OcGregD1R3->Fill(rpcsrv.segment(),o);}
567  else if(rpcId.station()==2 && rpcId.ring()==2){ ExGregD2R2->Fill(rpcsrv.segment(),p);OcGregD2R2->Fill(rpcsrv.segment(),o);}
568  else if(rpcId.station()==2 && rpcId.ring()==3){ ExGregD2R3->Fill(rpcsrv.segment(),p);OcGregD2R3->Fill(rpcsrv.segment(),o);}
569  else if(rpcId.station()==3 && rpcId.ring()==2){ ExGregD3R2->Fill(rpcsrv.segment(),p);OcGregD3R2->Fill(rpcsrv.segment(),o);}
570  else if(rpcId.station()==3 && rpcId.ring()==3){ ExGregD3R3->Fill(rpcsrv.segment(),p);OcGregD3R3->Fill(rpcsrv.segment(),o);}
571  }else if(rpcId.region()==-1){
572  if(rpcId.station()==1 && rpcId.ring()==2){ ExGregDm1R2->Fill(rpcsrv.segment(),p);OcGregDm1R2->Fill(rpcsrv.segment(),o);}
573  else if(rpcId.station()==1 && rpcId.ring()==3){ ExGregDm1R3->Fill(rpcsrv.segment(),p);OcGregDm1R3->Fill(rpcsrv.segment(),o);}
574  else if(rpcId.station()==2 && rpcId.ring()==2){ ExGregDm2R2->Fill(rpcsrv.segment(),p);OcGregDm2R2->Fill(rpcsrv.segment(),o);}
575  else if(rpcId.station()==2 && rpcId.ring()==3){ ExGregDm2R3->Fill(rpcsrv.segment(),p);OcGregDm2R3->Fill(rpcsrv.segment(),o);}
576  else if(rpcId.station()==3 && rpcId.ring()==2){ ExGregDm3R2->Fill(rpcsrv.segment(),p);OcGregDm3R2->Fill(rpcsrv.segment(),o);}
577  else if(rpcId.station()==3 && rpcId.ring()==3){ ExGregDm3R3->Fill(rpcsrv.segment(),p);OcGregDm3R3->Fill(rpcsrv.segment(),o);}
578  }
579 
580  std::string camera = rpcsrv.name();
581 
582  //float nopredictionsratio = (float(NumberWithOutPrediction)/float((*r)->nstrips()))*100.;
583 
584 
585  //Efficiency for Pigis Histos
586 
587  LogDebug("rpcefficiencysecond")<<"Pigi "<<camera<<" "<<rpcsrv.shortname()<<" "
588  <<(*r)->id();
589 
590 
591 
592  if(p > 100){ //We need at least 100 predictions to fill the summary plot
593  RPCGeomServ RPCServ((*r)->id());
594  int xBin = RPCServ.segment();
595  int yBin= ((*r)->id().ring()-1)*3-(*r)->id().roll()+1;
596  if(Disk==-3) Diskm3Summary->setBinContent(xBin, yBin, averageeff);
597  else if(Disk==-2) Diskm2Summary->setBinContent(xBin, yBin, averageeff);
598  else if(Disk==-1) Diskm1Summary->setBinContent(xBin, yBin, averageeff);
599  else if(Disk==1) Disk1Summary->setBinContent(xBin, yBin, averageeff);
600  else if(Disk==2) Disk2Summary->setBinContent(xBin, yBin, averageeff);
601  else if(Disk==3) Disk3Summary->setBinContent(xBin, yBin, averageeff);
602  }
603 
604  //Near Side
605 
606  //float maskedratio =0;
607 
608 // if(sector==1||sector==2||sector==6){
609 
610  if(Disk==-3){
611  EffDistroDm3->Fill(averageeff);
612  indexDisk[0]++;
613  EffGlobDm3->setBinContent(indexDisk[0],ef);
614  EffGlobDm3->setBinError(indexDisk[0],er);
615  EffGlobDm3->setBinLabel(indexDisk[0],camera,1);
616 
617 
618  }else if(Disk==-2){
619  EffDistroDm2->Fill(averageeff);
620  indexDisk[1]++;
621  EffGlobDm2->setBinContent(indexDisk[1],ef);
622  EffGlobDm2->setBinError(indexDisk[1],er);
623  EffGlobDm2->setBinLabel(indexDisk[1],camera,1);
624 
625 
626  }else if(Disk==-1){
627  EffDistroDm1->Fill(averageeff);
628  indexDisk[2]++;
629  EffGlobDm1->setBinContent(indexDisk[2],ef);
630  EffGlobDm1->setBinError(indexDisk[2],er);
631  EffGlobDm1->setBinLabel(indexDisk[2],camera,1);
632 
633 
634  }else if(Disk==1){
635  EffDistroD1->Fill(averageeff);
636  indexDisk[3]++;
637  EffGlobD1->setBinContent(indexDisk[3],ef);
638  EffGlobD1->setBinError(indexDisk[3],er);
639  EffGlobD1->setBinLabel(indexDisk[3],camera,1);
640 
641 
642  }else if(Disk==2){
643  EffDistroD2->Fill(averageeff);
644  indexDisk[4]++;
645  EffGlobD2->setBinContent(indexDisk[4],ef);
646  EffGlobD2->setBinError(indexDisk[4],er);
647  EffGlobD2->setBinLabel(indexDisk[4],camera,1);
648 
649 
650  }else if(Disk==3){
651  EffDistroD3->Fill(averageeff);
652  indexDisk[5]++;
653  EffGlobD3->setBinContent(indexDisk[5],ef);
654  EffGlobD3->setBinError(indexDisk[5],er);
655  EffGlobD3->setBinLabel(indexDisk[5],camera,1);
656 
657 
658  }
659 
660  }
661  }
662  }
663  }
664 
665  float eff,N,err;
666  int k;
667  for(k=1;k<=36;k++){
668  err=0; eff=0; N=ExGregD1R2->getBinContent(k);
669  if(N!=0.){ eff = OcGregD1R2->getBinContent(k)/N; err=sqrt(eff*(1-eff)/N);}
670  GregD1R2->setBinContent(k,eff); GregD1R2->setBinError(k,err);
671 
672  err=0; eff=0; N=ExGregD1R3->getBinContent(k);
673  if(N!=0.){eff = OcGregD1R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
674  GregD1R3->setBinContent(k,eff); GregD1R3->setBinError(k,err);
675 
676  err=0; eff=0; N=ExGregD2R2->getBinContent(k);
677  if(N!=0.){ eff = OcGregD2R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
678  GregD2R2->setBinContent(k,eff); GregD2R2->setBinError(k,err);
679 
680  err=0; eff=0; N=ExGregD2R3->getBinContent(k);
681  if(N!=0.){ eff = OcGregD2R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
682  GregD2R3->setBinContent(k,eff); GregD2R3->setBinError(k,err);
683 
684  err=0; eff=0; N=ExGregD3R2->getBinContent(k);
685  if(N!=0.){ eff = OcGregD3R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
686  GregD3R2->setBinContent(k,eff); GregD3R2->setBinError(k,err);
687 
688  err=0; eff=0; N=ExGregD3R3->getBinContent(k);
689  if(N!=0.){ eff = OcGregD3R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
690  GregD3R3->setBinContent(k,eff); GregD3R3->setBinError(k,err);
691 
692  err=0; eff=0; N=ExGregDm1R2->getBinContent(k);
693  if(N!=0.){ eff = OcGregDm1R2->getBinContent(k)/N; err=sqrt(eff*(1-eff)/N);}
694  GregDm1R2->setBinContent(k,eff); GregDm1R2->setBinError(k,err);
695 
696  err=0; eff=0; N=ExGregDm1R3->getBinContent(k);
697  if(N!=0.){eff = OcGregDm1R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
698  GregDm1R3->setBinContent(k,eff); GregDm1R3->setBinError(k,err);
699 
700  err=0; eff=0; N=ExGregDm2R2->getBinContent(k);
701  if(N!=0.){ eff = OcGregDm2R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
702  GregDm2R2->setBinContent(k,eff); GregDm2R2->setBinError(k,err);
703 
704  err=0; eff=0; N=ExGregDm2R3->getBinContent(k);
705  if(N!=0.){ eff = OcGregDm2R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
706  GregDm2R3->setBinContent(k,eff); GregDm2R3->setBinError(k,err);
707 
708  err=0; eff=0; N=ExGregDm3R2->getBinContent(k);
709  if(N!=0.){ eff = OcGregDm3R2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
710  GregDm3R2->setBinContent(k,eff); GregDm3R2->setBinError(k,err);
711 
712  err=0; eff=0; N=ExGregDm3R3->getBinContent(k);
713  if(N!=0.){ eff = OcGregDm3R3->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
714  GregDm3R3->setBinContent(k,eff); GregDm3R3->setBinError(k,err);
715  }
716 
717  for(k=1;k<=12;k++){
718  err=0; eff=0; N=ExsectorEffWm2->getBinContent(k);
719  if(N!=0.){ eff = OcsectorEffWm2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
720  sectorEffWm2->setBinContent(k,eff); sectorEffWm2->setBinError(k,err);
721  //std::cout<<N<<" "<<OcsectorEffWm2->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
722 
723  err=0; eff=0; N=ExsectorEffWm1->getBinContent(k);
724  if(N!=0.){ eff = OcsectorEffWm1->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
725  sectorEffWm1->setBinContent(k,eff); sectorEffWm1->setBinError(k,err);
726  //std::cout<<N<<" "<<OcsectorEffWm1->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
727 
728  err=0; eff=0; N=ExsectorEffW0->getBinContent(k);
729  if(N!=0.){ eff = OcsectorEffW0->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
730  sectorEffW0->setBinContent(k,eff); sectorEffW0->setBinError(k,err);
731  //std::cout<<N<<" "<<OcsectorEffW0->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
732 
733  err=0; eff=0; N=ExsectorEffW1->getBinContent(k);
734  if(N!=0.){ eff = OcsectorEffW1->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
735  sectorEffW1->setBinContent(k,eff); sectorEffW1->setBinError(k,err);
736  //std::cout<<N<<" "<<OcsectorEffW1->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
737 
738  err=0; eff=0; N=ExsectorEffW2->getBinContent(k);
739  if(N!=0.){ eff = OcsectorEffW2->getBinContent(k)/N;err=sqrt(eff*(1-eff)/N);}
740  sectorEffW2->setBinContent(k,eff); sectorEffW2->setBinError(k,err);
741  //std::cout<<N<<" "<<OcsectorEffW2->getBinContent(k)<<" "<<eff<<" "<<err<<std::endl;
742  }
743 
744  //Ranges for Both
745  //Barrel
746 
747  if(barrel){
748  EffGlobWm2->setAxisRange(-4.,100.,2);
749  EffGlobWm1->setAxisRange(-4.,100.,2);
750  EffGlobW0->setAxisRange(-4.,100.,2);
751  EffGlobW1->setAxisRange(-4.,100.,2);
752  EffGlobW2->setAxisRange(-4.,100.,2);
753  }
754 
755  //EndCap
756 
757  if(endcap){
758  EffGlobDm3->setAxisRange(-4.,100.,2);
759  EffGlobDm2->setAxisRange(-4.,100.,2);
760  EffGlobDm1->setAxisRange(-4.,100.,2);
761  EffGlobD1->setAxisRange(-4.,100.,2);
762  EffGlobD2->setAxisRange(-4.,100.,2);
763  EffGlobD3->setAxisRange(-4.,100.,2);
764 
765 
766  }
767 
768  //Title for Both
769 
770  //Barrel
771  if(barrel){
772  EffGlobWm2->setAxisTitle("%",2);
773  EffGlobWm1->setAxisTitle("%",2);
774  EffGlobW0->setAxisTitle("%",2);
775  EffGlobW1->setAxisTitle("%",2);
776  EffGlobW2->setAxisTitle("%",2);
777 
778  }
779  //EndCap
780 
781  if(endcap){
782  EffGlobDm3->setAxisTitle("%",2);
783  EffGlobDm2->setAxisTitle("%",2);
784  EffGlobDm1->setAxisTitle("%",2);
785  EffGlobD1->setAxisTitle("%",2);
786  EffGlobD2->setAxisTitle("%",2);
787  EffGlobD3->setAxisTitle("%",2);
788 
789 
790  }
791 
792 
793  if(SaveFile){
794  std::cout<<"Saving RootFile"<<std::endl;
795  dbe->save(NameFile);
796  }
797 
798 }
799 
800 void RPCEfficiencySecond::endJob(){}
801 
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:501
RPCEfficiencySecond::EffGlobD1
MonitorElement * EffGlobD1
Definition: RPCEfficiencySecond.h:240
RPCEfficiencySecond::ExpLayerW1
MonitorElement * ExpLayerW1
Definition: RPCEfficiencySecond.h:402
RPCEfficiencySecond::ExpLayerWm1
MonitorElement * ExpLayerWm1
Definition: RPCEfficiencySecond.h:400
RPCEfficiencySecond::OcGregDm2R3
MonitorElement * OcGregDm2R3
Definition: RPCEfficiencySecond.h:382
RPCEfficiencySecond::GregD3R2
MonitorElement * GregD3R2
Definition: RPCEfficiencySecond.h:364
RPCEfficiencySecond::GregDm1R3
MonitorElement * GregDm1R3
Definition: RPCEfficiencySecond.h:367
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
RPCEfficiencySecond::ExGregD1R3
MonitorElement * ExGregD1R3
Definition: RPCEfficiencySecond.h:387
RPCEfficiencySecond::ExGregDm3R3
MonitorElement * ExGregDm3R3
Definition: RPCEfficiencySecond.h:397
i
int i
Definition: DBlmapReader.cc:9
RPCEfficiencySecond::analyze
virtual void analyze(const edm::Event &, const edm::EventSetup &)
Definition: RPCEfficiencySecond.cc:231
MonitorElement::setBinContent
void setBinContent(int binx, double content)
set content of bin (1-D)
Definition: MonitorElement.cc:825
RPCEfficiencySecond::ExGregDm2R3
MonitorElement * ExGregDm2R3
Definition: RPCEfficiencySecond.h:395
RPCEfficiencySecond::OcGregD3R2
MonitorElement * OcGregD3R2
Definition: RPCEfficiencySecond.h:377
RPCEfficiencySecond::OcGregD1R3
MonitorElement * OcGregD1R3
Definition: RPCEfficiencySecond.h:374
RPCEfficiencySecond::ExGregD3R2
MonitorElement * ExGregD3R2
Definition: RPCEfficiencySecond.h:390
RPCEfficiencySecond::RPCEfficiencySecond
RPCEfficiencySecond(const edm::ParameterSet &)
Definition: RPCEfficiencySecond.cc:26
DQMStore::book1D
MonitorElement * book1D(const char *name, const char *title, int nchX, double lowX, double highX)
Book 1D histogram.
Definition: DQMStore.cc:872
RPCEfficiencySecond::histoCSC
MonitorElement * histoCSC
Definition: RPCEfficiencySecond.h:141
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:919
RPCEfficiencySecond::EffDistroD2
MonitorElement * EffDistroD2
Definition: RPCEfficiencySecond.h:316
RPCEfficiencySecond::GregD2R3
MonitorElement * GregD2R3
Definition: RPCEfficiencySecond.h:363
RPCEfficiencySecond::EffDistroD1
MonitorElement * EffDistroD1
Definition: RPCEfficiencySecond.h:315
RPCEfficiencySecond::Diskm2Summary
MonitorElement * Diskm2Summary
Definition: RPCEfficiencySecond.h:334
cuy.yBin
tuple yBin
Definition: cuy.py:891
RPCEfficiencySecond::sectorEffWm2
MonitorElement * sectorEffWm2
Definition: RPCEfficiencySecond.h:342
RPCEfficiencySecond::OcGregDm3R3
MonitorElement * OcGregDm3R3
Definition: RPCEfficiencySecond.h:384
RPCEfficiencySecond::ExGregDm1R2
MonitorElement * ExGregDm1R2
Definition: RPCEfficiencySecond.h:392
RPCEfficiencySecond::OcGregD2R2
MonitorElement * OcGregD2R2
Definition: RPCEfficiencySecond.h:375
RPCEfficiencySecond::histoDT
MonitorElement * histoDT
Definition: RPCEfficiencySecond.h:139
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:901
RPCEfficiencySecond::EffDistroWm2
MonitorElement * EffDistroWm2
Definition: RPCEfficiencySecond.h:222
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:338
RPCEfficiencySecond::GregDm3R3
MonitorElement * GregDm3R3
Definition: RPCEfficiencySecond.h:371
RPCEfficiencySecond::ExsectorEffW2
MonitorElement * ExsectorEffW2
Definition: RPCEfficiencySecond.h:358
RPCEfficiencySecond::GregDm2R2
MonitorElement * GregDm2R2
Definition: RPCEfficiencySecond.h:368
RPCEfficiencySecond::EffGlobW1
MonitorElement * EffGlobW1
Definition: RPCEfficiencySecond.h:160
RPCEfficiencySecond::GregD3R3
MonitorElement * GregD3R3
Definition: RPCEfficiencySecond.h:365
RPCEfficiencySecond::EffGlobD2
MonitorElement * EffGlobD2
Definition: RPCEfficiencySecond.h:241
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
RPCEfficiencySecond::OcsectorEffWm2
MonitorElement * OcsectorEffWm2
Definition: RPCEfficiencySecond.h:348
RPCEfficiencySecond::ExsectorEffW1
MonitorElement * ExsectorEffW1
Definition: RPCEfficiencySecond.h:357
RPCEfficiencySecond::EffDistroDm1
MonitorElement * EffDistroDm1
Definition: RPCEfficiencySecond.h:314
MonitorElement::Fill
void Fill(long long x)
Definition: MonitorElement.h:161
RPCEfficiencySecond::EffGlobW0
MonitorElement * EffGlobW0
Definition: RPCEfficiencySecond.h:159
RPCEfficiencySecond::ObsLayerWm1
MonitorElement * ObsLayerWm1
Definition: RPCEfficiencySecond.h:406
DetId::rawId
uint32_t rawId() const
get the raw id
Definition: DetId.h:43
RPCEfficiencySecond::ExpLayerWm2
MonitorElement * ExpLayerWm2
Definition: RPCEfficiencySecond.h:399
RPCEfficiencySecond::ExGregDm2R2
MonitorElement * ExGregDm2R2
Definition: RPCEfficiencySecond.h:394
RPCEfficiencySecond::EffDistroDm3
MonitorElement * EffDistroDm3
Definition: RPCEfficiencySecond.h:312
RPCEfficiencySecond::ExsectorEffWm2
MonitorElement * ExsectorEffWm2
Definition: RPCEfficiencySecond.h:354
RPCEfficiencySecond::EffDistroWm1
MonitorElement * EffDistroWm1
Definition: RPCEfficiencySecond.h:223
RPCEfficiencySecond::endRun
virtual void endRun(const edm::Run &, const edm::EventSetup &)
Definition: RPCEfficiencySecond.cc:233
RPCEfficiencySecond::Diskm3Summary
MonitorElement * Diskm3Summary
Definition: RPCEfficiencySecond.h:333
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:328
RPCEfficiencySecond::ObsLayerW0
MonitorElement * ObsLayerW0
Definition: RPCEfficiencySecond.h:407
RPCEfficiencySecond::EffGlobW2
MonitorElement * EffGlobW2
Definition: RPCEfficiencySecond.h:161
RPCDetId::ring
int ring() const
Definition: RPCDetId.h:72
RPCEfficiencySecond::OcGregD3R3
MonitorElement * OcGregD3R3
Definition: RPCEfficiencySecond.h:378
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:48
RPCEfficiencySecond::EffDistroD3
MonitorElement * EffDistroD3
Definition: RPCEfficiencySecond.h:317
RPCEfficiencySecond::Wheel1Summary
MonitorElement * Wheel1Summary
Definition: RPCEfficiencySecond.h:330
RPCEfficiencySecond::sectorEffW2
MonitorElement * sectorEffW2
Definition: RPCEfficiencySecond.h:346
RPCEfficiencySecond::EffGlobDm2
MonitorElement * EffGlobDm2
Definition: RPCEfficiencySecond.h:238
RPCChamber::rolls
const std::vector< const RPCRoll * > & rolls() const
Return the Rolls.
Definition: RPCChamber.cc:68
j
int j
Definition: DBlmapReader.cc:9
DQMStore::save
void save(const std::string &filename, const std::string &path="", const std::string &pattern="", const std::string &rewrite="", const uint32_t run=0, SaveReferenceTag ref=SaveWithReference, int minStatus=dqm::qstatus::STATUS_OK, const std::string &fileupdate="RECREATE")
Definition: DQMStore.cc:2296
MonitorElement::setBinError
void setBinError(int binx, double error)
set uncertainty on content of bin (1-D)
Definition: MonitorElement.cc:850
RPCEfficiencySecond::OcGregD1R2
MonitorElement * OcGregD1R2
Definition: RPCEfficiencySecond.h:373
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:1623
RPCEfficiencySecond::OcsectorEffW0
MonitorElement * OcsectorEffW0
Definition: RPCEfficiencySecond.h:350
RPCEfficiencySecond::GregDm1R2
MonitorElement * GregDm1R2
Definition: RPCEfficiencySecond.h:366
RPCGeomServ::shortname
virtual std::string shortname()
Definition: RPCGeomServ.cc:206
RPCEfficiencySecond::Disk1Summary
MonitorElement * Disk1Summary
Definition: RPCEfficiencySecond.h:336
rpcdqm::utils::labelXAxisSector
void labelXAxisSector(MonitorElement *myMe)
Definition: utils.h:236
RPCEfficiencySecond::GregD1R3
MonitorElement * GregD1R3
Definition: RPCEfficiencySecond.h:361
RPCEfficiencySecond::EffDistroW2
MonitorElement * EffDistroW2
Definition: RPCEfficiencySecond.h:226
RPCEfficiencySecond::sectorEffW1
MonitorElement * sectorEffW1
Definition: RPCEfficiencySecond.h:345
gen::k
int k[5][pyjets_maxn]
Definition: Cascade2Hadronizer.cc:81
RPCEfficiencySecond::ObsLayerWm2
MonitorElement * ObsLayerWm2
Definition: RPCEfficiencySecond.h:405
RPCEfficiencySecond::GregDm2R3
MonitorElement * GregDm2R3
Definition: RPCEfficiencySecond.h:369
RPCEfficiencySecond::OcGregDm1R3
MonitorElement * OcGregDm1R3
Definition: RPCEfficiencySecond.h:380
RPCDetId::layer
int layer() const
Definition: RPCDetId.h:108
RPCEfficiencySecond::ExsectorEffW0
MonitorElement * ExsectorEffW0
Definition: RPCEfficiencySecond.h:356
RPCEfficiencySecond::ObsLayerW1
MonitorElement * ObsLayerW1
Definition: RPCEfficiencySecond.h:408
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:242
RPCEfficiencySecond::OcGregDm1R2
MonitorElement * OcGregDm1R2
Definition: RPCEfficiencySecond.h:379
RPCEfficiencySecond::EffDistroW1
MonitorElement * EffDistroW1
Definition: RPCEfficiencySecond.h:225
N
#define N
Definition: blowfish.cc:9
RPCEfficiencySecond::Diskm1Summary
MonitorElement * Diskm1Summary
Definition: RPCEfficiencySecond.h:335
RPCEfficiencySecond::GregD1R2
MonitorElement * GregD1R2
Definition: RPCEfficiencySecond.h:360
RPCEfficiencySecond::OcGregD2R3
MonitorElement * OcGregD2R3
Definition: RPCEfficiencySecond.h:376
RPCEfficiencySecond::GregDm3R2
MonitorElement * GregDm3R2
Definition: RPCEfficiencySecond.h:370
edm::EventSetup::get
const T & get() const
Definition: EventSetup.h:55
MonitorElement::getTH1F
TH1F * getTH1F(void) const
Definition: MonitorElement.cc:1498
RPCEfficiencySecond::ExGregD2R2
MonitorElement * ExGregD2R2
Definition: RPCEfficiencySecond.h:388
RPCEfficiencySecond::Wheel2Summary
MonitorElement * Wheel2Summary
Definition: RPCEfficiencySecond.h:331
RPCEfficiencySecond::Disk2Summary
MonitorElement * Disk2Summary
Definition: RPCEfficiencySecond.h:337
RPCEfficiencySecond::ExpLayerW0
MonitorElement * ExpLayerW0
Definition: RPCEfficiencySecond.h:401
RPCDetId::sector
int sector() const
Sector id: the group of chambers at same phi (and increasing r)
Definition: RPCDetId.h:102
RPCEfficiencySecond::EffGlobWm1
MonitorElement * EffGlobWm1
Definition: RPCEfficiencySecond.h:158
RPCEfficiencySecond::GregD2R2
MonitorElement * GregD2R2
Definition: RPCEfficiencySecond.h:362
RPCEfficiencySecond::EffGlobWm2
MonitorElement * EffGlobWm2
Definition: RPCEfficiencySecond.h:157
RPCEfficiencySecond::beginRun
virtual void beginRun(const edm::Run &, const edm::EventSetup &iSetup)
Definition: RPCEfficiencySecond.cc:37
AlCaHLTBitMon_ParallelJobs.p
tuple p
Definition: AlCaHLTBitMon_ParallelJobs.py:152
RPCEfficiencySecond::EffDistroDm2
MonitorElement * EffDistroDm2
Definition: RPCEfficiencySecond.h:313
MonitorElement::getBinContent
double getBinContent(int binx) const
get content of bin (1-D)
Definition: MonitorElement.cc:724
RPCEfficiencySecond::ExGregDm1R3
MonitorElement * ExGregDm1R3
Definition: RPCEfficiencySecond.h:393
RPCEfficiencySecond::EffDistroW0
MonitorElement * EffDistroW0
Definition: RPCEfficiencySecond.h:224
RPCEfficiencySecond::Wheel0Summary
MonitorElement * Wheel0Summary
Definition: RPCEfficiencySecond.h:329
RPCEfficiencySecond::OcsectorEffW2
MonitorElement * OcsectorEffW2
Definition: RPCEfficiencySecond.h:352
RPCEfficiencySecond::EffGlobDm3
MonitorElement * EffGlobDm3
Definition: RPCEfficiencySecond.h:237
RPCEfficiencySecond::ExsectorEffWm1
MonitorElement * ExsectorEffWm1
Definition: RPCEfficiencySecond.h:355
RPCEfficiencySecond::ExpLayerW2
MonitorElement * ExpLayerW2
Definition: RPCEfficiencySecond.h:403
RPCEfficiencySecond::OcsectorEffW1
MonitorElement * OcsectorEffW1
Definition: RPCEfficiencySecond.h:351
RPCEfficiencySecond::Wheelm2Summary
MonitorElement * Wheelm2Summary
Definition: RPCEfficiencySecond.h:327
RPCEfficiencySecond::sectorEffW0
MonitorElement * sectorEffW0
Definition: RPCEfficiencySecond.h:344
RPCEfficiencySecond::ExGregD1R2
MonitorElement * ExGregD1R2
Definition: RPCEfficiencySecond.h:386
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:121
RPCEfficiencySecond::ExGregD3R3
MonitorElement * ExGregD3R3
Definition: RPCEfficiencySecond.h:391
RPCEfficiencySecond::OcsectorEffWm1
MonitorElement * OcsectorEffWm1
Definition: RPCEfficiencySecond.h:349
x
Definition: DDAxes.h:10
RPCEfficiencySecond::ExGregD2R3
MonitorElement * ExGregD2R3
Definition: RPCEfficiencySecond.h:389
RPCEfficiencySecond::OcGregDm2R2
MonitorElement * OcGregDm2R2
Definition: RPCEfficiencySecond.h:381
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:1000
RPCEfficiencySecond::EffGlobDm1
MonitorElement * EffGlobDm1
Definition: RPCEfficiencySecond.h:239
RPCEfficiencySecond::ObsLayerW2
MonitorElement * ObsLayerW2
Definition: RPCEfficiencySecond.h:409
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:928
RPCEfficiencySecond::histoRPC
MonitorElement * histoRPC
Definition: RPCEfficiencySecond.h:138
RPCEfficiencySecond::sectorEffWm1
MonitorElement * sectorEffWm1
Definition: RPCEfficiencySecond.h:343
DQMStore::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:584
edm::Run
Definition: Run.h:41
RPCEfficiencySecond::ExGregDm3R2
MonitorElement * ExGregDm3R2
Definition: RPCEfficiencySecond.h:396
RPCDetId::region
int region() const
Region id: 0 for Barrel, +/-1 For +/- Endcap.
Definition: RPCDetId.h:63
RPCEfficiencySecond::OcGregDm3R2
MonitorElement * OcGregDm3R2
Definition: RPCEfficiencySecond.h:383
RPCDetId::station
int station() const
Definition: RPCDetId.h:96
Generated for CMSSW Reference Manual by doxygen 1.8.5