CMS 3D CMS Logo
RemoteMonitoringGLOBALRBX.cc
Go to the documentation of this file.
1 // How to run:
2 //root -b -q -l RemoteMonitoringGLOBAL.C+
3 //root -b -q -l 'RemoteMonitoringGLOBAL.C+("/afs/cern.ch/cms/CAF/CMSALCA/ALCA_HCALCALIB/HCALMONITORING/CMTweb/histos/Global_190707.root")'
4 
5 #include "LogEleMapdb.h"
6 
7 #include <iostream>
8 #include <fstream>
9 
10 #include "TH1.h"
11 #include "TH2.h"
12 #include "TCanvas.h"
13 #include "TROOT.h"
14 #include <TMath.h>
15 #include "TStyle.h"
16 #include "TSystem.h"
17 #include "TLegend.h"
18 #include "TText.h"
19 #include "TAxis.h"
20 #include "TFile.h"
21 #include "TLine.h"
22 #include "TGraph.h"
23 #include <THStack.h>
24 #include <TPaveText.h>
25 
26 using namespace std;
27 //inline void HERE(const char *msg) { std::cout << msg << std::endl; } kfitq
28 int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin);
29 
30 // -----------------------------------------------------
31 
32 int main(int argc, char *argv[]) {
33  gROOT->Reset();
34  gROOT->SetStyle("Plain");
35  gStyle->SetOptStat(0);
36  gStyle->SetOptTitle(1);
37 
38  if (argc < 1)
39  return 1;
40  char fname[300];
41  sprintf(fname, "%s", argv[1]);
42  std::cout << fname << std::endl;
43 
44  //======================================================================
45  // Connect the input files, parameters and get the 2-d histogram in memory
46  // TFile *hfile= new TFile("GlobalHist.root", "READ");
47  string promt = (string)fname;
48  string runnumber = "";
49  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
50  runnumber += fname[i];
51 
52  TFile *hfile = new TFile(fname, "READ");
53  // Cut [test][sub][depth]
54  // Empty HB HE HO HF
55  double Cut0[7][5][8] = {
56  {{0., 0., 0., 0., 0., 0., 0., 0.},
57  {0., 1.0, 1.0, 0., 0., 0., 0., 0.},
58  {0., 1., 1., 1., 0., 0., 0., 0.},
59  {0., 0., 0., 0., 1., 0., 0., 0.},
60  {0., 1., 1., 0., 0., 0., 0., 0.}}, //CapID 0,HB,HE,HO,HF
61  // {{0.,0.,0.,0.,0.,0.,0.,0.}, {0.,35.,35.,0.,0.,0.,0.,0.}, {0.,100.,140.,150.,0.,0.,0.,0.}, {0.,0.,0.,0.,100.,0.,0.,0.}, {0.,170.,110.,170.,110.,0.,0.,0.} }, //Amplitude 0,HB,HE,HO,HF
62  {{0., 0., 0., 0., 0., 0., 0., 0.},
63  {0., 35., 35., 0., 0., 0., 0., 0.},
64  {0., 12000., 4500., 3500., 3500., 4000., 4500., 5500.},
65  {0., 0., 0., 0., 200., 0., 0., 0.},
66  {0., 4500., 4500., 4500., 4500., 0., 0., 0.}}, //Amplitude 0,HB,HE,HO,HF
67  {{0., 0., 0., 0., 0., 0., 0., 0.},
68  {0., 3., 3., 0., 0., 0., 0., 0.},
69  {0., 3., 3., 3., 0., 0., 0., 0.},
70  {0., 0., 0., 0., 3., 0., 0., 0.},
71  {0., 2., 2., 0., 0., 0., 0., 0.}}, //Width 0,HB,HE,HO,HF
72  {{0., 0., 0., 0., 0., 0., 0., 0.},
73  {0., 0.4, 0.4, 0., 0., 0., 0., 0.},
74  {0., 0.4, 0.4, 0.4, 0., 0., 0., 0.},
75  {0., 0., 0., 0., 0.4, 0., 0., 0.},
76  {0., 0.8, 0.8, 0., 0., 0., 0., 0.}}, //Ratio 0,HB,HE,HO,HF
77  {{0., 0., 0., 0., 0., 0., 0., 0.},
78  {0., 4.7, 4.7, 0., 0., 0., 0., 0.},
79  {0., 4.8, 4.8, 5.0, 0., 0., 0., 0.},
80  {0., 0., 0., 0., 4.8, 0., 0., 0.},
81  {0., 4.0, 4.0, 0., 0., 0., 0., 0.}}, //TSn 0,HB,HE,HO,HF
82  {{0., 0., 0., 0., 0., 0., 0., 0.},
83  {0., 3.5, 3.5, 0., 0., 0., 0., 0.},
84  {0., 4.0, 4.0, 4.0, 0., 0., 0., 0.},
85  {0., 0., 0., 0., 3., 0., 0., 0.},
86  {0., 3.5, 3.5, 0., 0., 0., 0., 0.}}, //TSx 0,HB,HE,HO,HF
87  {{0., 0., 0., 0., 0., 0., 0., 0.},
88  {0., 0., 0., 0., 0., 0., 0., 0.},
89  {0., 0., 0., 0., 0., 0., 0., 0.},
90  {0., 0., 0., 0., 0., 0., 0., 0.},
91  {0., 0., 0., 0., 0., 0., 0., 0.}}}; //Empty
92 
93  double CutAb[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
94  {0., 20., 7., 0., 0., 0., 0., 0.},
95  {0., 16., 13., 4., 0., 0., 0., 0.},
96  {0., 0., 0., 0., 45., 0., 0., 0.},
97  {0., 10., 5., 0., 0., 0., 0., 0.}}; // cut 1 for CapIdErrors 0,HB,HE,HO,HF
98 
99  double CutPo[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
100  {0., 9., 3., 0., 0., 0., 0., 0.},
101  {0., 8., 6., 2., 0., 0., 0., 0.},
102  {0., 0., 0., 0., 20., 0., 0., 0.},
103  {0., 5., 3., 0., 0., 0., 0., 0.}}; //cut 3 for CapIdErrors (portions) 0,HB,HE,HO,HF
104 
105  //======================================================================
106 
107  // CUTs FOR IPHI RBX:
108  int cutA_HB = 100;
109  int cutA_HE = 6000;
110  int cutA_HO = 150;
111  int cutA_HF = 500;
112  // CUTs FOR IETA RBX:
113  int cutB_HB = 100;
114  int cutB_HE = 10000;
115  int cutB_HO = 150;
116  int cutB_HF = 500;
117 
118  //======================================================================
119  // Prepare histograms and plot them to .png files
120  TCanvas *c1 = new TCanvas("c1", "Hcal4test", 200, 10, 700, 900);
121 
122  TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 500);
123  TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 500);
124  TCanvas *cONE = new TCanvas("cONE", "cONE", 500, 500);
125  TCanvas *cFour = new TCanvas("cFour", "cFour", 1500, 1000);
126  TCanvas *cFour1 = new TCanvas("cFour1", "cFour1", 1200, 800);
127  TCanvas *cNine = new TCanvas("cNine", "cNine", 1500, 1500);
128 
129  // RBX:
130  // TCanvas *c4x6 = new TCanvas("c4x6","c4x6",1500,3000);
131  TCanvas *c4x6 = new TCanvas("c4x6", "c4x6", 1200, 2400);
132  //TCanvas *c5x6 = new TCanvas("c5x6","c5x6",2000,3000);
133  TCanvas *c5x6 = new TCanvas("c5x6", "c5x6", 1500, 2400);
134  // TCanvas *cRBX1 = new TCanvas("cRBX1","cRBX1",200,10,1300,1110);
135  TCanvas *cRBX1 = new TCanvas("cRBX1", "cRBX1", 1200, 1000);
136  //
137  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",1800,600);
138  TCanvas *cRBX31 = new TCanvas("cRBX31", "cRBX31", 1860, 600);
139  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",200,10,,1800,600);
140 
141  // char *str = (char*)alloca(10000);
142 
143  int k_min[5] = {0, 1, 1, 4, 1}; // minimum depth for each subdet HB HE HO HF
144 
145  int k_max[5] = {0, 2, 3, 4, 2}; // maximum depth for each subdet HB HE HO HF
146  // int k_maxHFupgrade[5]={0,2,3,4,4}; // maximum depth for each subdet HB HE HO HF
147  int k_maxHFupgrade[5] = {0, 2, 7, 4, 4}; // maximum depth for each subdet HB HE HO HF
148 
149  //+++++++++++++++++++++++++++++
150  // Lumi iLumi and number of events
151  //+++++++++++++++++++++++++++++
152  cHB->Divide(2, 1);
153  cHB->cd(1);
154  TH1F *LumLum = (TH1F *)hfile->Get("h_lsnumber_per_eachLS");
155  int MaxLumDanila = LumLum->GetBinContent(LumLum->GetMaximumBin()); // old variant of Danila
156  cout << " MaxLumDanila= " << MaxLumDanila << endl;
157  gPad->SetGridy();
158  gPad->SetGridx();
159  LumLum->SetMarkerStyle(10);
160  LumLum->SetMarkerSize(0.8);
161  LumLum->GetYaxis()->SetLabelSize(0.04);
162  LumLum->SetTitle("Cont. number per LS \b");
163  LumLum->SetXTitle("Cont.number \b");
164  LumLum->SetYTitle("Ls \b");
165  LumLum->SetMarkerColor(4);
166  LumLum->SetLineColor(0);
167  LumLum->SetMinimum(0.8);
168  LumLum->GetXaxis()->SetRangeUser(0, MaxLumDanila);
169  LumLum->Draw("Error");
170 
171  cHB->cd(2);
172  TH1F *LumiEv = (TH1F *)hfile->Get("h_nevents_per_eachRealLS");
173  int MaxLum0 = LumiEv->GetBinContent(LumiEv->GetMaximumBin());
174  int MaxLum = 0;
175  for (int i = 1; i <= LumiEv->GetXaxis()->GetNbins(); i++) {
176  if (LumiEv->GetBinContent(i)) {
177  MaxLum = i;
178  }
179  }
180  cout << " MaxLum0= " << MaxLum0 << " MaxLum= " << MaxLum << endl;
181 
182  gPad->SetGridy();
183  gPad->SetGridx();
184  gPad->SetLogy();
185  // gPad->SetLogx();
186  LumiEv->GetYaxis()->SetLabelSize(0.04);
187  LumiEv->SetTitle("Number of events per LS");
188  LumiEv->SetXTitle("LS");
189  LumiEv->SetYTitle("Number of events ");
190  LumiEv->SetMarkerStyle(10);
191  LumiEv->SetMarkerSize(0.8);
192  LumiEv->SetMarkerColor(4);
193  LumiEv->SetLineColor(0);
194  // LumiEv->SetMinimum(0.8);
195  LumiEv->GetXaxis()->SetRangeUser(0, MaxLum);
196  LumiEv->Draw("Error");
197 
198  cHB->Print("LumiEvent.png");
199  cHB->Clear();
200 
201  //=======================================================================================================
202  // Shape criteria: 1d histogram first definition
203  //=======================================================================================================
204  TH1F *H_NumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
205 
206  //+++++++++++++++++++++++++++++
207  // ADC Amplitude
208  //+++++++++++++++++++++++++++++
209 
210  H_NumBadChanDepth[1][1][1] = (TH1F *)hfile->Get("h_sumADCAmplLS1");
211  H_NumBadChanDepth[1][1][2] = (TH1F *)hfile->Get("h_sumADCAmplLS2");
212 
213  H_NumBadChanDepth[1][2][1] = (TH1F *)hfile->Get("h_sumADCAmplLS3");
214  H_NumBadChanDepth[1][2][2] = (TH1F *)hfile->Get("h_sumADCAmplLS4");
215  H_NumBadChanDepth[1][2][3] = (TH1F *)hfile->Get("h_sumADCAmplLS5");
216 
217  H_NumBadChanDepth[1][3][4] = (TH1F *)hfile->Get("h_sumADCAmplLS8");
218 
219  H_NumBadChanDepth[1][4][1] = (TH1F *)hfile->Get("h_sumADCAmplLS6");
220  H_NumBadChanDepth[1][4][2] = (TH1F *)hfile->Get("h_sumADCAmplLS7");
221 
222  //+++++++++++++++++++++++++++++
223  // Width
224  //+++++++++++++++++++++++++++++
225 
226  H_NumBadChanDepth[2][1][1] = (TH1F *)hfile->Get("h_sumAmplitudeLS1");
227  H_NumBadChanDepth[2][1][2] = (TH1F *)hfile->Get("h_sumAmplitudeLS2");
228 
229  H_NumBadChanDepth[2][2][1] = (TH1F *)hfile->Get("h_sumAmplitudeLS3");
230  H_NumBadChanDepth[2][2][2] = (TH1F *)hfile->Get("h_sumAmplitudeLS4");
231  H_NumBadChanDepth[2][2][3] = (TH1F *)hfile->Get("h_sumAmplitudeLS5");
232 
233  H_NumBadChanDepth[2][3][4] = (TH1F *)hfile->Get("h_sumAmplitudeLS8");
234 
235  H_NumBadChanDepth[2][4][1] = (TH1F *)hfile->Get("h_sumAmplitudeLS6");
236  H_NumBadChanDepth[2][4][2] = (TH1F *)hfile->Get("h_sumAmplitudeLS7");
237 
238  //+++++++++++++++++++++++++++++
239  // Ratio
240  //+++++++++++++++++++++++++++++
241 
242  H_NumBadChanDepth[3][1][1] = (TH1F *)hfile->Get("h_sumAmplLS1");
243  H_NumBadChanDepth[3][1][2] = (TH1F *)hfile->Get("h_sumAmplLS2");
244 
245  H_NumBadChanDepth[3][2][1] = (TH1F *)hfile->Get("h_sumAmplLS3");
246  H_NumBadChanDepth[3][2][2] = (TH1F *)hfile->Get("h_sumAmplLS4");
247  H_NumBadChanDepth[3][2][3] = (TH1F *)hfile->Get("h_sumAmplLS5");
248 
249  H_NumBadChanDepth[3][3][4] = (TH1F *)hfile->Get("h_sumAmplLS8");
250 
251  H_NumBadChanDepth[3][4][1] = (TH1F *)hfile->Get("h_sumAmplLS6");
252  H_NumBadChanDepth[3][4][2] = (TH1F *)hfile->Get("h_sumAmplLS7");
253 
254  //+++++++++++++++++++++++++++++
255  // Tmean
256  //+++++++++++++++++++++++++++++
257 
258  H_NumBadChanDepth[4][1][1] = (TH1F *)hfile->Get("h_sumTSmeanALS1");
259  H_NumBadChanDepth[4][1][2] = (TH1F *)hfile->Get("h_sumTSmeanALS2");
260 
261  H_NumBadChanDepth[4][2][1] = (TH1F *)hfile->Get("h_sumTSmeanALS3");
262  H_NumBadChanDepth[4][2][2] = (TH1F *)hfile->Get("h_sumTSmeanALS4");
263  H_NumBadChanDepth[4][2][3] = (TH1F *)hfile->Get("h_sumTSmeanALS5");
264 
265  H_NumBadChanDepth[4][3][4] = (TH1F *)hfile->Get("h_sumTSmeanALS8");
266 
267  H_NumBadChanDepth[4][4][1] = (TH1F *)hfile->Get("h_sumTSmeanALS6");
268  H_NumBadChanDepth[4][4][2] = (TH1F *)hfile->Get("h_sumTSmeanALS7");
269 
270  //+++++++++++++++++++++++++++++
271  // Tmax
272  //+++++++++++++++++++++++++++++
273 
274  H_NumBadChanDepth[5][1][1] = (TH1F *)hfile->Get("h_sumTSmaxALS1");
275  H_NumBadChanDepth[5][1][2] = (TH1F *)hfile->Get("h_sumTSmaxALS2");
276 
277  H_NumBadChanDepth[5][2][1] = (TH1F *)hfile->Get("h_sumTSmaxALS3");
278  H_NumBadChanDepth[5][2][2] = (TH1F *)hfile->Get("h_sumTSmaxALS4");
279  H_NumBadChanDepth[5][2][3] = (TH1F *)hfile->Get("h_sumTSmaxALS5");
280 
281  H_NumBadChanDepth[5][3][4] = (TH1F *)hfile->Get("h_sumTSmaxALS8");
282 
283  H_NumBadChanDepth[5][4][1] = (TH1F *)hfile->Get("h_sumTSmaxALS6");
284  H_NumBadChanDepth[5][4][2] = (TH1F *)hfile->Get("h_sumTSmaxALS7");
285 
286  gStyle->SetOptStat(110000);
287 
288  for (int test = 1; test <= 5; test++) { //Test: 0,
289  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
290  if (sub == 1)
291  cHB->Divide(2, 1);
292  if (sub == 2)
293  cHE->Divide(3, 1);
294  if (sub == 3)
295  cONE->Divide(1, 1);
296  if (sub == 4)
297  cHB->Divide(2, 1);
298  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
299  if (sub == 1)
300  cHB->cd(k);
301  if (sub == 2)
302  cHE->cd(k);
303  if (sub == 3)
304  cONE->cd(k - 3);
305  if (sub == 4)
306  cHB->cd(k);
307  gPad->SetGridy();
308  gPad->SetGridx();
309  gPad->SetLogy();
310  H_NumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
311  H_NumBadChanDepth[test][sub][k]->SetMarkerSize(0.8);
312  if (k == 1)
313  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
314  if (k == 2)
315  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
316  if (k == 3)
317  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
318  if (k == 4)
319  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
320  if (test == 1)
321  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Amplitude> \b");
322  if (test == 2)
323  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Width> \b");
324  if (test == 3)
325  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Ratio> \b");
326  if (test == 4)
327  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS mean> \b");
328  if (test == 5)
329  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS max> \b");
330  H_NumBadChanDepth[test][sub][k]->SetYTitle("Number of channel-LSs\b");
331  H_NumBadChanDepth[test][sub][k]->SetMarkerColor(4);
332  H_NumBadChanDepth[test][sub][k]->SetLineColor(0);
333  // H_NumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
334  H_NumBadChanDepth[test][sub][k]->SetMinimum(0.8);
335  H_NumBadChanDepth[test][sub][k]->Draw("Error");
336  }
337  if (test == 0) {
338  if (sub == 1) {
339  cHB->Print("H_NBCMNHB.png");
340  cHB->Clear();
341  }
342  if (sub == 2) {
343  cHE->Print("H_NBCMNHE.png");
344  cHE->Clear();
345  }
346  if (sub == 3) {
347  cONE->Print("H_NBCMNHO.png");
348  cONE->Clear();
349  }
350  if (sub == 4) {
351  cHB->Print("H_NBCMNHF.png");
352  cHB->Clear();
353  }
354  }
355 
356  if (test == 1) {
357  if (sub == 1) {
358  cHB->Print("H_ADCamplHB.png");
359  cHB->Clear();
360  }
361  if (sub == 2) {
362  cHE->Print("H_ADCamplHE.png");
363  cHE->Clear();
364  }
365  if (sub == 3) {
366  cONE->Print("H_ADCamplHO.png");
367  cONE->Clear();
368  }
369  if (sub == 4) {
370  cHB->Print("H_ADCamplHF.png");
371  cHB->Clear();
372  }
373  }
374  if (test == 2) {
375  if (sub == 1) {
376  cHB->Print("H_WidthHB.png");
377  cHB->Clear();
378  }
379  if (sub == 2) {
380  cHE->Print("H_WidthHE.png");
381  cHE->Clear();
382  }
383  if (sub == 3) {
384  cONE->Print("H_WidthHO.png");
385  cONE->Clear();
386  }
387  if (sub == 4) {
388  cHB->Print("H_WidthHF.png");
389  cHB->Clear();
390  }
391  }
392  if (test == 3) {
393  if (sub == 1) {
394  cHB->Print("H_RatioHB.png");
395  cHB->Clear();
396  }
397  if (sub == 2) {
398  cHE->Print("H_RatioHE.png");
399  cHE->Clear();
400  }
401  if (sub == 3) {
402  cONE->Print("H_RatioHO.png");
403  cONE->Clear();
404  }
405  if (sub == 4) {
406  cHB->Print("H_RatioHF.png");
407  cHB->Clear();
408  }
409  }
410  if (test == 4) {
411  if (sub == 1) {
412  cHB->Print("H_TmeanHB.png");
413  cHB->Clear();
414  }
415  if (sub == 2) {
416  cHE->Print("H_TmeanHE.png");
417  cHE->Clear();
418  }
419  if (sub == 3) {
420  cONE->Print("H_TmeanHO.png");
421  cONE->Clear();
422  }
423  if (sub == 4) {
424  cHB->Print("H_TmeanHF.png");
425  cHB->Clear();
426  }
427  }
428  if (test == 5) {
429  if (sub == 1) {
430  cHB->Print("H_TmaxHB.png");
431  cHB->Clear();
432  }
433  if (sub == 2) {
434  cHE->Print("H_TmaxHE.png");
435  cHE->Clear();
436  }
437  if (sub == 3) {
438  cONE->Print("H_TmaxHO.png");
439  cONE->Clear();
440  }
441  if (sub == 4) {
442  cHB->Print("H_TmaxHF.png");
443  cHB->Clear();
444  }
445  }
446  } // end sub
447  } //end test
448 
449  gStyle->SetOptStat(0);
450  //================================================================================================================================
451 
452  //=======================================================================================================
453  // 2-d histograms second definition
454  //=========================================================
455  TH2F *MapNumBadChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
456  TH2F *MapNumChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
457  TH2F *MapNumBadChanFull[7]; // 1d Mapogramm for test
458  TH2F *MapNumChanFull[7]; // 1d Mapogramm for test
459 
460  //+++++++++++++++++++++++++++++
461  // CapID
462  //+++++++++++++++++++++++++++++
463 
464  MapNumBadChanDepth[0][1][1] = (TH2F *)hfile->Get("h_mapDepth1Error_HB");
465  MapNumBadChanDepth[0][1][2] = (TH2F *)hfile->Get("h_mapDepth2Error_HB");
466 
467  MapNumBadChanDepth[0][2][1] = (TH2F *)hfile->Get("h_mapDepth1Error_HE");
468  MapNumBadChanDepth[0][2][2] = (TH2F *)hfile->Get("h_mapDepth2Error_HE");
469  MapNumBadChanDepth[0][2][3] = (TH2F *)hfile->Get("h_mapDepth3Error_HE");
470 
471  MapNumBadChanDepth[0][3][4] = (TH2F *)hfile->Get("h_mapDepth4Error_HO");
472 
473  MapNumBadChanDepth[0][4][1] = (TH2F *)hfile->Get("h_mapDepth1Error_HF");
474  MapNumBadChanDepth[0][4][2] = (TH2F *)hfile->Get("h_mapDepth2Error_HF");
475 
476  MapNumBadChanFull[0] = (TH2F *)MapNumBadChanDepth[0][1][1]->Clone();
477 
478  MapNumChanDepth[0][1][1] = (TH2F *)hfile->Get("h_mapDepth1_HB");
479  MapNumChanDepth[0][1][2] = (TH2F *)hfile->Get("h_mapDepth2_HB");
480 
481  MapNumChanDepth[0][2][1] = (TH2F *)hfile->Get("h_mapDepth1_HE");
482  MapNumChanDepth[0][2][2] = (TH2F *)hfile->Get("h_mapDepth2_HE");
483  MapNumChanDepth[0][2][3] = (TH2F *)hfile->Get("h_mapDepth3_HE");
484 
485  MapNumChanDepth[0][3][4] = (TH2F *)hfile->Get("h_mapDepth4_HO");
486 
487  MapNumChanDepth[0][4][1] = (TH2F *)hfile->Get("h_mapDepth1_HF");
488  MapNumChanDepth[0][4][2] = (TH2F *)hfile->Get("h_mapDepth2_HF");
489 
490  MapNumChanFull[0] = (TH2F *)MapNumChanDepth[0][1][1]->Clone();
491 
492  //+++++++++++++++++++++++++++++
493  // ADC Amplitude
494  //+++++++++++++++++++++++++++++
495 
496  MapNumBadChanDepth[1][1][1] = (TH2F *)hfile->Get("h_2DsumADCAmplLS1");
497  MapNumBadChanDepth[1][1][2] = (TH2F *)hfile->Get("h_2DsumADCAmplLS2");
498 
499  MapNumBadChanDepth[1][2][1] = (TH2F *)hfile->Get("h_2DsumADCAmplLS3");
500  MapNumBadChanDepth[1][2][2] = (TH2F *)hfile->Get("h_2DsumADCAmplLS4");
501  MapNumBadChanDepth[1][2][3] = (TH2F *)hfile->Get("h_2DsumADCAmplLS5");
502 
503  MapNumBadChanDepth[1][3][4] = (TH2F *)hfile->Get("h_2DsumADCAmplLS8");
504 
505  MapNumBadChanDepth[1][4][1] = (TH2F *)hfile->Get("h_2DsumADCAmplLS6");
506  MapNumBadChanDepth[1][4][2] = (TH2F *)hfile->Get("h_2DsumADCAmplLS7");
507 
508  MapNumBadChanFull[1] = (TH2F *)MapNumBadChanDepth[1][1][1]->Clone();
509 
510  MapNumChanDepth[1][1][1] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS1");
511  MapNumChanDepth[1][1][2] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS2");
512 
513  MapNumChanDepth[1][2][1] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS3");
514  MapNumChanDepth[1][2][2] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS4");
515  MapNumChanDepth[1][2][3] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS5");
516 
517  MapNumChanDepth[1][3][4] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS8");
518 
519  MapNumChanDepth[1][4][1] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS6");
520  MapNumChanDepth[1][4][2] = (TH2F *)hfile->Get("h_2D0sumADCAmplLS7");
521 
522  MapNumChanFull[1] = (TH2F *)MapNumChanDepth[1][1][1]->Clone();
523 
524  //+++++++++++++++++++++++++++++
525  // Width
526  //+++++++++++++++++++++++++++++
527 
528  MapNumBadChanDepth[2][1][1] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS1");
529  MapNumBadChanDepth[2][1][2] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS2");
530 
531  MapNumBadChanDepth[2][2][1] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS3");
532  MapNumBadChanDepth[2][2][2] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS4");
533  MapNumBadChanDepth[2][2][3] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS5");
534 
535  MapNumBadChanDepth[2][3][4] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS8");
536 
537  MapNumBadChanDepth[2][4][1] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS6");
538  MapNumBadChanDepth[2][4][2] = (TH2F *)hfile->Get("h_2DsumAmplitudeLS7");
539 
540  MapNumBadChanFull[2] = (TH2F *)MapNumBadChanDepth[2][1][1]->Clone();
541 
542  MapNumChanDepth[2][1][1] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS1");
543  MapNumChanDepth[2][1][2] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS2");
544 
545  MapNumChanDepth[2][2][1] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS3");
546  MapNumChanDepth[2][2][2] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS4");
547  MapNumChanDepth[2][2][3] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS5");
548 
549  MapNumChanDepth[2][3][4] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS8");
550 
551  MapNumChanDepth[2][4][1] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS6");
552  MapNumChanDepth[2][4][2] = (TH2F *)hfile->Get("h_2D0sumAmplitudeLS7");
553 
554  MapNumChanFull[2] = (TH2F *)MapNumChanDepth[2][1][1]->Clone();
555 
556  //+++++++++++++++++++++++++++++
557  // Ratio
558  //+++++++++++++++++++++++++++++
559 
560  MapNumBadChanDepth[3][1][1] = (TH2F *)hfile->Get("h_2DsumAmplLS1");
561  MapNumBadChanDepth[3][1][2] = (TH2F *)hfile->Get("h_2DsumAmplLS2");
562 
563  MapNumBadChanDepth[3][2][1] = (TH2F *)hfile->Get("h_2DsumAmplLS3");
564  MapNumBadChanDepth[3][2][2] = (TH2F *)hfile->Get("h_2DsumAmplLS4");
565  MapNumBadChanDepth[3][2][3] = (TH2F *)hfile->Get("h_2DsumAmplLS5");
566 
567  MapNumBadChanDepth[3][3][4] = (TH2F *)hfile->Get("h_2DsumAmplLS8");
568 
569  MapNumBadChanDepth[3][4][1] = (TH2F *)hfile->Get("h_2DsumAmplLS6");
570  MapNumBadChanDepth[3][4][2] = (TH2F *)hfile->Get("h_2DsumAmplLS7");
571 
572  MapNumBadChanFull[3] = (TH2F *)MapNumBadChanDepth[3][1][1]->Clone();
573 
574  MapNumChanDepth[3][1][1] = (TH2F *)hfile->Get("h_2D0sumAmplLS1");
575  MapNumChanDepth[3][1][2] = (TH2F *)hfile->Get("h_2D0sumAmplLS2");
576 
577  MapNumChanDepth[3][2][1] = (TH2F *)hfile->Get("h_2D0sumAmplLS3");
578  MapNumChanDepth[3][2][2] = (TH2F *)hfile->Get("h_2D0sumAmplLS4");
579  MapNumChanDepth[3][2][3] = (TH2F *)hfile->Get("h_2D0sumAmplLS5");
580 
581  MapNumChanDepth[3][3][4] = (TH2F *)hfile->Get("h_2D0sumAmplLS8");
582 
583  MapNumChanDepth[3][4][1] = (TH2F *)hfile->Get("h_2D0sumAmplLS6");
584  MapNumChanDepth[3][4][2] = (TH2F *)hfile->Get("h_2D0sumAmplLS7");
585 
586  MapNumChanFull[3] = (TH2F *)MapNumChanDepth[3][1][1]->Clone();
587 
588  //+++++++++++++++++++++++++++++
589  // Tmean
590  //+++++++++++++++++++++++++++++
591 
592  MapNumBadChanDepth[4][1][1] = (TH2F *)hfile->Get("h_2DsumTSmeanALS1");
593  MapNumBadChanDepth[4][1][2] = (TH2F *)hfile->Get("h_2DsumTSmeanALS2");
594 
595  MapNumBadChanDepth[4][2][1] = (TH2F *)hfile->Get("h_2DsumTSmeanALS3");
596  MapNumBadChanDepth[4][2][2] = (TH2F *)hfile->Get("h_2DsumTSmeanALS4");
597  MapNumBadChanDepth[4][2][3] = (TH2F *)hfile->Get("h_2DsumTSmeanALS5");
598 
599  MapNumBadChanDepth[4][3][4] = (TH2F *)hfile->Get("h_2DsumTSmeanALS8");
600 
601  MapNumBadChanDepth[4][4][1] = (TH2F *)hfile->Get("h_2DsumTSmeanALS6");
602  MapNumBadChanDepth[4][4][2] = (TH2F *)hfile->Get("h_2DsumTSmeanALS7");
603 
604  MapNumBadChanFull[4] = (TH2F *)MapNumBadChanDepth[4][1][1]->Clone();
605 
606  MapNumChanDepth[4][1][1] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS1");
607  MapNumChanDepth[4][1][2] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS2");
608 
609  MapNumChanDepth[4][2][1] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS3");
610  MapNumChanDepth[4][2][2] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS4");
611  MapNumChanDepth[4][2][3] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS5");
612 
613  MapNumChanDepth[4][3][4] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS8");
614 
615  MapNumChanDepth[4][4][1] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS6");
616  MapNumChanDepth[4][4][2] = (TH2F *)hfile->Get("h_2D0sumTSmeanALS7");
617 
618  MapNumChanFull[4] = (TH2F *)MapNumChanDepth[4][1][1]->Clone();
619 
620  //+++++++++++++++++++++++++++++
621  // Tmax
622  //+++++++++++++++++++++++++++++
623 
624  MapNumBadChanDepth[5][1][1] = (TH2F *)hfile->Get("h_2DsumTSmaxALS1");
625  MapNumBadChanDepth[5][1][2] = (TH2F *)hfile->Get("h_2DsumTSmaxALS2");
626 
627  MapNumBadChanDepth[5][2][1] = (TH2F *)hfile->Get("h_2DsumTSmaxALS3");
628  MapNumBadChanDepth[5][2][2] = (TH2F *)hfile->Get("h_2DsumTSmaxALS4");
629  MapNumBadChanDepth[5][2][3] = (TH2F *)hfile->Get("h_2DsumTSmaxALS5");
630 
631  MapNumBadChanDepth[5][3][4] = (TH2F *)hfile->Get("h_2DsumTSmaxALS8");
632 
633  MapNumBadChanDepth[5][4][1] = (TH2F *)hfile->Get("h_2DsumTSmaxALS6");
634  MapNumBadChanDepth[5][4][2] = (TH2F *)hfile->Get("h_2DsumTSmaxALS7");
635 
636  MapNumBadChanFull[5] = (TH2F *)MapNumBadChanDepth[5][1][1]->Clone();
637 
638  MapNumChanDepth[5][1][1] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS1");
639  MapNumChanDepth[5][1][2] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS2");
640 
641  MapNumChanDepth[5][2][1] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS3");
642  MapNumChanDepth[5][2][2] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS4");
643  MapNumChanDepth[5][2][3] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS5");
644 
645  MapNumChanDepth[5][3][4] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS8");
646 
647  MapNumChanDepth[5][4][1] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS6");
648  MapNumChanDepth[5][4][2] = (TH2F *)hfile->Get("h_2D0sumTSmaxALS7");
649 
650  MapNumChanFull[5] = (TH2F *)MapNumChanDepth[5][1][1]->Clone();
651 
652  for (int test = 0; test <= 5; test++) { //Test: 0,
653  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
654  if (sub == 1)
655  cHB->Divide(2, 1);
656  if (sub == 2)
657  cHE->Divide(3, 1);
658  if (sub == 3)
659  cONE->Divide(1, 1);
660  if (sub == 4)
661  cHB->Divide(2, 1);
662  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
663  if (sub == 1)
664  cHB->cd(k);
665  if (sub == 2)
666  cHE->cd(k);
667  if (sub == 3)
668  cONE->cd(k - 3);
669  if (sub == 4)
670  cHB->cd(k);
671  MapNumBadChanDepth[test][sub][k]->Divide(
672  MapNumBadChanDepth[test][sub][k], MapNumChanDepth[test][sub][k], 1, 1, "B");
673 
674  for (int x = 1; x <= MapNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
675  for (int y = 1; y <= MapNumBadChanFull[test]->GetYaxis()->GetNbins(); y++) {
676  double ccc1 = MapNumBadChanDepth[test][sub][k]->GetBinContent(x, y);
677  MapNumBadChanFull[test]->SetBinContent(x, y, MapNumBadChanFull[test]->GetBinContent(x, y) + ccc1);
678  } //end y
679  } //end x
680 
681  if (k == 1)
682  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
683  if (k == 2)
684  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
685  if (k == 3)
686  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
687  if (k == 4)
688  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
689  gPad->SetGridy();
690  gPad->SetGridx();
691  gPad->SetLogz();
692  MapNumBadChanDepth[test][sub][k]->SetXTitle("#eta \b");
693  MapNumBadChanDepth[test][sub][k]->SetYTitle("#phi \b");
694  MapNumBadChanDepth[test][sub][k]->SetZTitle("Average estimator \b");
695  MapNumBadChanDepth[test][sub][k]->SetTitleOffset(0.75, "Z");
696  MapNumBadChanDepth[test][sub][k]->Draw("COLZ");
697  MapNumBadChanDepth[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
698  // MapNumBadChanDepth[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
699  }
700  if (test == 0) {
701  if (sub == 1) {
702  cHB->Print("MapCapIdErrorHB.png");
703  cHB->Clear();
704  }
705  if (sub == 2) {
706  cHE->Print("MapCapIdErrorHE.png");
707  cHE->Clear();
708  }
709  if (sub == 3) {
710  cONE->Print("MapCapIdErrorHO.png");
711  cONE->Clear();
712  }
713  if (sub == 4) {
714  cHB->Print("MapCapIdErrorHF.png");
715  cHB->Clear();
716  }
717  }
718  if (test == 1) {
719  if (sub == 1) {
720  cHB->Print("MapADCamplHB.png");
721  cHB->Clear();
722  }
723  if (sub == 2) {
724  cHE->Print("MapADCamplHE.png");
725  cHE->Clear();
726  }
727  if (sub == 3) {
728  cONE->Print("MapADCamplHO.png");
729  cONE->Clear();
730  }
731  if (sub == 4) {
732  cHB->Print("MapADCamplHF.png");
733  cHB->Clear();
734  }
735  }
736  if (test == 2) {
737  if (sub == 1) {
738  cHB->Print("MapWidthHB.png");
739  cHB->Clear();
740  }
741  if (sub == 2) {
742  cHE->Print("MapWidthHE.png");
743  cHE->Clear();
744  }
745  if (sub == 3) {
746  cONE->Print("MapWidthHO.png");
747  cONE->Clear();
748  }
749  if (sub == 4) {
750  cHB->Print("MapWidthHF.png");
751  cHB->Clear();
752  }
753  }
754  if (test == 3) {
755  if (sub == 1) {
756  cHB->Print("MapRatioHB.png");
757  cHB->Clear();
758  }
759  if (sub == 2) {
760  cHE->Print("MapRatioHE.png");
761  cHE->Clear();
762  }
763  if (sub == 3) {
764  cONE->Print("MapRatioHO.png");
765  cONE->Clear();
766  }
767  if (sub == 4) {
768  cHB->Print("MapRatioHF.png");
769  cHB->Clear();
770  }
771  }
772  if (test == 4) {
773  if (sub == 1) {
774  cHB->Print("MapTmeanHB.png");
775  cHB->Clear();
776  }
777  if (sub == 2) {
778  cHE->Print("MapTmeanHE.png");
779  cHE->Clear();
780  }
781  if (sub == 3) {
782  cONE->Print("MapTmeanHO.png");
783  cONE->Clear();
784  }
785  if (sub == 4) {
786  cHB->Print("MapTmeanHF.png");
787  cHB->Clear();
788  }
789  }
790  if (test == 5) {
791  if (sub == 1) {
792  cHB->Print("MapTmaxHB.png");
793  cHB->Clear();
794  }
795  if (sub == 2) {
796  cHE->Print("MapTmaxHE.png");
797  cHE->Clear();
798  }
799  if (sub == 3) {
800  cONE->Print("MapTmaxHO.png");
801  cONE->Clear();
802  }
803  if (sub == 4) {
804  cHB->Print("MapTmaxHF.png");
805  cHB->Clear();
806  }
807  }
808  } // end sub
809  cONE->Divide(1, 1);
810  cONE->cd(1);
811  gPad->SetGridy();
812  gPad->SetGridx();
813  gPad->SetLogz();
814  MapNumBadChanFull[test]->SetTitle("All subdetectors\b");
815  MapNumBadChanFull[test]->SetXTitle("#eta \b");
816  MapNumBadChanFull[test]->SetYTitle("#phi \b");
817  if (test == 0)
818  MapNumBadChanFull[test]->SetZTitle("Average Nbcs \b");
819  if (test != 0)
820  MapNumBadChanFull[test]->SetZTitle("Average estimator \b");
821  // MapNumBadChanFull[test]->GetZaxis()->SetLabelSize(0.008);
822  MapNumBadChanFull[test]->SetTitleOffset(0.75, "Z");
823  MapNumBadChanFull[test]->Draw("COLZ");
824  MapNumBadChanFull[test]->GetYaxis()->SetRangeUser(0, 72.);
825  // MapNumBadChanFull[test]->GetZaxis()->SetRangeUser(0.0001, 1.);
826  if (test == 0) {
827  cONE->Print("MapCapIdError.png");
828  cONE->Clear();
829  }
830  if (test == 1) {
831  cONE->Print("MapADCAmpl.png");
832  cONE->Clear();
833  }
834  if (test == 2) {
835  cONE->Print("MapWidth.png");
836  cONE->Clear();
837  }
838  if (test == 3) {
839  cONE->Print("MapRatio.png");
840  cONE->Clear();
841  }
842  if (test == 4) {
843  cONE->Print("MapTmean.png");
844  cONE->Clear();
845  }
846  if (test == 5) {
847  cONE->Print("MapTmax.png");
848  cONE->Clear();
849  }
850  } //end test
851 
852  //================================================================================================================================
853 
854  //=======================================================================================================
855  // 1-d histograms third definition
856 
857  TH1F *HistNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
858  TH1F *HistCutNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
859  TH1F *HistNumChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
860 
861  // TH1F *HistNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
862  // TH1F *HistCutNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
863  // TH1F *HistNumChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
864 
865  TH1F *HistNumBadChanFull[7]; // 1d histogramm for test
866  TH1F *HistNumChanFull[7]; // 1d histogramm for test
867 
868  //+++++++++++++++++++++++++++++
869  // Rate of Cap ID errors
870  //+++++++++++++++++++++++++++++
871 
872  HistNumBadChanDepth[0][1][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HB");
873  HistNumBadChanDepth[0][1][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HB");
874 
875  HistNumBadChanDepth[0][2][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HE");
876  HistNumBadChanDepth[0][2][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HE");
877  HistNumBadChanDepth[0][2][3] = (TH1F *)hfile->Get("h_runnbadchannels_depth3_HE");
878 
879  HistNumBadChanDepth[0][3][4] = (TH1F *)hfile->Get("h_runnbadchannels_depth4_HO");
880 
881  HistNumBadChanDepth[0][4][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HF");
882  HistNumBadChanDepth[0][4][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HF");
883 
884  HistNumBadChanFull[0] = (TH1F *)HistNumBadChanDepth[0][1][1]->Clone();
885 
886  HistCutNumBadChanDepth[0][1][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HB");
887  HistCutNumBadChanDepth[0][1][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HB");
888 
889  HistCutNumBadChanDepth[0][2][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HE");
890  HistCutNumBadChanDepth[0][2][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HE");
891  HistCutNumBadChanDepth[0][2][3] = (TH1F *)hfile->Get("h_runnbadchannels_depth3_HE");
892 
893  HistCutNumBadChanDepth[0][3][4] = (TH1F *)hfile->Get("h_runnbadchannels_depth4_HO");
894 
895  HistCutNumBadChanDepth[0][4][1] = (TH1F *)hfile->Get("h_runnbadchannels_depth1_HF");
896  HistCutNumBadChanDepth[0][4][2] = (TH1F *)hfile->Get("h_runnbadchannels_depth2_HF");
897 
898  HistNumChanDepth[0][1][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HB");
899  HistNumChanDepth[0][1][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HB");
900 
901  HistNumChanDepth[0][2][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HE");
902  HistNumChanDepth[0][2][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HE");
903  HistNumChanDepth[0][2][3] = (TH1F *)hfile->Get("h_runbadrate0_depth3_HE");
904 
905  HistNumChanDepth[0][3][4] = (TH1F *)hfile->Get("h_runbadrate0_depth4_HO");
906 
907  HistNumChanDepth[0][4][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HF");
908  HistNumChanDepth[0][4][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HF");
909 
910  HistNumChanFull[0] = (TH1F *)HistNumChanDepth[0][1][1]->Clone();
911 
912  //+++++++++++++++++++++++++++++
913  // ADC Amplitude
914  //+++++++++++++++++++++++++++++
915 
917  // HB:
918  HistNumBadChanDepth[1][1][1] = (TH1F *)hfile->Get("h_sumADCAmplperLS1");
919  HistNumBadChanDepth[1][1][2] = (TH1F *)hfile->Get("h_sumADCAmplperLS2");
920 
921  // HE:
922  HistNumBadChanDepth[1][2][1] = (TH1F *)hfile->Get("h_sumADCAmplperLS3");
923  HistNumBadChanDepth[1][2][2] = (TH1F *)hfile->Get("h_sumADCAmplperLS4");
924  HistNumBadChanDepth[1][2][3] = (TH1F *)hfile->Get("h_sumADCAmplperLS5");
925  // HE upgrade:
926  HistNumBadChanDepth[1][2][4] = (TH1F *)hfile->Get("h_sumADCAmplperLSdepth4HEu");
927  HistNumBadChanDepth[1][2][5] = (TH1F *)hfile->Get("h_sumADCAmplperLSdepth5HEu");
928  HistNumBadChanDepth[1][2][6] = (TH1F *)hfile->Get("h_sumADCAmplperLSdepth6HEu");
929  HistNumBadChanDepth[1][2][7] = (TH1F *)hfile->Get("h_sumADCAmplperLSdepth7HEu");
930 
931  // HO:
932  HistNumBadChanDepth[1][3][4] = (TH1F *)hfile->Get("h_sumADCAmplperLS8");
933 
934  // HF:
935  HistNumBadChanDepth[1][4][1] = (TH1F *)hfile->Get("h_sumADCAmplperLS6");
936  HistNumBadChanDepth[1][4][2] = (TH1F *)hfile->Get("h_sumADCAmplperLS7");
937  // HF upgrade:
938  HistNumBadChanDepth[1][4][3] = (TH1F *)hfile->Get("h_sumADCAmplperLS6u");
939  HistNumBadChanDepth[1][4][4] = (TH1F *)hfile->Get("h_sumADCAmplperLS7u");
940 
941  // other cases:
942  HistNumBadChanFull[1] = (TH1F *)HistNumBadChanDepth[1][1][1]->Clone();
943 
945  // HB:
946  HistCutNumBadChanDepth[1][1][1] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS1");
947  HistCutNumBadChanDepth[1][1][2] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS2");
948 
949  // HE:
950  HistCutNumBadChanDepth[1][2][1] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS3");
951  HistCutNumBadChanDepth[1][2][2] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS4");
952  HistCutNumBadChanDepth[1][2][3] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS5");
953  // HE upgrade:
954  HistCutNumBadChanDepth[1][2][4] = (TH1F *)hfile->Get("h_sumCutADCAmplperLSdepth4HEu");
955  HistCutNumBadChanDepth[1][2][5] = (TH1F *)hfile->Get("h_sumCutADCAmplperLSdepth5HEu");
956  HistCutNumBadChanDepth[1][2][6] = (TH1F *)hfile->Get("h_sumCutADCAmplperLSdepth6HEu");
957  HistCutNumBadChanDepth[1][2][7] = (TH1F *)hfile->Get("h_sumCutADCAmplperLSdepth7HEu");
958 
959  // HO:
960  HistCutNumBadChanDepth[1][3][4] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS8");
961 
962  // HF:
963  HistCutNumBadChanDepth[1][4][1] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS6");
964  HistCutNumBadChanDepth[1][4][2] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS7");
965  // HF upgrade:
966  HistCutNumBadChanDepth[1][4][3] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS6u");
967  HistCutNumBadChanDepth[1][4][4] = (TH1F *)hfile->Get("h_sumCutADCAmplperLS7u");
968 
970  // HB:
971  HistNumChanDepth[1][1][1] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS1");
972  HistNumChanDepth[1][1][2] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS2");
973 
974  // HE:
975  HistNumChanDepth[1][2][1] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS3");
976  HistNumChanDepth[1][2][2] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS4");
977  HistNumChanDepth[1][2][3] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS5");
978  // HE upgrade:
979  HistNumChanDepth[1][2][4] = (TH1F *)hfile->Get("h_sum0ADCAmplperLSdepth4HEu");
980  HistNumChanDepth[1][2][5] = (TH1F *)hfile->Get("h_sum0ADCAmplperLSdepth5HEu");
981  HistNumChanDepth[1][2][6] = (TH1F *)hfile->Get("h_sum0ADCAmplperLSdepth6HEu");
982  HistNumChanDepth[1][2][7] = (TH1F *)hfile->Get("h_sum0ADCAmplperLSdepth7HEu");
983 
984  // HO:
985  HistNumChanDepth[1][3][4] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS8");
986 
987  // HF:
988  HistNumChanDepth[1][4][1] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS6");
989  HistNumChanDepth[1][4][2] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS7");
990  // HF upgrade:
991  HistNumChanDepth[1][4][3] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS6u");
992  HistNumChanDepth[1][4][4] = (TH1F *)hfile->Get("h_sum0ADCAmplperLS7u");
993 
994  // other cases:
995  HistNumChanFull[1] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
996  // just initialization of [6] massive for alternative <A> calculation
997  HistNumChanFull[6] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
998 
999  //+++++++++++++++++++++++++++++
1000  // Width
1001  //+++++++++++++++++++++++++++++
1002 
1003  HistNumBadChanDepth[2][1][1] = (TH1F *)hfile->Get("h_sumAmplitudeperLS1");
1004  HistNumBadChanDepth[2][1][2] = (TH1F *)hfile->Get("h_sumAmplitudeperLS2");
1005 
1006  HistNumBadChanDepth[2][2][1] = (TH1F *)hfile->Get("h_sumAmplitudeperLS3");
1007  HistNumBadChanDepth[2][2][2] = (TH1F *)hfile->Get("h_sumAmplitudeperLS4");
1008  HistNumBadChanDepth[2][2][3] = (TH1F *)hfile->Get("h_sumAmplitudeperLS5");
1009 
1010  HistNumBadChanDepth[2][3][4] = (TH1F *)hfile->Get("h_sumAmplitudeperLS8");
1011 
1012  HistNumBadChanDepth[2][4][1] = (TH1F *)hfile->Get("h_sumAmplitudeperLS6");
1013  HistNumBadChanDepth[2][4][2] = (TH1F *)hfile->Get("h_sumAmplitudeperLS7");
1014 
1015  HistNumBadChanFull[2] = (TH1F *)HistNumBadChanDepth[2][1][1]->Clone();
1016 
1017  HistCutNumBadChanDepth[2][1][1] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS1");
1018  HistCutNumBadChanDepth[2][1][2] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS2");
1019 
1020  HistCutNumBadChanDepth[2][2][1] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS3");
1021  HistCutNumBadChanDepth[2][2][2] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS4");
1022  HistCutNumBadChanDepth[2][2][3] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS5");
1023 
1024  HistCutNumBadChanDepth[2][3][4] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS8");
1025 
1026  HistCutNumBadChanDepth[2][4][1] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS6");
1027  HistCutNumBadChanDepth[2][4][2] = (TH1F *)hfile->Get("h_sumCutAmplitudeperLS7");
1028 
1029  HistNumChanDepth[2][1][1] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS1");
1030  HistNumChanDepth[2][1][2] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS2");
1031 
1032  HistNumChanDepth[2][2][1] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS3");
1033  HistNumChanDepth[2][2][2] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS4");
1034  HistNumChanDepth[2][2][3] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS5");
1035 
1036  HistNumChanDepth[2][3][4] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS8");
1037 
1038  HistNumChanDepth[2][4][1] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS6");
1039  HistNumChanDepth[2][4][2] = (TH1F *)hfile->Get("h_sum0AmplitudeperLS7");
1040 
1041  HistNumChanFull[2] = (TH1F *)HistNumChanDepth[2][1][1]->Clone();
1042  //+++++++++++++++++++++++++++++
1043  // Ratio
1044  //+++++++++++++++++++++++++++++
1045 
1046  HistNumBadChanDepth[3][1][1] = (TH1F *)hfile->Get("h_sumAmplperLS1");
1047  HistNumBadChanDepth[3][1][2] = (TH1F *)hfile->Get("h_sumAmplperLS2");
1048 
1049  HistNumBadChanDepth[3][2][1] = (TH1F *)hfile->Get("h_sumAmplperLS3");
1050  HistNumBadChanDepth[3][2][2] = (TH1F *)hfile->Get("h_sumAmplperLS4");
1051  HistNumBadChanDepth[3][2][3] = (TH1F *)hfile->Get("h_sumAmplperLS5");
1052 
1053  HistNumBadChanDepth[3][3][4] = (TH1F *)hfile->Get("h_sumAmplperLS8");
1054 
1055  HistNumBadChanDepth[3][4][1] = (TH1F *)hfile->Get("h_sumAmplperLS6");
1056  HistNumBadChanDepth[3][4][2] = (TH1F *)hfile->Get("h_sumAmplperLS7");
1057 
1058  HistNumBadChanFull[3] = (TH1F *)HistNumBadChanDepth[3][1][1]->Clone();
1059 
1060  HistCutNumBadChanDepth[3][1][1] = (TH1F *)hfile->Get("h_sumCutAmplperLS1");
1061  HistCutNumBadChanDepth[3][1][2] = (TH1F *)hfile->Get("h_sumCutAmplperLS2");
1062 
1063  HistCutNumBadChanDepth[3][2][1] = (TH1F *)hfile->Get("h_sumCutAmplperLS3");
1064  HistCutNumBadChanDepth[3][2][2] = (TH1F *)hfile->Get("h_sumCutAmplperLS4");
1065  HistCutNumBadChanDepth[3][2][3] = (TH1F *)hfile->Get("h_sumCutAmplperLS5");
1066 
1067  HistCutNumBadChanDepth[3][3][4] = (TH1F *)hfile->Get("h_sumCutAmplperLS8");
1068 
1069  HistCutNumBadChanDepth[3][4][1] = (TH1F *)hfile->Get("h_sumCutAmplperLS6");
1070  HistCutNumBadChanDepth[3][4][2] = (TH1F *)hfile->Get("h_sumCutAmplperLS7");
1071 
1072  HistNumChanDepth[3][1][1] = (TH1F *)hfile->Get("h_sum0AmplperLS1");
1073  HistNumChanDepth[3][1][2] = (TH1F *)hfile->Get("h_sum0AmplperLS2");
1074 
1075  HistNumChanDepth[3][2][1] = (TH1F *)hfile->Get("h_sum0AmplperLS3");
1076  HistNumChanDepth[3][2][2] = (TH1F *)hfile->Get("h_sum0AmplperLS4");
1077  HistNumChanDepth[3][2][3] = (TH1F *)hfile->Get("h_sum0AmplperLS5");
1078 
1079  HistNumChanDepth[3][3][4] = (TH1F *)hfile->Get("h_sum0AmplperLS8");
1080 
1081  HistNumChanDepth[3][4][1] = (TH1F *)hfile->Get("h_sum0AmplperLS6");
1082  HistNumChanDepth[3][4][2] = (TH1F *)hfile->Get("h_sum0AmplperLS7");
1083 
1084  HistNumChanFull[3] = (TH1F *)HistNumChanDepth[3][1][1]->Clone();
1085  //+++++++++++++++++++++++++++++
1086  // Tmean
1087  //+++++++++++++++++++++++++++++
1088 
1089  HistNumBadChanDepth[4][1][1] = (TH1F *)hfile->Get("h_sumTSmeanAperLS1");
1090  HistNumBadChanDepth[4][1][2] = (TH1F *)hfile->Get("h_sumTSmeanAperLS2");
1091 
1092  HistNumBadChanDepth[4][2][1] = (TH1F *)hfile->Get("h_sumTSmeanAperLS3");
1093  HistNumBadChanDepth[4][2][2] = (TH1F *)hfile->Get("h_sumTSmeanAperLS4");
1094  HistNumBadChanDepth[4][2][3] = (TH1F *)hfile->Get("h_sumTSmeanAperLS5");
1095 
1096  HistNumBadChanDepth[4][3][4] = (TH1F *)hfile->Get("h_sumTSmeanAperLS8");
1097 
1098  HistNumBadChanDepth[4][4][1] = (TH1F *)hfile->Get("h_sumTSmeanAperLS6");
1099  HistNumBadChanDepth[4][4][2] = (TH1F *)hfile->Get("h_sumTSmeanAperLS7");
1100 
1101  HistNumBadChanFull[4] = (TH1F *)HistNumBadChanDepth[4][1][1]->Clone();
1102 
1103  HistCutNumBadChanDepth[4][1][1] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS1");
1104  HistCutNumBadChanDepth[4][1][2] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS2");
1105 
1106  HistCutNumBadChanDepth[4][2][1] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS3");
1107  HistCutNumBadChanDepth[4][2][2] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS4");
1108  HistCutNumBadChanDepth[4][2][3] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS5");
1109 
1110  HistCutNumBadChanDepth[4][3][4] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS8");
1111 
1112  HistCutNumBadChanDepth[4][4][1] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS6");
1113  HistCutNumBadChanDepth[4][4][2] = (TH1F *)hfile->Get("h_sumCutTSmeanAperLS7");
1114 
1115  HistNumChanDepth[4][1][1] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS1");
1116  HistNumChanDepth[4][1][2] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS2");
1117 
1118  HistNumChanDepth[4][2][1] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS3");
1119  HistNumChanDepth[4][2][2] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS4");
1120  HistNumChanDepth[4][2][3] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS5");
1121 
1122  HistNumChanDepth[4][3][4] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS8");
1123 
1124  HistNumChanDepth[4][4][1] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS6");
1125  HistNumChanDepth[4][4][2] = (TH1F *)hfile->Get("h_sum0TSmeanAperLS7");
1126 
1127  HistNumChanFull[4] = (TH1F *)HistNumChanDepth[4][1][1]->Clone();
1128  //+++++++++++++++++++++++++++++
1129  // Tmax
1130  //+++++++++++++++++++++++++++++
1131 
1132  HistNumBadChanDepth[5][1][1] = (TH1F *)hfile->Get("h_sumTSmaxAperLS1");
1133  HistNumBadChanDepth[5][1][2] = (TH1F *)hfile->Get("h_sumTSmaxAperLS2");
1134 
1135  HistNumBadChanDepth[5][2][1] = (TH1F *)hfile->Get("h_sumTSmaxAperLS3");
1136  HistNumBadChanDepth[5][2][2] = (TH1F *)hfile->Get("h_sumTSmaxAperLS4");
1137  HistNumBadChanDepth[5][2][3] = (TH1F *)hfile->Get("h_sumTSmaxAperLS5");
1138 
1139  HistNumBadChanDepth[5][3][4] = (TH1F *)hfile->Get("h_sumTSmaxAperLS8");
1140 
1141  HistNumBadChanDepth[5][4][1] = (TH1F *)hfile->Get("h_sumTSmaxAperLS6");
1142  HistNumBadChanDepth[5][4][2] = (TH1F *)hfile->Get("h_sumTSmaxAperLS7");
1143 
1144  HistNumBadChanFull[5] = (TH1F *)HistNumBadChanDepth[5][1][1]->Clone();
1145 
1146  HistCutNumBadChanDepth[5][1][1] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS1");
1147  HistCutNumBadChanDepth[5][1][2] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS2");
1148 
1149  HistCutNumBadChanDepth[5][2][1] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS3");
1150  HistCutNumBadChanDepth[5][2][2] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS4");
1151  HistCutNumBadChanDepth[5][2][3] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS5");
1152 
1153  HistCutNumBadChanDepth[5][3][4] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS8");
1154 
1155  HistCutNumBadChanDepth[5][4][1] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS6");
1156  HistCutNumBadChanDepth[5][4][2] = (TH1F *)hfile->Get("h_sumCutTSmaxAperLS7");
1157 
1158  HistNumChanDepth[5][1][1] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS1");
1159  HistNumChanDepth[5][1][2] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS2");
1160 
1161  HistNumChanDepth[5][2][1] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS3");
1162  HistNumChanDepth[5][2][2] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS4");
1163  HistNumChanDepth[5][2][3] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS5");
1164 
1165  HistNumChanDepth[5][3][4] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS8");
1166 
1167  HistNumChanDepth[5][4][1] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS6");
1168  HistNumChanDepth[5][4][2] = (TH1F *)hfile->Get("h_sum0TSmaxAperLS7");
1169 
1170  HistNumChanFull[5] = (TH1F *)HistNumChanDepth[5][1][1]->Clone();
1171 
1172  for (int test = 0; test <= 5; test++) { //Test: =0(CapIdErrors), =1(Amplitude), =2...
1173  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1174  if (sub == 1)
1175  cHE->Divide(2, 1); //HB
1176  if (sub == 2 && test != 1)
1177  cHE->Divide(3, 1); //HE
1178  if (sub == 2 && test == 1) {
1179  cNine->Clear();
1180  cNine->Divide(3, 3);
1181  } //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1182  if (sub == 3)
1183  cHB->Divide(1, 1); //HO
1184  if (sub == 4 && test != 1)
1185  cHE->Divide(2, 1); //HF
1186  if (sub == 4 && test == 1) {
1187  cFour1->Clear();
1188  cFour1->Divide(2, 2);
1189  } // HF upgrade with new depthes 3 and 4 for Amplitude test only
1190 
1191  int kkkkkkmax = k_max[sub];
1192  if ((sub == 4 || sub == 2) && test == 1)
1193  kkkkkkmax = k_maxHFupgrade[sub];
1194  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1195  if (sub == 1)
1196  cHE->cd(k); //HB
1197  if (sub == 2 && test != 1)
1198  cHE->cd(k); //HE
1199  if (sub == 2 && test == 1)
1200  cNine->cd(k); //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1201  if (sub == 3)
1202  cHB->cd(k - 3); //HO
1203  if (sub == 4 && test != 1)
1204  cHE->cd(k); //HF
1205  if (sub == 4 && test == 1)
1206  cFour1->cd(k); // HF upgrade with new depthes 3 and 4 for Amplitude test only
1207  gPad->SetGridy();
1208  gPad->SetGridx();
1209  // gPad->SetLogy();
1210 
1211  if (sub == 1 && k == 1) {
1212  } else {
1213  // use "else" because ...Full[test] are filled by estimastor for sub==1 && k== 1 at initialization of ...Full[test] variables
1214  for (int x = 1; x <= HistNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
1215  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1216  HistNumBadChanFull[test]->SetBinContent(x, HistNumBadChanFull[test]->GetBinContent(x) + ccc1);
1217  double ccc2 = HistNumChanDepth[test][sub][k]->GetBinContent(x);
1218  HistNumChanFull[test]->SetBinContent(x, HistNumChanFull[test]->GetBinContent(x) + ccc2);
1219  }
1220  } //end x
1221 
1222  // !!!!!! change the sense of HistNumBadChanDepth: now it's averaged values(estimators)
1223  HistNumBadChanDepth[test][sub][k]->Divide(
1224  HistNumBadChanDepth[test][sub][k], HistNumChanDepth[test][sub][k], 1, 1, "B");
1225  // errors abnulling:
1226  for (int x = 1; x <= HistNumBadChanDepth[test][sub][k]->GetXaxis()->GetNbins(); x++) {
1227  HistNumBadChanDepth[test][sub][k]->SetBinError(float(x), 0.01);
1228  }
1229 
1230  // int myMaxLum= HistNumBadChanDepth[test][sub][k]->GetBinContent(HistNumBadChanDepth[test][sub][k]->GetMaximumBin());
1231  // cout<<"********************>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> myMaxLum = "<<myMaxLum<<" MaxLum = "<<MaxLum<<endl;
1232  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1233 
1234  // // // // // // // // // // // // // // // // // //
1235  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1236  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.4);
1237  HistNumBadChanDepth[test][sub][k]->GetYaxis()->SetLabelSize(0.04);
1238  if (k == 1)
1239  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1240  if (k == 2)
1241  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1242  if (k == 3)
1243  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1244  if (k == 4)
1245  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1246  if (k == 5)
1247  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 5\b");
1248  if (k == 6)
1249  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 6\b");
1250  if (k == 7)
1251  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 7\b");
1252  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1253  if (test == 0)
1254  HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1255  if (test != 0)
1256  HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1257  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1258  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1259  // gPad->SetGridx();
1260  gPad->SetLogy();
1261  gPad->SetGridy();
1262  gPad->SetGridx();
1263  // if (test == 1) HistNumBadChanDepth[test][sub][k]->SetMinimum(0.1);
1264  HistNumBadChanDepth[test][sub][k]->Draw("Error");
1265  /*
1266  if (k == 1) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1267  if (k == 2) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1268  if (k == 3) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1269  if (k == 4) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1270  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1271  if (test == 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1272  if (test != 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1273 
1274  if (MaxLum<=1000){
1275  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1276  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.5);
1277  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1278  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1279  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1280  HistNumBadChanDepth[test][sub][k]->Draw("P");
1281  }
1282  else{
1283  HistNumBadChanDepth[test][sub][k]->SetLineColor(2);
1284  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1285  HistNumBadChanDepth[test][sub][k]->Draw("L");
1286  }
1287  */
1288  /*
1289  float min_x[] = {0,10000};
1290  float min_y[] = {(float)(Cut0[test][sub][k]),(float)(Cut0[test][sub][k])};
1291  TGraph* MIN = new TGraph(2, min_x, min_y);
1292  MIN->SetLineStyle(2);
1293  MIN->SetLineColor(5);
1294  MIN->SetLineWidth(2 + 100*100);
1295  MIN->SetFillStyle(3005);
1296  MIN->SetFillColor(5);
1297  gPad->SetGridy();
1298  gPad->SetGridx();
1299  MIN->Draw("L");
1300 */
1301 
1302  if (sub == 1) {
1303  cHE->Modified();
1304  }
1305  if (sub == 2 && test != 1) {
1306  cHE->Modified();
1307  }
1308  if (sub == 2 && test == 1) {
1309  cNine->Modified();
1310  } // HE upgrade
1311  if (sub == 3) {
1312  cHB->Modified();
1313  }
1314  if (sub == 4 && test != 1) {
1315  cHE->Modified();
1316  }
1317  if (sub == 4 && test == 1) {
1318  cFour1->Modified();
1319  } // HF upgrade
1320 
1321  } // k loop
1322 
1323  if (test == 0) {
1324  if (sub == 1) {
1325  cHE->Print("HistNBCMNHB.png");
1326  cHE->Clear();
1327  }
1328  if (sub == 2) {
1329  cHE->Print("HistNBCMNHE.png");
1330  cHE->Clear();
1331  }
1332  if (sub == 3) {
1333  cHB->Print("HistNBCMNHO.png");
1334  cHB->Clear();
1335  }
1336  if (sub == 4) {
1337  cHE->Print("HistNBCMNHF.png");
1338  cHE->Clear();
1339  }
1340  }
1341  // Amplitude:
1342  if (test == 1) {
1343  if (sub == 1) {
1344  cHE->Print("HistADCamplHB.png");
1345  cHE->Clear();
1346  }
1347  // if (sub==2) {cHE->Print("HistADCamplHE.png"); cHE->Clear();}
1348  if (sub == 2) {
1349  cNine->Print("HistADCamplHE.png");
1350  cNine->Clear();
1351  } // HE upgrade
1352  if (sub == 3) {
1353  cHB->Print("HistADCamplHO.png");
1354  cHB->Clear();
1355  }
1356  if (sub == 4) {
1357  cFour1->Print("HistADCamplHF.png");
1358  cFour1->Clear();
1359  } // HF upgrade
1360  }
1361  if (test == 2) {
1362  if (sub == 1) {
1363  cHE->Print("HistWidthHB.png");
1364  cHE->Clear();
1365  }
1366  if (sub == 2) {
1367  cHE->Print("HistWidthHE.png");
1368  cHE->Clear();
1369  }
1370  if (sub == 3) {
1371  cHB->Print("HistWidthHO.png");
1372  cHB->Clear();
1373  }
1374  if (sub == 4) {
1375  cHE->Print("HistWidthHF.png");
1376  cHE->Clear();
1377  }
1378  }
1379  if (test == 3) {
1380  if (sub == 1) {
1381  cHE->Print("HistRatioHB.png");
1382  cHE->Clear();
1383  }
1384  if (sub == 2) {
1385  cHE->Print("HistRatioHE.png");
1386  cHE->Clear();
1387  }
1388  if (sub == 3) {
1389  cHB->Print("HistRatioHO.png");
1390  cHB->Clear();
1391  }
1392  if (sub == 4) {
1393  cHE->Print("HistRatioHF.png");
1394  cHE->Clear();
1395  }
1396  }
1397  if (test == 4) {
1398  if (sub == 1) {
1399  cHE->Print("HistTmeanHB.png");
1400  cHE->Clear();
1401  }
1402  if (sub == 2) {
1403  cHE->Print("HistTmeanHE.png");
1404  cHE->Clear();
1405  }
1406  if (sub == 3) {
1407  cHB->Print("HistTmeanHO.png");
1408  cHB->Clear();
1409  }
1410  if (sub == 4) {
1411  cHE->Print("HistTmeanHF.png");
1412  cHE->Clear();
1413  }
1414  }
1415  if (test == 5) {
1416  if (sub == 1) {
1417  cHE->Print("HistTmaxHB.png");
1418  cHE->Clear();
1419  }
1420  if (sub == 2) {
1421  cHE->Print("HistTmaxHE.png");
1422  cHE->Clear();
1423  }
1424  if (sub == 3) {
1425  cHB->Print("HistTmaxHO.png");
1426  cHB->Clear();
1427  }
1428  if (sub == 4) {
1429  cHE->Print("HistTmaxHF.png");
1430  cHE->Clear();
1431  }
1432  }
1433  } // end sub
1435  if (test == 1) {
1436  for (int x = 1; x <= HistNumChanFull[6]->GetXaxis()->GetNbins(); x++) {
1437  HistNumChanFull[6]->SetBinContent(x, 0.0);
1438  int depthsubcount = 0.;
1439  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1440  int kkkkkkmax = k_max[sub];
1441  if (sub == 4 || sub == 2)
1442  kkkkkkmax = k_maxHFupgrade[sub];
1443  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1444  // line below is temporary, just to avoid contribution of HEP(M)17 in depthes 4,5,6,7 but keep in depthes 1,2,3
1445  if (sub == 2 && k > 3)
1446  break;
1447  depthsubcount++;
1448  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1449  HistNumChanFull[6]->SetBinContent(x, HistNumChanFull[6]->GetBinContent(x) + ccc1);
1450  } //depth
1451  } //sub
1452  if (depthsubcount > 0.) {
1453  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / depthsubcount);
1454  } else {
1455  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / 8.);
1456  }
1457  } //x
1458  } //test=1
1460  if (test != 1) {
1461  cHB->Divide(1, 1);
1462  cHB->cd(1);
1463  } else {
1464  cHE->Divide(2, 1);
1465  cHE->cd(1);
1466  }
1467  HistNumBadChanFull[test]->Divide(HistNumBadChanFull[test], HistNumChanFull[test], 1, 1, "B");
1468  TH1F *kfitq = new TH1F("kfitq", "", MaxLum, 1., MaxLum + 1.);
1469  int nx = kfitq->GetXaxis()->GetNbins();
1470  for (int i = 1; i <= nx; i++) {
1471  double ccc1 = HistNumBadChanFull[test]->GetBinContent(i);
1472  if (ccc1 > 0.) {
1473  kfitq->Fill(float(i), ccc1);
1474  kfitq->SetBinError(float(i), 0.01);
1475  }
1476  }
1477  kfitq->SetMarkerStyle(20);
1478  kfitq->SetMarkerSize(0.4);
1479  kfitq->GetYaxis()->SetLabelSize(0.04);
1480  if (test == 0)
1481  kfitq->SetTitle("Average Nbch for whole Hcal \b");
1482  if (test != 0)
1483  kfitq->SetTitle("Averaged estimator for whole Hcal \b");
1484  kfitq->SetXTitle("LS \b");
1485  if (test == 0)
1486  kfitq->SetYTitle("<Number of bad channels> \b");
1487  if (test != 0)
1488  kfitq->SetYTitle("Averaged estimator \b");
1489  kfitq->SetMarkerColor(2);
1490  kfitq->SetLineColor(0);
1491  gPad->SetGridx();
1492  kfitq->Draw("Error");
1493  /*
1494  HistNumBadChanFull[test]->SetMarkerStyle(20);
1495  HistNumBadChanFull[test]->SetMarkerSize(0.8);
1496  HistNumBadChanFull[test]->SetTitle("Averaged estimator for whole Hcal \b");
1497  HistNumBadChanFull[test]->SetXTitle("LS \b");
1498  if (test == 0) HistNumBadChanFull[test]->SetYTitle("<Number of bad channels> \b");
1499  if (test != 0) HistNumBadChanFull[test]->SetYTitle("Averaged estimator \b");
1500  if (MaxLum<=1000){
1501  HistNumBadChanFull[test]->SetMarkerColor(1);
1502  HistNumBadChanFull[test]->SetLineColor(0);
1503  HistNumBadChanFull[test]->Draw("P");
1504  }
1505  else {
1506  HistNumBadChanFull[test]->SetLineColor(1);
1507  HistNumBadChanFull[test]->Draw("L");
1508  }
1509  */
1510  if (test == 1) {
1511  cHE->cd(2);
1512  TH1F *lpuio = new TH1F("lpuio", "", MaxLum, 1., MaxLum + 1.);
1513  int nx = lpuio->GetXaxis()->GetNbins();
1514  for (int i = 1; i <= nx; i++) {
1515  double ccc1 = HistNumChanFull[6]->GetBinContent(i);
1516  if (ccc1 > 0.) {
1517  lpuio->Fill(float(i), ccc1);
1518  lpuio->SetBinError(float(i), 0.01);
1519  }
1520  }
1521  lpuio->SetMarkerStyle(20);
1522  lpuio->SetMarkerSize(0.4);
1523  lpuio->GetYaxis()->SetLabelSize(0.04);
1524  lpuio->SetTitle("Mean of Averaged Amplitudes over all Hcal sub-detectors \b");
1525  lpuio->SetXTitle("LS \b");
1526  lpuio->SetYTitle("Mean of Averaged estimator \b");
1527  lpuio->SetMarkerColor(2);
1528  lpuio->SetLineColor(0);
1529  gPad->SetGridx();
1530  lpuio->Draw("Error");
1531  }
1532  if (test == 0) {
1533  cHB->Print("HistCapID.png");
1534  cHB->Clear();
1535  }
1536  if (test == 1) {
1537  cHE->Print("HistADCAmpl.png");
1538  cHE->Clear();
1539  }
1540  if (test == 2) {
1541  cHB->Print("HistWidth.png");
1542  cHB->Clear();
1543  }
1544  if (test == 3) {
1545  cHB->Print("HistRatio.png");
1546  cHB->Clear();
1547  }
1548  if (test == 4) {
1549  cHB->Print("HistTmean.png");
1550  cHB->Clear();
1551  }
1552  if (test == 5) {
1553  cHB->Print("HistTmax.png");
1554  cHB->Clear();
1555  }
1556 
1557  // clean-up
1558  if (kfitq)
1559  delete kfitq;
1560  } //end test
1561 
1562  //================================================================================================================================
1563 
1564  //=======================================================================================================333
1565  //CapID 1-d histograms
1566 
1567  TH1F *HistAbnormNumBadChanDepth[5][5]; // 1d histogramm for subdet, depth
1568 
1569  //+++++++++++++++++++++++++++++
1570  // Abnormal Bad Channels Rate of Cap ID errors first set of histograms
1571  //+++++++++++++++++++++++++++++
1572 
1573  HistAbnormNumBadChanDepth[1][1] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth1_HB");
1574  HistAbnormNumBadChanDepth[1][2] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth2_HB");
1575  HistAbnormNumBadChanDepth[2][1] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth1_HE");
1576  HistAbnormNumBadChanDepth[2][2] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth2_HE");
1577  HistAbnormNumBadChanDepth[2][3] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth3_HE");
1578  HistAbnormNumBadChanDepth[3][4] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth4_HO");
1579  HistAbnormNumBadChanDepth[4][1] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth1_HF");
1580  HistAbnormNumBadChanDepth[4][2] = (TH1F *)hfile->Get("h_runnbadchannelsC_depth2_HF");
1581 
1582  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1583  if (sub == 1)
1584  cHB->Divide(2, 1);
1585  if (sub == 2)
1586  cHE->Divide(3, 1);
1587  if (sub == 3)
1588  cONE->Divide(1, 1);
1589  if (sub == 4)
1590  cHB->Divide(2, 1);
1591  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1592  if (sub == 1)
1593  cHB->cd(k);
1594  if (sub == 2)
1595  cHE->cd(k);
1596  if (sub == 3)
1597  cONE->cd(k - 3);
1598  if (sub == 4)
1599  cHB->cd(k);
1600  gPad->SetGridy();
1601  gPad->SetGridx();
1602  // gPad->SetLogy();
1603  HistAbnormNumBadChanDepth[sub][k]->Divide(
1604  HistAbnormNumBadChanDepth[sub][k], HistNumChanDepth[0][sub][k], 1, 1, "B");
1605  if (k == 1)
1606  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 1\b");
1607  if (k == 2)
1608  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 2\b");
1609  if (k == 3)
1610  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 3\b");
1611  if (k == 4)
1612  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 4\b");
1613  HistAbnormNumBadChanDepth[sub][k]->SetXTitle("LS \b");
1614  HistAbnormNumBadChanDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1615  if (MaxLum <= 1000) {
1616  HistAbnormNumBadChanDepth[sub][k]->SetMarkerStyle(20);
1617  HistAbnormNumBadChanDepth[sub][k]->SetMarkerSize(0.5);
1618  HistAbnormNumBadChanDepth[sub][k]->SetMarkerColor(1);
1619  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(0);
1620  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1621  HistAbnormNumBadChanDepth[sub][k]->Draw("P");
1622  } else {
1623  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(1);
1624  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1625  HistAbnormNumBadChanDepth[sub][k]->Draw("L");
1626  }
1627  }
1628  if (sub == 1) {
1629  cHB->Print("Hist_CAPID_Abnorm_HB.png");
1630  cHB->Clear();
1631  }
1632  if (sub == 2) {
1633  cHE->Print("Hist_CAPID_Abnorm_HE.png");
1634  cHE->Clear();
1635  }
1636  if (sub == 3) {
1637  cONE->Print("Hist_CAPID_Abnorm_HO.png");
1638  cONE->Clear();
1639  }
1640  if (sub == 4) {
1641  cHB->Print("Hist_CAPID_Abnorm_HF.png");
1642  cHB->Clear();
1643  }
1644  } // end sub
1645 
1646  //+++++++++++++++++++++++++++++
1647  // Portions of bad channels events identified by Cap ID errors third set of histograms
1648  //+++++++++++++++++++++++++++++
1649 
1650  TH1F *HistPortBadEventsDepth[5][5]; // 1d histogramm for subdet, depth
1651 
1652  HistPortBadEventsDepth[1][1] = (TH1F *)hfile->Get("h_runbadrateC_depth1_HB");
1653  HistPortBadEventsDepth[1][2] = (TH1F *)hfile->Get("h_runbadrateC_depth2_HB");
1654  HistPortBadEventsDepth[2][1] = (TH1F *)hfile->Get("h_runbadrateC_depth1_HE");
1655  HistPortBadEventsDepth[2][2] = (TH1F *)hfile->Get("h_runbadrateC_depth2_HE");
1656  HistPortBadEventsDepth[2][3] = (TH1F *)hfile->Get("h_runbadrateC_depth3_HE");
1657  HistPortBadEventsDepth[3][4] = (TH1F *)hfile->Get("h_runbadrateC_depth4_HO");
1658  HistPortBadEventsDepth[4][1] = (TH1F *)hfile->Get("h_runbadrateC_depth1_HF");
1659  HistPortBadEventsDepth[4][2] = (TH1F *)hfile->Get("h_runbadrateC_depth2_HF");
1660 
1661  TH1F *HistNumRateDepth[5][5];
1662  HistNumRateDepth[1][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HB");
1663  HistNumRateDepth[1][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HB");
1664  HistNumRateDepth[2][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HE");
1665  HistNumRateDepth[2][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HE");
1666  HistNumRateDepth[2][3] = (TH1F *)hfile->Get("h_runbadrate0_depth3_HE");
1667  HistNumRateDepth[3][4] = (TH1F *)hfile->Get("h_runbadrate0_depth4_HO");
1668  HistNumRateDepth[4][1] = (TH1F *)hfile->Get("h_runbadrate0_depth1_HF");
1669  HistNumRateDepth[4][2] = (TH1F *)hfile->Get("h_runbadrate0_depth2_HF");
1670 
1671  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1672  if (sub == 1)
1673  cHB->Divide(2, 1);
1674  if (sub == 2)
1675  cHE->Divide(3, 1);
1676  if (sub == 3)
1677  cONE->Divide(1, 1);
1678  if (sub == 4)
1679  cHB->Divide(2, 1);
1680  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1681  if (sub == 1)
1682  cHB->cd(k);
1683  if (sub == 2)
1684  cHE->cd(k);
1685  if (sub == 3)
1686  cONE->cd(k - 3);
1687  if (sub == 4)
1688  cHB->cd(k);
1689  gPad->SetGridy();
1690  gPad->SetGridx();
1691  // gPad->SetLogy();
1692  HistPortBadEventsDepth[sub][k]->Divide(HistPortBadEventsDepth[sub][k], HistNumRateDepth[sub][k], 1, 1, "B");
1693 
1694  if (k == 1)
1695  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 1\b");
1696  if (k == 2)
1697  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 2\b");
1698  if (k == 3)
1699  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 3\b");
1700  if (k == 4)
1701  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 4\b");
1702  HistPortBadEventsDepth[sub][k]->SetXTitle("LS \b");
1703  HistPortBadEventsDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1704  if (MaxLum <= 1000) {
1705  HistPortBadEventsDepth[sub][k]->SetMarkerStyle(20);
1706  HistPortBadEventsDepth[sub][k]->SetMarkerSize(0.5);
1707  HistPortBadEventsDepth[sub][k]->SetMarkerColor(1);
1708  HistPortBadEventsDepth[sub][k]->SetLineColor(0);
1709  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1710  HistPortBadEventsDepth[sub][k]->Draw("P");
1711  } else {
1712  HistPortBadEventsDepth[sub][k]->SetLineColor(1);
1713  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1714  HistPortBadEventsDepth[sub][k]->Draw("L");
1715  }
1716  }
1717  if (sub == 1) {
1718  cHB->Print("HistPortHB.png");
1719  cHB->Clear();
1720  }
1721  if (sub == 2) {
1722  cHE->Print("HistPortHE.png");
1723  cHE->Clear();
1724  }
1725  if (sub == 3) {
1726  cONE->Print("HistPortHO.png");
1727  cONE->Clear();
1728  }
1729  if (sub == 4) {
1730  cHB->Print("HistPortHF.png");
1731  cHB->Clear();
1732  }
1733  } // end sub
1734 
1735  //================================================================================================================================
1736 
1737  //+++++++++++++++++++++++++++++
1738  // Number of bad channels events identified by Cap ID errors third set of histograms
1739  //+++++++++++++++++++++++++++++
1740 
1741  TH1F *HistNBadChsDepth[5][5]; // 1d histogramm for subdet, depth
1742 
1743  HistNBadChsDepth[1][1] = (TH1F *)hfile->Get("h_nbadchannels_depth1_HB");
1744  HistNBadChsDepth[1][2] = (TH1F *)hfile->Get("h_nbadchannels_depth2_HB");
1745  HistNBadChsDepth[2][1] = (TH1F *)hfile->Get("h_nbadchannels_depth1_HE");
1746  HistNBadChsDepth[2][2] = (TH1F *)hfile->Get("h_nbadchannels_depth2_HE");
1747  HistNBadChsDepth[2][3] = (TH1F *)hfile->Get("h_nbadchannels_depth3_HE");
1748  HistNBadChsDepth[3][4] = (TH1F *)hfile->Get("h_nbadchannels_depth4_HO");
1749  HistNBadChsDepth[4][1] = (TH1F *)hfile->Get("h_nbadchannels_depth1_HF");
1750  HistNBadChsDepth[4][2] = (TH1F *)hfile->Get("h_nbadchannels_depth2_HF");
1751 
1752  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1753  if (sub == 1)
1754  cHB->Divide(2, 1);
1755  if (sub == 2)
1756  cHE->Divide(3, 1);
1757  if (sub == 3)
1758  cONE->Divide(1, 1);
1759  if (sub == 4)
1760  cHB->Divide(2, 1);
1761  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1762  if (sub == 1)
1763  cHB->cd(k);
1764  if (sub == 2)
1765  cHE->cd(k);
1766  if (sub == 3)
1767  cONE->cd(k - 3);
1768  if (sub == 4)
1769  cHB->cd(k);
1770  gPad->SetGridy();
1771  gPad->SetGridx();
1772  gPad->SetLogy();
1773 
1774  if (k == 1)
1775  HistNBadChsDepth[sub][k]->SetTitle("Depth 1\b");
1776  if (k == 2)
1777  HistNBadChsDepth[sub][k]->SetTitle("Depth 2\b");
1778  if (k == 3)
1779  HistNBadChsDepth[sub][k]->SetTitle("Depth 3\b");
1780  if (k == 4)
1781  HistNBadChsDepth[sub][k]->SetTitle("Depth 4\b");
1782  HistNBadChsDepth[sub][k]->SetXTitle("Number of bad channels\b");
1783  HistNBadChsDepth[sub][k]->SetYTitle("Number of events\b");
1784  // HistNBadChsDepth[sub][k]->SetMarkerStyle(20);
1785  // HistNBadChsDepth[sub][k]->SetMarkerSize(0.5);
1786  // HistNBadChsDepth[sub][k]->SetMarkerColor(1);
1787  // HistNBadChsDepth[sub][k]->SetLineColor(0);
1788  HistNBadChsDepth[sub][k]->Draw("");
1789  }
1790  if (sub == 1) {
1791  cHB->Print("HistNBadChsHB.png");
1792  cHB->Clear();
1793  }
1794  if (sub == 2) {
1795  cHE->Print("HistNBadChsHE.png");
1796  cHE->Clear();
1797  }
1798  if (sub == 3) {
1799  cONE->Print("HistNBadChsHO.png");
1800  cONE->Clear();
1801  }
1802  if (sub == 4) {
1803  cHB->Print("HistNBadChsHF.png");
1804  cHB->Clear();
1805  }
1806  } // end sub
1807 
1808  //====================================================================== HB :
1809  //====================================================================== HB :
1810  //====================================================================== HB :
1811  // Special test of errors type A and B in HB
1812  // AZ 08.02.2016
1813 
1814  int flagErrAB_HB[2];
1815  flagErrAB_HB[0] = -1;
1816  flagErrAB_HB[1] = -1;
1817  double avedelta_HB = 0.;
1818  int lastLumiBin_HB = -1;
1819  int LSofFirstErrB_HB = -1;
1820  {
1821  const int specCountA = 4;
1822  const int specColors[specCountA] = {1, 2, 3, 4};
1823  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS1_P1", "h_sum0ADCAmplperLS1_P1"},
1824  {"h_sumADCAmplperLS1_P2", "h_sum0ADCAmplperLS1_P2"},
1825  {"h_sumADCAmplperLS1_M1", "h_sum0ADCAmplperLS1_M1"},
1826  {"h_sumADCAmplperLS1_M2", "h_sum0ADCAmplperLS1_M2"}};
1827 
1828  std::vector<TH1F *> hV;
1829  THStack *hs = new THStack("hs", "ADCAmplerLS1");
1830  cHB->Clear();
1831  // cHB->cd();
1832  cHB->Divide(2, 1);
1833  cHB->cd(1);
1834 
1836  for (int i = 0; i < specCountA; i++) {
1837  if (1)
1838  std::cout << "debugger: errA_HB : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
1839  << "\n";
1840  TH1F *h1 = (TH1F *)hfile->Get(hnames[i][0]);
1841  TH1F *h0 = (TH1F *)hfile->Get(hnames[i][1]);
1842  if (!h1 || !h0) {
1843  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
1844  ptext->AddText("Missing histo");
1845  if (!h1) {
1846  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
1847  ptext->AddText(hnames[i][0]);
1848  }
1849  if (!h0) {
1850  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
1851  ptext->AddText(hnames[i][1]);
1852  }
1853  ptext->Draw();
1854  continue;
1855  }
1856  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
1857  hERT1orig->Divide(h1, h0, 1, 1, "B");
1858 
1859  if ((lastLumiBin_HB < 0) && (i == 0)) {
1860  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
1861  if (hERT1orig->GetBinContent(ibin) == 0)
1862  lastLumiBin_HB = ibin;
1863  else
1864  break;
1865  }
1866  lastLumiBin_HB += 3; // show more bins
1867  if (lastLumiBin_HB >= hERT1orig->GetNbinsX())
1868  lastLumiBin_HB = -1;
1869  }
1870  TH1F *hERT1 = NULL;
1871  if (lastLumiBin_HB > 1) {
1872  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HB)) {
1873  std::cout << "code failed" << std::endl;
1874  gSystem->Exit(1);
1875  }
1876  } else
1877  hERT1 = hERT1orig;
1878 
1879  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HB: black-P1, red-P2,green-M1,blue-M2");
1880  hV.push_back(hERT1);
1881  hERT1->SetMarkerStyle(20);
1882  hERT1->SetMarkerSize(0.4);
1883  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HB P1 - iLS \b");
1884  hERT1->SetMarkerColor(specColors[i]);
1885  hERT1->SetLineColor(0);
1886  hs->Add(hERT1);
1887  delete h1;
1888  delete h0;
1889  if (hERT1 != hERT1orig)
1890  delete hERT1orig;
1891  }
1892  hs->Draw("LPE1 nostack");
1893  cHB->Update(); // activate the axes
1894  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
1895  hs->Draw("LPE1 nostack");
1896  gPad->SetGridy();
1898 
1899  // AZ corrections 08.02.2016
1900  cHB->cd(2);
1901  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
1902 
1903  if (int(hV.size()) == specCountA) {
1904  flagErrAB_HB[0] = 0; // If we have the expected number of histograms, set the flag
1905  double sumdelta = 0.;
1906  int nnndelta = 0;
1907  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
1908  double delta = 0.;
1909  double maxdelta = 0.;
1910  for (unsigned int i = 0; i < hV.size(); i++) {
1911  const TH1F *hi = hV[i];
1912  for (unsigned int j = 1; j < hV.size(); j++) {
1913  const TH1F *hj = hV[j];
1914  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
1915  if (delta > maxdelta)
1916  maxdelta = delta;
1917  } //for
1918  } //for
1919  if (maxdelta > 0.) {
1920  diff->Fill(maxdelta);
1921  sumdelta += maxdelta;
1922  nnndelta++;
1923  }
1924  } //for ibin
1925  // avedelta_HB = sumdelta/hV[0]->GetNbinsX();
1926  avedelta_HB = sumdelta / nnndelta;
1927  std::cout << "******************>>>>>> ErrA_HB: avedelta_HB = " << avedelta_HB << std::endl;
1928  if (avedelta_HB > 0.24 || (avedelta_HB < 0.14 && avedelta_HB > 0.)) {
1929  flagErrAB_HB[0] = 1;
1930  } //if
1931  } //hV.size
1932  diff->SetMarkerStyle(20);
1933  diff->SetMarkerSize(0.8);
1934  diff->SetXTitle("max difference \b");
1935  diff->SetMarkerColor(2);
1936  diff->SetLineColor(0);
1937  gPad->SetGridx();
1938  gPad->SetLogy();
1939  diff->Draw("Error");
1941  cHB->Update();
1942  cHB->Print("HistErrA_HB.png");
1943  cHB->Clear();
1945 
1946  // clean-up
1947  if (diff)
1948  delete diff;
1949  for (unsigned int i = 0; i < hV.size(); i++)
1950  delete hV[i];
1951  } // ErrorA in HB
1952 
1954 
1955  { // errors type B
1956  const int specCountB = 4;
1957  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS1", "h_2D0sumErrorBLS1"},
1958  {"h_sumErrorBperLS1", "h_sum0ErrorBperLS1"},
1959  {"h_2DsumErrorBLS2", "h_2D0sumErrorBLS2"},
1960  {"h_sumErrorBperLS2", "h_sum0ErrorBperLS2"}};
1961 
1962  for (int depth = 1; depth <= 2; depth++) {
1963  cHB->Clear();
1964  cHB->Divide(2, 1);
1965  cHB->cd(1);
1966 
1967  TH1F *hRate2orig = NULL;
1968  TH2F *h2Cefz6 = NULL;
1969  TString hname1 = hnames[2 * depth - 2][0];
1970  TString hname0 = hnames[2 * depth - 2][1];
1971  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
1972  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
1973  if (1)
1974  std::cout << "debugger: errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
1975  if (!twod1 || !twod0) {
1976  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
1977  ptext->AddText("Missing histos");
1978  if (!twod1) {
1979  std::cout << "\tfailed to get " << hname1 << "\n";
1980  ptext->AddText(hname1);
1981  }
1982  if (!twod0) {
1983  std::cout << "\tfailed to get " << hname0 << "\n";
1984  ptext->AddText(hname0);
1985  }
1986  ptext->Draw();
1987  } else {
1988  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
1989  h2Cefz6->SetTitle(Form("HB Depth %d \b", depth));
1990  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
1991 
1992  gPad->SetGridy();
1993  gPad->SetGridx();
1994  gPad->SetLogz();
1995  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
1996  h2Cefz6->SetMarkerStyle(20);
1997  h2Cefz6->SetMarkerSize(0.4);
1998  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
1999  h2Cefz6->SetXTitle("#eta \b");
2000  h2Cefz6->SetYTitle("#phi \b");
2001  h2Cefz6->SetZTitle(Form("<ErrorB> - HB Depth%d \b", depth));
2002  h2Cefz6->SetMarkerColor(2);
2003  h2Cefz6->SetLineColor(2);
2004  h2Cefz6->Draw("COLZ");
2005 
2006  delete twod1;
2007  delete twod0;
2008  } // histos ok
2009 
2010  cHB->cd(2);
2011  hname1 = hnames[2 * depth - 1][0];
2012  hname0 = hnames[2 * depth - 1][1];
2013  TH1F *h1 = (TH1F *)hfile->Get(hname1);
2014  TH1F *h0 = (TH1F *)hfile->Get(hname0);
2015  if (1)
2016  std::cout << "errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2017  if (!h1 || !h0) {
2018  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2019  ptext->AddText("Missing histo");
2020  if (!h1) {
2021  std::cout << "\tfailed to get " << hname1 << "\n";
2022  ptext->AddText(hname1);
2023  }
2024  if (!h0) {
2025  std::cout << "\tfailed to get " << hname0 << "\n";
2026  ptext->AddText(hname0);
2027  }
2028  ptext->Draw();
2029  } else {
2030  gPad->SetGridx();
2031  gPad->SetGridy();
2032  // gPad->SetLogy();
2033  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2034  hRate2orig->Divide(h1, h0, 1, 1, "B");
2035 
2036  TH1F *hRate2 = NULL;
2037  if (lastLumiBin_HB > 1) {
2038  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HB)) {
2039  std::cout << "code failed" << std::endl;
2040  gSystem->Exit(1);
2041  }
2042  } else
2043  hRate2 = hRate2orig;
2044 
2045  hRate2->SetTitle(Form("Depth %d \b", depth));
2046  hRate2->SetMarkerStyle(20);
2047  hRate2->SetMarkerSize(0.8);
2048  // hRate2->GetZaxis()->SetLabelSize(0.04);
2049  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HB depth%d - iLS \b", depth));
2050  hRate2->SetMarkerColor(2);
2051  hRate2->SetLineColor(0);
2052  hRate2->Draw("Error");
2053 
2054  if (LSofFirstErrB_HB == -1) {
2055  int nx = hRate2->GetXaxis()->GetNbins();
2056  for (int i = 1; i <= nx; i++) {
2057  double ccc1 = hRate2->GetBinContent(i);
2058  if (ccc1 > 0.) {
2059  cout << "****************>>>>>>>>>>> ErrB_HB bad LS start at iLS = " << i << " with rate = " << ccc1
2060  << endl;
2061  LSofFirstErrB_HB = i;
2062  break;
2063  }
2064  }
2065  }
2066 
2067  delete h1;
2068  delete h0;
2069  if (hRate2 != hRate2orig) {
2070  delete hRate2orig;
2071  hRate2orig = hRate2;
2072  }
2073  }
2074 
2075  cHB->Update();
2076  cHB->Print(Form("HistErrB_HB_%d.png", depth));
2077  cHB->Clear();
2078  if (h2Cefz6)
2079  delete h2Cefz6;
2080  if (hRate2orig)
2081  delete hRate2orig;
2082  }
2083  } // ErrorsB in HB
2084 
2085  //====================================================================== HE :
2086  //====================================================================== HE :
2087  //====================================================================== HE :
2088  // Special test of errors type A and B in HE
2089  // AZ 08.02.2016
2090 
2091  int flagErrAB_HE[2];
2092  flagErrAB_HE[0] = -1;
2093  flagErrAB_HE[1] = -1;
2094  double avedelta_HE = 0.;
2095  int lastLumiBin_HE = -1;
2096  int LSofFirstErrB_HE = -1;
2097  {
2098  const int specCountA = 4;
2099  const int specColors[specCountA] = {1, 2, 3, 4};
2100  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS3_P1", "h_sum0ADCAmplperLS3_P1"},
2101  {"h_sumADCAmplperLS3_P2", "h_sum0ADCAmplperLS3_P2"},
2102  {"h_sumADCAmplperLS3_M1", "h_sum0ADCAmplperLS3_M1"},
2103  {"h_sumADCAmplperLS3_M2", "h_sum0ADCAmplperLS3_M2"}};
2104 
2105  std::vector<TH1F *> hV;
2106  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2107  cHB->Clear();
2108  // cHB->cd();
2109  cHB->Divide(2, 1);
2110  cHB->cd(1);
2111 
2113  for (int i = 0; i < specCountA; i++) {
2114  if (1)
2115  std::cout << "debugger: errA_HE : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2116  << "\n";
2117  TH1F *h1 = (TH1F *)hfile->Get(hnames[i][0]);
2118  TH1F *h0 = (TH1F *)hfile->Get(hnames[i][1]);
2119  if (!h1 || !h0) {
2120  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2121  ptext->AddText("Missing histo");
2122  if (!h1) {
2123  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2124  ptext->AddText(hnames[i][0]);
2125  }
2126  if (!h0) {
2127  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2128  ptext->AddText(hnames[i][1]);
2129  }
2130  ptext->Draw();
2131  continue;
2132  }
2133  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2134  hERT1orig->Divide(h1, h0, 1, 1, "B");
2135 
2136  if ((lastLumiBin_HE < 0) && (i == 0)) {
2137  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2138  if (hERT1orig->GetBinContent(ibin) == 0)
2139  lastLumiBin_HE = ibin;
2140  else
2141  break;
2142  }
2143  lastLumiBin_HE += 3; // show more bins
2144  if (lastLumiBin_HE >= hERT1orig->GetNbinsX())
2145  lastLumiBin_HE = -1;
2146  }
2147  TH1F *hERT1 = NULL;
2148  if (lastLumiBin_HE > 1) {
2149  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HE)) {
2150  std::cout << "code failed" << std::endl;
2151  gSystem->Exit(1);
2152  }
2153  } else
2154  hERT1 = hERT1orig;
2155 
2156  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HE: black-P1, red-P2,green-M1,blue-M2");
2157  hV.push_back(hERT1);
2158  hERT1->SetMarkerStyle(20);
2159  hERT1->SetMarkerSize(0.4);
2160  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HE P1 - iLS \b");
2161  hERT1->SetMarkerColor(specColors[i]);
2162  hERT1->SetLineColor(0);
2163  hs->Add(hERT1);
2164  delete h1;
2165  delete h0;
2166  if (hERT1 != hERT1orig)
2167  delete hERT1orig;
2168  }
2169  hs->Draw("LPE1 nostack");
2170  cHB->Update(); // activate the axes
2171  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2172  hs->Draw("LPE1 nostack");
2173  gPad->SetGridy();
2175 
2176  // AZ corrections 08.02.2016
2177  cHB->cd(2);
2178  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2179 
2180  if (int(hV.size()) == specCountA) {
2181  flagErrAB_HE[0] = 0; // If we have the expected number of histograms, set the flag
2182  double sumdelta = 0.;
2183  int nnndelta = 0;
2184  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2185  double delta = 0.;
2186  double maxdelta = 0.;
2187  for (unsigned int i = 0; i < hV.size(); i++) {
2188  const TH1F *hi = hV[i];
2189  for (unsigned int j = 1; j < hV.size(); j++) {
2190  const TH1F *hj = hV[j];
2191  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2192  if (delta > maxdelta)
2193  maxdelta = delta;
2194  } //for
2195  } //for
2196  if (maxdelta > 0.) {
2197  diff->Fill(maxdelta);
2198  sumdelta += maxdelta;
2199  nnndelta++;
2200  }
2201  } //for ibin
2202  // avedelta_HE = sumdelta/hV[0]->GetNbinsX();
2203  avedelta_HE = sumdelta / nnndelta;
2204  std::cout << "******************>>>>>> ErrA_HE: avedelta_HE = " << avedelta_HE << std::endl;
2205  if (avedelta_HE > 1.1 || (avedelta_HE < 0.5 && avedelta_HE > 0.)) {
2206  flagErrAB_HE[0] = 1;
2207  } //if
2208  } //hV.size
2209  diff->SetMarkerStyle(20);
2210  diff->SetMarkerSize(0.8);
2211  diff->SetXTitle("max difference \b");
2212  diff->SetMarkerColor(2);
2213  diff->SetLineColor(0);
2214  gPad->SetGridx();
2215  gPad->SetLogy();
2216  diff->Draw("Error");
2218  cHB->Update();
2219  cHB->Print("HistErrA_HE.png");
2220  cHB->Clear();
2222 
2223  // clean-up
2224  if (diff)
2225  delete diff;
2226  for (unsigned int i = 0; i < hV.size(); i++)
2227  delete hV[i];
2228  } // ErrorA in HE
2229 
2231 
2232  { // errors type B
2233  const int specCountB = 6;
2234  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS3", "h_2D0sumErrorBLS3"},
2235  {"h_sumErrorBperLS3", "h_sum0ErrorBperLS3"},
2236  {"h_2DsumErrorBLS4", "h_2D0sumErrorBLS4"},
2237  {"h_sumErrorBperLS4", "h_sum0ErrorBperLS4"},
2238  {"h_2DsumErrorBLS5", "h_2D0sumErrorBLS5"},
2239  {"h_sumErrorBperLS5", "h_sum0ErrorBperLS5"}};
2240 
2241  for (int depth = 1; depth <= 3; depth++) {
2242  cHB->Clear();
2243  cHB->Divide(2, 1);
2244  cHB->cd(1);
2245 
2246  TH1F *hRate2orig = NULL;
2247  TH2F *h2Cefz6 = NULL;
2248  TString hname1 = hnames[2 * depth - 2][0];
2249  TString hname0 = hnames[2 * depth - 2][1];
2250  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
2251  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
2252  if (1)
2253  std::cout << "debugger: errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2254  if (!twod1 || !twod0) {
2255  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2256  ptext->AddText("Missing histos");
2257  if (!twod1) {
2258  std::cout << "\tfailed to get " << hname1 << "\n";
2259  ptext->AddText(hname1);
2260  }
2261  if (!twod0) {
2262  std::cout << "\tfailed to get " << hname0 << "\n";
2263  ptext->AddText(hname0);
2264  }
2265  ptext->Draw();
2266  } else {
2267  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2268  h2Cefz6->SetTitle(Form("HE Depth %d \b", depth));
2269  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2270 
2271  gPad->SetGridy();
2272  gPad->SetGridx();
2273  gPad->SetLogz();
2274  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2275  h2Cefz6->SetMarkerStyle(20);
2276  h2Cefz6->SetMarkerSize(0.4);
2277  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2278  h2Cefz6->SetXTitle("#eta \b");
2279  h2Cefz6->SetYTitle("#phi \b");
2280  h2Cefz6->SetZTitle(Form("<ErrorB> - HE Depth%d \b", depth));
2281  h2Cefz6->SetMarkerColor(2);
2282  h2Cefz6->SetLineColor(2);
2283  h2Cefz6->Draw("COLZ");
2284 
2285  delete twod1;
2286  delete twod0;
2287  } // histos ok
2288 
2289  cHB->cd(2);
2290  hname1 = hnames[2 * depth - 1][0];
2291  hname0 = hnames[2 * depth - 1][1];
2292  TH1F *h1 = (TH1F *)hfile->Get(hname1);
2293  TH1F *h0 = (TH1F *)hfile->Get(hname0);
2294  if (1)
2295  std::cout << "errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2296  if (!h1 || !h0) {
2297  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2298  ptext->AddText("Missing histo");
2299  if (!h1) {
2300  std::cout << "\tfailed to get " << hname1 << "\n";
2301  ptext->AddText(hname1);
2302  }
2303  if (!h0) {
2304  std::cout << "\tfailed to get " << hname0 << "\n";
2305  ptext->AddText(hname0);
2306  }
2307  ptext->Draw();
2308  } else {
2309  gPad->SetGridx();
2310  gPad->SetGridy();
2311  // gPad->SetLogy();
2312  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2313  hRate2orig->Divide(h1, h0, 1, 1, "B");
2314 
2315  TH1F *hRate2 = NULL;
2316  if (lastLumiBin_HE > 1) {
2317  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HE)) {
2318  std::cout << "code failed" << std::endl;
2319  gSystem->Exit(1);
2320  }
2321  } else
2322  hRate2 = hRate2orig;
2323 
2324  hRate2->SetTitle(Form("Depth %d \b", depth));
2325  hRate2->SetMarkerStyle(20);
2326  hRate2->SetMarkerSize(0.8);
2327  // hRate2->GetZaxis()->SetLabelSize(0.04);
2328  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HE depth%d - iLS \b", depth));
2329  hRate2->SetMarkerColor(2);
2330  hRate2->SetLineColor(0);
2331  hRate2->Draw("Error");
2332 
2333  if (LSofFirstErrB_HE == -1) {
2334  int nx = hRate2->GetXaxis()->GetNbins();
2335  for (int i = 1; i <= nx; i++) {
2336  double ccc1 = hRate2->GetBinContent(i);
2337  if (ccc1 > 0.) {
2338  cout << "****************>>>>>>>>>>> ErrB_HE bad LS start at iLS = " << i << " with rate = " << ccc1
2339  << endl;
2340  LSofFirstErrB_HE = i;
2341  break;
2342  }
2343  }
2344  }
2345 
2346  delete h1;
2347  delete h0;
2348  if (hRate2 != hRate2orig) {
2349  delete hRate2orig;
2350  hRate2orig = hRate2;
2351  }
2352  }
2353 
2354  cHB->Update();
2355  cHB->Print(Form("HistErrB_HE_%d.png", depth));
2356  cHB->Clear();
2357  if (h2Cefz6)
2358  delete h2Cefz6;
2359  if (hRate2orig)
2360  delete hRate2orig;
2361  }
2362  } // ErrorsB in HE
2363 
2364  //====================================================================== HO :
2365  //====================================================================== HO :
2366  //====================================================================== HO :
2367  // Special test of errors type A and B in HO
2368  // AZ 08.02.2016
2369 
2370  int flagErrAB_HO[2];
2371  flagErrAB_HO[0] = -1;
2372  flagErrAB_HO[1] = -1;
2373  double avedelta_HO = 0.;
2374  int lastLumiBin_HO = -1;
2375  int LSofFirstErrB_HO = -1;
2376  {
2377  const int specCountA = 4;
2378  const int specColors[specCountA] = {1, 2, 3, 4};
2379  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS8_P1", "h_sum0ADCAmplperLS8_P1"},
2380  {"h_sumADCAmplperLS8_P2", "h_sum0ADCAmplperLS8_P2"},
2381  {"h_sumADCAmplperLS8_M1", "h_sum0ADCAmplperLS8_M1"},
2382  {"h_sumADCAmplperLS8_M2", "h_sum0ADCAmplperLS8_M2"}};
2383 
2384  std::vector<TH1F *> hV;
2385  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2386  cHB->Clear();
2387  // cHB->cd();
2388  cHB->Divide(2, 1);
2389  cHB->cd(1);
2390 
2392  for (int i = 0; i < specCountA; i++) {
2393  if (1)
2394  std::cout << "debugger: errA_HO : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2395  << "\n";
2396  TH1F *h1 = (TH1F *)hfile->Get(hnames[i][0]);
2397  TH1F *h0 = (TH1F *)hfile->Get(hnames[i][1]);
2398  if (!h1 || !h0) {
2399  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2400  ptext->AddText("Missing histo");
2401  if (!h1) {
2402  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2403  ptext->AddText(hnames[i][0]);
2404  }
2405  if (!h0) {
2406  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2407  ptext->AddText(hnames[i][1]);
2408  }
2409  ptext->Draw();
2410  continue;
2411  }
2412  TH1F *hoRT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2413  hoRT1orig->Divide(h1, h0, 1, 1, "B");
2414 
2415  if ((lastLumiBin_HO < 0) && (i == 0)) {
2416  for (int ibin = hoRT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2417  if (hoRT1orig->GetBinContent(ibin) == 0)
2418  lastLumiBin_HO = ibin;
2419  else
2420  break;
2421  }
2422  lastLumiBin_HO += 3; // show more bins
2423  if (lastLumiBin_HO >= hoRT1orig->GetNbinsX())
2424  lastLumiBin_HO = -1;
2425  }
2426  TH1F *hoRT1 = NULL;
2427  if (lastLumiBin_HO > 1) {
2428  if (!copyContents(&hoRT1, Form("ERT1_%d", i), "", hoRT1orig, lastLumiBin_HO)) {
2429  std::cout << "code failed" << std::endl;
2430  gSystem->Exit(1);
2431  }
2432  } else
2433  hoRT1 = hoRT1orig;
2434 
2435  hoRT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HO: black-P1, red-P2,green-M1,blue-M2");
2436  hV.push_back(hoRT1);
2437  hoRT1->SetMarkerStyle(20);
2438  hoRT1->SetMarkerSize(0.4);
2439  hoRT1->SetXTitle("<A>(ev.in LS & ch.) - HO P1 - iLS \b");
2440  hoRT1->SetMarkerColor(specColors[i]);
2441  hoRT1->SetLineColor(0);
2442  hs->Add(hoRT1);
2443  delete h1;
2444  delete h0;
2445  if (hoRT1 != hoRT1orig)
2446  delete hoRT1orig;
2447  }
2448  hs->Draw("LPE1 nostack");
2449  cHB->Update(); // activate tho axes
2450  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2451  hs->Draw("LPE1 nostack");
2452  gPad->SetGridy();
2454 
2455  // AZ corrections 08.02.2016
2456  cHB->cd(2);
2457  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2458 
2459  if (int(hV.size()) == specCountA) {
2460  flagErrAB_HO[0] = 0; // If we have tho expected number of histograms, set tho flag
2461  double sumdelta = 0.;
2462  int nnndelta = 0;
2463  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2464  double delta = 0.;
2465  double maxdelta = 0.;
2466  for (unsigned int i = 0; i < hV.size(); i++) {
2467  const TH1F *hi = hV[i];
2468  for (unsigned int j = 1; j < hV.size(); j++) {
2469  const TH1F *hj = hV[j];
2470  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2471  if (delta > maxdelta)
2472  maxdelta = delta;
2473  } //for
2474  } //for
2475  if (maxdelta > 0.) {
2476  diff->Fill(maxdelta);
2477  sumdelta += maxdelta;
2478  nnndelta++;
2479  }
2480  } //for ibin
2481  // avedelta_HO = sumdelta/hV[0]->GetNbinsX();
2482  avedelta_HO = sumdelta / nnndelta;
2483  std::cout << "******************>>>>>> ErrA_HO: avedelta_HO = " << avedelta_HO << std::endl;
2484  if (avedelta_HO > 0.8 || (avedelta_HO < 0.2 && avedelta_HO > 0.)) {
2485  flagErrAB_HO[0] = 1;
2486  } //if
2487  } //hV.size
2488  diff->SetMarkerStyle(20);
2489  diff->SetMarkerSize(0.8);
2490  diff->SetXTitle("max difference \b");
2491  diff->SetMarkerColor(2);
2492  diff->SetLineColor(0);
2493  gPad->SetGridx();
2494  gPad->SetLogy();
2495  diff->Draw("Error");
2497  cHB->Update();
2498  cHB->Print("HistErrA_HO.png");
2499  cHB->Clear();
2501 
2502  // clean-up
2503  if (diff)
2504  delete diff;
2505  for (unsigned int i = 0; i < hV.size(); i++)
2506  delete hV[i];
2507  } // ErrorA in HO
2508 
2510 
2511  { // errors type B
2512  const int specCountB = 2;
2513  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS8", "h_2D0sumErrorBLS8"},
2514  {"h_sumErrorBperLS8", "h_sum0ErrorBperLS8"}};
2515 
2516  for (int depth = 4; depth <= 4; depth++) {
2517  cHB->Clear();
2518  cHB->Divide(2, 1);
2519  cHB->cd(1);
2520 
2521  TH1F *hRate2orig = NULL;
2522  TH2F *h2Cefz6 = NULL;
2523  TString hname1 = hnames[2 * depth - 8][0];
2524  TString hname0 = hnames[2 * depth - 8][1];
2525  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
2526  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
2527  if (1)
2528  std::cout << "debugger: errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2529  if (!twod1 || !twod0) {
2530  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2531  ptext->AddText("Missing histos");
2532  if (!twod1) {
2533  std::cout << "\tfailed to get " << hname1 << "\n";
2534  ptext->AddText(hname1);
2535  }
2536  if (!twod0) {
2537  std::cout << "\tfailed to get " << hname0 << "\n";
2538  ptext->AddText(hname0);
2539  }
2540  ptext->Draw();
2541  } else {
2542  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2543  h2Cefz6->SetTitle(Form("HO Depth %d \b", depth));
2544  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2545 
2546  gPad->SetGridy();
2547  gPad->SetGridx();
2548  gPad->SetLogz();
2549  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2550  h2Cefz6->SetMarkerStyle(20);
2551  h2Cefz6->SetMarkerSize(0.4);
2552  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2553  h2Cefz6->SetXTitle("#eta \b");
2554  h2Cefz6->SetYTitle("#phi \b");
2555  h2Cefz6->SetZTitle(Form("<ErrorB> - HO Depth%d \b", depth));
2556  h2Cefz6->SetMarkerColor(2);
2557  h2Cefz6->SetLineColor(2);
2558  h2Cefz6->Draw("COLZ");
2559 
2560  delete twod1;
2561  delete twod0;
2562  } // histos ok
2563 
2564  cHB->cd(2);
2565  hname1 = hnames[2 * depth - 7][0];
2566  hname0 = hnames[2 * depth - 7][1];
2567  TH1F *h1 = (TH1F *)hfile->Get(hname1);
2568  TH1F *h0 = (TH1F *)hfile->Get(hname0);
2569  if (1)
2570  std::cout << "errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2571  if (!h1 || !h0) {
2572  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2573  ptext->AddText("Missing histo");
2574  if (!h1) {
2575  std::cout << "\tfailed to get " << hname1 << "\n";
2576  ptext->AddText(hname1);
2577  }
2578  if (!h0) {
2579  std::cout << "\tfailed to get " << hname0 << "\n";
2580  ptext->AddText(hname0);
2581  }
2582  ptext->Draw();
2583  } else {
2584  gPad->SetGridx();
2585  gPad->SetGridy();
2586  // gPad->SetLogy();
2587  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2588  hRate2orig->Divide(h1, h0, 1, 1, "B");
2589 
2590  TH1F *hRate2 = NULL;
2591  if (lastLumiBin_HO > 1) {
2592  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HO)) {
2593  std::cout << "code failed" << std::endl;
2594  gSystem->Exit(1);
2595  }
2596  } else
2597  hRate2 = hRate2orig;
2598 
2599  hRate2->SetTitle(Form("Depth %d \b", depth));
2600  hRate2->SetMarkerStyle(20);
2601  hRate2->SetMarkerSize(0.8);
2602  // hRate2->GetZaxis()->SetLabelSize(0.04);
2603  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HO depth%d - iLS \b", depth));
2604  hRate2->SetMarkerColor(2);
2605  hRate2->SetLineColor(0);
2606  hRate2->Draw("Error");
2607 
2608  if (LSofFirstErrB_HO == -1) {
2609  int nx = hRate2->GetXaxis()->GetNbins();
2610  for (int i = 1; i <= nx; i++) {
2611  double ccc1 = hRate2->GetBinContent(i);
2612  if (ccc1 > 0.) {
2613  cout << "****************>>>>>>>>>>> ErrB_HO bad LS start at iLS = " << i << " with rate = " << ccc1
2614  << endl;
2615  LSofFirstErrB_HO = i;
2616  break;
2617  }
2618  }
2619  }
2620 
2621  delete h1;
2622  delete h0;
2623  if (hRate2 != hRate2orig) {
2624  delete hRate2orig;
2625  hRate2orig = hRate2;
2626  }
2627  }
2628 
2629  cHB->Update();
2630  cHB->Print(Form("HistErrB_HO_%d.png", depth));
2631  cHB->Clear();
2632  if (h2Cefz6)
2633  delete h2Cefz6;
2634  if (hRate2orig)
2635  delete hRate2orig;
2636  }
2637  } // ErrorsB in HO
2638 
2639  //====================================================================== done by Andrius for HF:
2640  //====================================================================== done by Andrius for HF:
2641  //====================================================================== done by Andrius for HF:
2642  // Special test of errors type A and B in HF
2643 
2644  int flagErrAB_HF[2];
2645  flagErrAB_HF[0] = -1;
2646  flagErrAB_HF[1] = -1;
2647  double avedelta_HF = 0.;
2648  int lastLumiBin_HF = -1;
2649  int LSofFirstErrB_HF = -1;
2650  {
2651  const int specCountA = 4;
2652  const int specColors[specCountA] = {1, 2, 3, 4};
2653  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS6_P1", "h_sum0ADCAmplperLS6_P1"},
2654  {"h_sumADCAmplperLS6_P2", "h_sum0ADCAmplperLS6_P2"},
2655  {"h_sumADCAmplperLS6_M1", "h_sum0ADCAmplperLS6_M1"},
2656  {"h_sumADCAmplperLS6_M2", "h_sum0ADCAmplperLS6_M2"}};
2657 
2658  std::vector<TH1F *> hV;
2659  THStack *hs = new THStack("hs", "ADCAmplerLS6");
2660  cHB->Clear();
2661  // cHB->cd();
2662  cHB->Divide(2, 1);
2663  cHB->cd(1);
2664 
2666  for (int i = 0; i < specCountA; i++) {
2667  if (1)
2668  std::cout << "debugger: errA_HF : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2669  << "\n";
2670  TH1F *h1 = (TH1F *)hfile->Get(hnames[i][0]);
2671  TH1F *h0 = (TH1F *)hfile->Get(hnames[i][1]);
2672  if (!h1 || !h0) {
2673  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2674  ptext->AddText("Missing histo");
2675  if (!h1) {
2676  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2677  ptext->AddText(hnames[i][0]);
2678  }
2679  if (!h0) {
2680  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2681  ptext->AddText(hnames[i][1]);
2682  }
2683  ptext->Draw();
2684  continue;
2685  }
2686  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2687  hERT1orig->Divide(h1, h0, 1, 1, "B");
2688 
2689  if ((lastLumiBin_HF < 0) && (i == 0)) {
2690  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2691  if (hERT1orig->GetBinContent(ibin) == 0)
2692  lastLumiBin_HF = ibin;
2693  else
2694  break;
2695  }
2696  lastLumiBin_HF += 3; // show more bins
2697  if (lastLumiBin_HF >= hERT1orig->GetNbinsX())
2698  lastLumiBin_HF = -1;
2699  }
2700  TH1F *hERT1 = NULL;
2701  if (lastLumiBin_HF > 1) {
2702  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HF)) {
2703  std::cout << "code failed" << std::endl;
2704  gSystem->Exit(1);
2705  }
2706  } else
2707  hERT1 = hERT1orig;
2708 
2709  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HF: black-P1, red-P2,green-M1,blue-M2");
2710  hV.push_back(hERT1);
2711  hERT1->SetMarkerStyle(20);
2712  hERT1->SetMarkerSize(0.4);
2713  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HF P1 - iLS \b");
2714  hERT1->SetMarkerColor(specColors[i]);
2715  hERT1->SetLineColor(0);
2716  hs->Add(hERT1);
2717  delete h1;
2718  delete h0;
2719  if (hERT1 != hERT1orig)
2720  delete hERT1orig;
2721  }
2722  hs->Draw("LPE1 nostack");
2723  cHB->Update(); // activate the axes
2724  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2725  hs->Draw("LPE1 nostack");
2726  gPad->SetGridy();
2728 
2729  // AZ corrections 04.02.2016
2730  cHB->cd(2);
2731  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2732 
2733  if (int(hV.size()) == specCountA) {
2734  flagErrAB_HF[0] = 0; // If we have the expected number of histograms, set the flag
2735  double sumdelta = 0.;
2736  int nnndelta = 0;
2737  std::cout << "******** GetNbinsX = " << hV[0]->GetNbinsX() << std::endl;
2738  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2739  double delta = 0.;
2740  double maxdelta = 0.;
2741  for (unsigned int i = 0; i < hV.size(); i++) {
2742  const TH1F *hi = hV[i];
2743  for (unsigned int j = 1; j < hV.size(); j++) {
2744  const TH1F *hj = hV[j];
2745  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2746  if (delta > maxdelta)
2747  maxdelta = delta;
2748  } //for
2749  } //for
2750  // std::cout << "***** ibin = " << ibin << " nnndelta= " << nnndelta << " maxdelta= " << maxdelta <<std::endl;
2751  if (maxdelta > 0.) {
2752  diff->Fill(maxdelta);
2753  sumdelta += maxdelta;
2754  nnndelta++;
2755  }
2756  } //for ibin
2757  // avedelta_HF = sumdelta/hV[0]->GetNbinsX();
2758  avedelta_HF = sumdelta / nnndelta;
2759  // std::cout << "******************>>>>>> ErrA_HF: avedelta_HF = " << avedelta_HF << " Npoints for comparison= " << nnndelta <<std::endl;
2760  if (avedelta_HF > 2.4 || (avedelta_HF < 0.8 && avedelta_HF > 0.)) {
2761  flagErrAB_HF[0] = 1;
2762  } //if
2763  } //hV.size
2764  diff->SetMarkerStyle(20);
2765  diff->SetMarkerSize(0.8);
2766  diff->SetXTitle("max difference \b");
2767  diff->SetMarkerColor(2);
2768  diff->SetLineColor(0);
2769  gPad->SetGridx();
2770  gPad->SetLogy();
2771  diff->Draw("Error");
2773  cHB->Update();
2774  cHB->Print("HistErrA_HF.png");
2775  cHB->Clear();
2777  // clean-up
2778  if (diff)
2779  delete diff;
2780  for (unsigned int i = 0; i < hV.size(); i++)
2781  delete hV[i];
2782  } // ErrorA in HF
2785  { // errors type B
2786  const int specCountB = 4;
2787  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS6", "h_2D0sumErrorBLS6"},
2788  {"h_sumErrorBperLS6", "h_sum0ErrorBperLS6"},
2789  {"h_2DsumErrorBLS7", "h_2D0sumErrorBLS7"},
2790  {"h_sumErrorBperLS7", "h_sum0ErrorBperLS7"}};
2791 
2792  for (int depth = 1; depth <= 2; depth++) {
2793  cHB->Clear();
2794  cHB->Divide(2, 1);
2795  cHB->cd(1);
2796  TH1F *hRate2orig = NULL;
2797  TH2F *h2Cefz6 = NULL;
2798  TString hname1 = hnames[2 * depth - 2][0];
2799  TString hname0 = hnames[2 * depth - 2][1];
2800  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
2801  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
2802  if (1)
2803  std::cout << "debugger: errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2804  if (!twod1 || !twod0) {
2805  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2806  ptext->AddText("Missing histos");
2807  if (!twod1) {
2808  std::cout << "\tfailed to get " << hname1 << "\n";
2809  ptext->AddText(hname1);
2810  }
2811  if (!twod0) {
2812  std::cout << "\tfailed to get " << hname0 << "\n";
2813  ptext->AddText(hname0);
2814  }
2815  ptext->Draw();
2816  } else {
2817  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2818  h2Cefz6->SetTitle(Form("HF Depth %d \b", depth));
2819  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2820 
2821  gPad->SetGridy();
2822  gPad->SetGridx();
2823  gPad->SetLogz();
2824  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2825  h2Cefz6->SetMarkerStyle(20);
2826  h2Cefz6->SetMarkerSize(0.4);
2827  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2828  h2Cefz6->SetXTitle("#eta \b");
2829  h2Cefz6->SetYTitle("#phi \b");
2830  h2Cefz6->SetZTitle(Form("<ErrorB> - HF Depth%d \b", depth));
2831  h2Cefz6->SetMarkerColor(2);
2832  h2Cefz6->SetLineColor(2);
2833  h2Cefz6->Draw("COLZ");
2834  delete twod1;
2835  delete twod0;
2836  } // histos ok
2837  cHB->cd(2);
2838  hname1 = hnames[2 * depth - 1][0];
2839  hname0 = hnames[2 * depth - 1][1];
2840  TH1F *h1 = (TH1F *)hfile->Get(hname1);
2841  TH1F *h0 = (TH1F *)hfile->Get(hname0);
2842  if (1)
2843  std::cout << "errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2844  if (!h1 || !h0) {
2845  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2846  ptext->AddText("Missing histo");
2847  if (!h1) {
2848  std::cout << "\tfailed to get " << hname1 << "\n";
2849  ptext->AddText(hname1);
2850  }
2851  if (!h0) {
2852  std::cout << "\tfailed to get " << hname0 << "\n";
2853  ptext->AddText(hname0);
2854  }
2855  ptext->Draw();
2856  } else {
2857  gPad->SetGridx();
2858  gPad->SetGridy();
2859  // gPad->SetLogy();
2860  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2861  hRate2orig->Divide(h1, h0, 1, 1, "B");
2862 
2863  TH1F *hRate2 = NULL;
2864  if (lastLumiBin_HF > 1) {
2865  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HF)) {
2866  std::cout << "code failed" << std::endl;
2867  gSystem->Exit(1);
2868  }
2869  } else
2870  hRate2 = hRate2orig;
2871  hRate2->SetTitle(Form("Depth %d \b", depth));
2872  hRate2->SetMarkerStyle(20);
2873  hRate2->SetMarkerSize(0.8);
2874  // hRate2->GetZaxis()->SetLabelSize(0.04);
2875  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HF depth%d - iLS \b", depth));
2876  hRate2->SetMarkerColor(2);
2877  hRate2->SetLineColor(0);
2878  hRate2->Draw("Error");
2879  if (LSofFirstErrB_HF == -1) {
2880  int nx = hRate2->GetXaxis()->GetNbins();
2881  for (int i = 1; i <= nx; i++) {
2882  double ccc1 = hRate2->GetBinContent(i);
2883  if (ccc1 > 0.) {
2884  cout << "****************>>>>>>>>>>> ErrB_HF bad LS start at iLS = " << i << " with rate = " << ccc1
2885  << endl;
2886  LSofFirstErrB_HF = i;
2887  break;
2888  }
2889  }
2890  }
2891  delete h1;
2892  delete h0;
2893  if (hRate2 != hRate2orig) {
2894  delete hRate2orig;
2895  hRate2orig = hRate2;
2896  }
2897  }
2898  cHB->Update();
2899  cHB->Print(Form("HistErrB_HF_%d.png", depth));
2900  cHB->Clear();
2901  if (h2Cefz6)
2902  delete h2Cefz6;
2903  if (hRate2orig)
2904  delete hRate2orig;
2905  }
2906  } // ErrorsB in HF
2907 
2909 
2910  //=============================================================================== err A HB
2912  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HBx.png
2913 
2914  for (int depth = 1; depth <= 2; depth++) {
2915  TH2F *h2Ceff = NULL;
2916  TH2F *h2Diffe = NULL;
2917  // TH1F* h1diffADCAmpl= NULL;
2918  TH2F *h3Ceff = NULL;
2919 
2920  cHE->Clear();
2921  cHE->Divide(3, 1);
2922 
2923  cHE->cd(1);
2924  // h_mapDepth1ADCAmpl_HB div h_mapDepth1_HB
2925  TString hname1 = Form("h_mapDepth%dADCAmpl_HB", depth);
2926  TString hname0 = Form("h_mapDepth%d_HB", depth);
2927  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
2928  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
2929  if (!twod1 || !twod0) {
2930  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2931  ptext->AddText("Missing histo");
2932  std::cout << "specHB test: failed to load " << hname1 << " and/or " << hname0 << "\n";
2933  if (!twod1)
2934  ptext->AddText(hname1);
2935  if (!twod0)
2936  ptext->AddText(hname0);
2937  ptext->Draw();
2938  continue;
2939  } else {
2940  // To IDENTIFY: see color different bins in eta-phi space
2941  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HB%d", depth));
2942  h2Ceff->SetTitle(Form("HB Depth %d. (No cut) \b", depth));
2943  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
2944 
2945  gPad->SetGridy();
2946  gPad->SetGridx();
2947  gPad->SetLogz();
2948  h2Ceff->SetMarkerStyle(20);
2949  h2Ceff->SetMarkerSize(0.4);
2950  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
2951  h2Ceff->SetXTitle("#eta \b");
2952  h2Ceff->SetYTitle("#phi \b");
2953  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HB \b");
2954  h2Ceff->SetMarkerColor(2);
2955  h2Ceff->SetLineColor(2);
2956  h2Ceff->Draw("COLZ");
2957  }
2958 
2959  cHE->cd(2);
2961  if (h2Ceff) {
2962  // TO IDENTIFY: see red bins in eta-phi space
2963  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HB", depth));
2964  h2Diffe->SetTitle(Form("HB Depth %d. Cut avg(ADCAmpl) > 25 \b", depth));
2965  int nx = h2Ceff->GetXaxis()->GetNbins();
2966  int ny = h2Ceff->GetYaxis()->GetNbins();
2967  for (int i = 1; i <= nx; i++) {
2968  for (int j = 1; j <= ny; j++) {
2969  double ccc1 = h2Ceff->GetBinContent(i, j);
2970  h2Diffe->SetBinContent(i, j, 0.);
2971  if (ccc1 > 25.)
2972  h2Diffe->SetBinContent(i, j, ccc1);
2973  }
2974  }
2975  gPad->SetGridy();
2976  gPad->SetGridx();
2977  gPad->SetLogz();
2978  h2Diffe->SetMarkerStyle(20);
2979  h2Diffe->SetMarkerSize(0.4);
2980  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
2981  h2Diffe->SetXTitle("#eta \b");
2982  h2Diffe->SetYTitle("#phi \b");
2983  h2Diffe->SetZTitle("<ADCAmpl> bigger 25.- HB Depth1 \b");
2984  h2Diffe->SetMarkerColor(2);
2985  h2Diffe->SetLineColor(2);
2986  h2Diffe->Draw("COLZ");
2987  }
2988 
2989  cHE->cd(3);
2990  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HB", depth);
2991  TH2F *twod3 = (TH2F *)hfile->Get(hname3);
2992  if (!twod3 || !twod0) {
2993  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2994  ptext->AddText("Missing histo");
2995  std::cout << "specHB test: failed to load " << hname3 << " and/or " << hname0 << "\n";
2996  if (!twod3)
2997  ptext->AddText(hname3);
2998  if (!twod0)
2999  ptext->AddText(hname0);
3000  ptext->Draw();
3001  continue;
3002  } else {
3003  // To IDENTIFY: see color different bins in eta-phi space
3004  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HB%d", depth));
3005  h3Ceff->SetTitle(Form("HB Depth %d. \b", depth));
3006  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3007  gPad->SetGridy();
3008  gPad->SetGridx();
3009  gPad->SetLogz();
3010  h3Ceff->SetMarkerStyle(20);
3011  h3Ceff->SetMarkerSize(0.4);
3012  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3013  h3Ceff->SetXTitle("#eta \b");
3014  h3Ceff->SetYTitle("#phi \b");
3015  h3Ceff->SetZTitle("rate for channels of HB \b");
3016  h3Ceff->SetMarkerColor(2);
3017  h3Ceff->SetLineColor(2);
3018  h3Ceff->Draw("COLZ");
3019  }
3020 
3021  cHE->Update();
3022  cHE->Print(Form("ChkErrA_HB%d.png", depth));
3023  cHE->Clear();
3024 
3025  if (h2Ceff)
3026  delete h2Ceff;
3027  if (h2Diffe)
3028  delete h2Diffe;
3029  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3030  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3031  if (twod1)
3032  delete twod1;
3033  if (twod3)
3034  delete twod3;
3035  if (h3Ceff)
3036  delete h3Ceff;
3037  } // depth
3038 
3039  //=============================================================================== err A HE
3041  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HEx.png
3042 
3043  for (int depth = 1; depth <= 3; depth++) {
3044  TH2F *h2Ceff = NULL;
3045  TH2F *h2Diffe = NULL;
3046  // TH1F* h1diffADCAmpl= NULL;
3047  TH2F *h3Ceff = NULL;
3048 
3049  cHE->Clear();
3050  cHE->Divide(3, 1);
3051 
3052  cHE->cd(1);
3053  // h_mapDepth1ADCAmpl_HE div h_mapDepth1_HE
3054  TString hname1 = Form("h_mapDepth%dADCAmpl_HE", depth);
3055  TString hname0 = Form("h_mapDepth%d_HE", depth);
3056  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
3057  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
3058  if (!twod1 || !twod0) {
3059  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3060  ptext->AddText("Missing histo");
3061  std::cout << "specHE test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3062  if (!twod1)
3063  ptext->AddText(hname1);
3064  if (!twod0)
3065  ptext->AddText(hname0);
3066  ptext->Draw();
3067  continue;
3068  } else {
3069  // To IDENTIFY: see color different bins in eta-phi space
3070  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HE%d", depth));
3071  h2Ceff->SetTitle(Form("HE Depth %d. (No cut) \b", depth));
3072  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3073 
3074  gPad->SetGridy();
3075  gPad->SetGridx();
3076  gPad->SetLogz();
3077  h2Ceff->SetMarkerStyle(20);
3078  h2Ceff->SetMarkerSize(0.4);
3079  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3080  h2Ceff->SetXTitle("#eta \b");
3081  h2Ceff->SetYTitle("#phi \b");
3082  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HE \b");
3083  h2Ceff->SetMarkerColor(2);
3084  h2Ceff->SetLineColor(2);
3085  h2Ceff->Draw("COLZ");
3086  }
3087 
3088  cHE->cd(2);
3090  if (h2Ceff) {
3091  // TO IDENTIFY: see red bins in eta-phi space
3092  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HE", depth));
3093  h2Diffe->SetTitle(Form("HE Depth %d. Cut avg(ADCAmpl) > 1000 fC \b", depth));
3094  int nx = h2Ceff->GetXaxis()->GetNbins();
3095  int ny = h2Ceff->GetYaxis()->GetNbins();
3096  for (int i = 1; i <= nx; i++) {
3097  for (int j = 1; j <= ny; j++) {
3098  double ccc1 = h2Ceff->GetBinContent(i, j);
3099  h2Diffe->SetBinContent(i, j, 0.);
3100  if (ccc1 > 1000.)
3101  h2Diffe->SetBinContent(i, j, ccc1);
3102  }
3103  }
3104  gPad->SetGridy();
3105  gPad->SetGridx();
3106  gPad->SetLogz();
3107  h2Diffe->SetMarkerStyle(20);
3108  h2Diffe->SetMarkerSize(0.4);
3109  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3110  h2Diffe->SetXTitle("#eta \b");
3111  h2Diffe->SetYTitle("#phi \b");
3112  h2Diffe->SetZTitle("<ADCAmpl> bigger 1000.fC - HE Depth1 \b");
3113  h2Diffe->SetMarkerColor(2);
3114  h2Diffe->SetLineColor(2);
3115  h2Diffe->Draw("COLZ");
3116  }
3117 
3118  cHE->cd(3);
3119  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HE", depth);
3120  TH2F *twod3 = (TH2F *)hfile->Get(hname3);
3121  if (!twod3 || !twod0) {
3122  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3123  ptext->AddText("Missing histo");
3124  std::cout << "specHE test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3125  if (!twod3)
3126  ptext->AddText(hname3);
3127  if (!twod0)
3128  ptext->AddText(hname0);
3129  ptext->Draw();
3130  continue;
3131  } else {
3132  // To IDENTIFY: see color different bins in eta-phi space
3133  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HE%d", depth));
3134  h3Ceff->SetTitle(Form("HE Depth %d. \b", depth));
3135  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3136  gPad->SetGridy();
3137  gPad->SetGridx();
3138  gPad->SetLogz();
3139  h3Ceff->SetMarkerStyle(20);
3140  h3Ceff->SetMarkerSize(0.4);
3141  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3142  h3Ceff->SetXTitle("#eta \b");
3143  h3Ceff->SetYTitle("#phi \b");
3144  h3Ceff->SetZTitle("rate for channels of HE \b");
3145  h3Ceff->SetMarkerColor(2);
3146  h3Ceff->SetLineColor(2);
3147  h3Ceff->Draw("COLZ");
3148  }
3149 
3150  cHE->Update();
3151  cHE->Print(Form("ChkErrA_HE%d.png", depth));
3152  cHE->Clear();
3153 
3154  if (h2Ceff)
3155  delete h2Ceff;
3156  if (h2Diffe)
3157  delete h2Diffe;
3158  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3159  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3160  if (twod1)
3161  delete twod1;
3162  if (twod3)
3163  delete twod3;
3164  if (h3Ceff)
3165  delete h3Ceff;
3166  } // depth
3167 
3168  //=============================================================================== err A HO
3170  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HOx.png
3171 
3172  for (int depth = 4; depth <= 4; depth++) {
3173  TH2F *h2Ceff = NULL;
3174  TH2F *h2Diffe = NULL;
3175  // TH1F* h1diffADCAmpl= NULL;
3176  TH2F *h3Ceff = NULL;
3177 
3178  cHE->Clear();
3179  cHE->Divide(3, 1);
3180 
3181  cHE->cd(1);
3182  // h_mapDepth1ADCAmpl_HO div h_mapDepth1_HO
3183  TString hname1 = Form("h_mapDepth%dADCAmpl_HO", depth);
3184  TString hname0 = Form("h_mapDepth%d_HO", depth);
3185  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
3186  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
3187  if (!twod1 || !twod0) {
3188  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3189  ptext->AddText("Missing histo");
3190  std::cout << "specHO test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3191  if (!twod1)
3192  ptext->AddText(hname1);
3193  if (!twod0)
3194  ptext->AddText(hname0);
3195  ptext->Draw();
3196  continue;
3197  } else {
3198  // To IDENTIFY: see color different bins in eta-phi space
3199  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HO%d", depth));
3200  h2Ceff->SetTitle(Form("HO Depth %d. (No cut) \b", depth));
3201  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3202 
3203  gPad->SetGridy();
3204  gPad->SetGridx();
3205  gPad->SetLogz();
3206  h2Ceff->SetMarkerStyle(20);
3207  h2Ceff->SetMarkerSize(0.4);
3208  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3209  h2Ceff->SetXTitle("#eta \b");
3210  h2Ceff->SetYTitle("#phi \b");
3211  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HO \b");
3212  h2Ceff->SetMarkerColor(2);
3213  h2Ceff->SetLineColor(2);
3214  h2Ceff->Draw("COLZ");
3215  }
3216 
3217  cHE->cd(2);
3219  if (h2Ceff) {
3220  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3221  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HO", depth));
3222  h2Diffe->SetTitle(Form("HO Depth %d. Cut avg(ADCAmpl) > 80 \b", depth));
3223  int nx = h2Ceff->GetXaxis()->GetNbins();
3224  int ny = h2Ceff->GetYaxis()->GetNbins();
3225  for (int i = 1; i <= nx; i++) {
3226  for (int j = 1; j <= ny; j++) {
3227  double ccc1 = h2Ceff->GetBinContent(i, j);
3228  h2Diffe->SetBinContent(i, j, 0.);
3229  if (ccc1 > 20.)
3230  h2Diffe->SetBinContent(i, j, ccc1);
3231  }
3232  }
3233  gPad->SetGridy();
3234  gPad->SetGridx();
3235  gPad->SetLogz();
3236  h2Diffe->SetMarkerStyle(20);
3237  h2Diffe->SetMarkerSize(0.4);
3238  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3239  h2Diffe->SetXTitle("#eta \b");
3240  h2Diffe->SetYTitle("#phi \b");
3241  h2Diffe->SetZTitle("<ADCAmpl> bigger 80.- HO Depth1 \b");
3242  h2Diffe->SetMarkerColor(2);
3243  h2Diffe->SetLineColor(2);
3244  h2Diffe->Draw("COLZ");
3245  }
3246 
3247  cHE->cd(3);
3248  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HO", depth);
3249  TH2F *twod3 = (TH2F *)hfile->Get(hname3);
3250  if (!twod3 || !twod0) {
3251  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3252  ptext->AddText("Missing histo");
3253  std::cout << "specHO test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3254  if (!twod3)
3255  ptext->AddText(hname3);
3256  if (!twod0)
3257  ptext->AddText(hname0);
3258  ptext->Draw();
3259  continue;
3260  } else {
3261  // To IDENTIFY: see color different bins in eta-phi space
3262  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HO%d", depth));
3263  h3Ceff->SetTitle(Form("HO Depth %d. \b", depth));
3264  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3265  gPad->SetGridy();
3266  gPad->SetGridx();
3267  gPad->SetLogz();
3268  h3Ceff->SetMarkerStyle(20);
3269  h3Ceff->SetMarkerSize(0.4);
3270  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3271  h3Ceff->SetXTitle("#eta \b");
3272  h3Ceff->SetYTitle("#phi \b");
3273  h3Ceff->SetZTitle("rate for channels of HO \b");
3274  h3Ceff->SetMarkerColor(2);
3275  h3Ceff->SetLineColor(2);
3276  h3Ceff->Draw("COLZ");
3277  }
3278 
3279  cHE->Update();
3280  cHE->Print(Form("ChkErrA_HO%d.png", depth));
3281  cHE->Clear();
3282 
3283  if (h2Ceff)
3284  delete h2Ceff;
3285  if (h2Diffe)
3286  delete h2Diffe;
3287  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3288  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3289  if (twod1)
3290  delete twod1;
3291  if (twod3)
3292  delete twod3;
3293  if (h3Ceff)
3294  delete h3Ceff;
3295  } // depth
3296 
3297  //=============================================================================== err A HF
3299  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HFx.png
3300 
3301  for (int depth = 1; depth <= 2; depth++) {
3302  TH2F *h2Ceff = NULL;
3303  TH2F *h2Diffe = NULL;
3304  // TH1F* h1diffADCAmpl= NULL;
3305  TH2F *h3Ceff = NULL;
3306 
3307  cHE->Clear();
3308  cHE->Divide(3, 1);
3309 
3310  cHE->cd(1);
3311  // h_mapDepth1ADCAmpl_HF div h_mapDepth1_HF
3312  TString hname1 = Form("h_mapDepth%dADCAmpl_HF", depth);
3313  TString hname0 = Form("h_mapDepth%d_HF", depth);
3314  TH2F *twod1 = (TH2F *)hfile->Get(hname1);
3315  TH2F *twod0 = (TH2F *)hfile->Get(hname0);
3316  if (!twod1 || !twod0) {
3317  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3318  ptext->AddText("Missing histo");
3319  std::cout << "specHF test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3320  if (!twod1)
3321  ptext->AddText(hname1);
3322  if (!twod0)
3323  ptext->AddText(hname0);
3324  ptext->Draw();
3325  continue;
3326  } else {
3327  // To IDENTIFY: see color different bins in eta-phi space
3328  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HF%d", depth));
3329  h2Ceff->SetTitle(Form("HF Depth %d. (No cut) \b", depth));
3330  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3331 
3332  gPad->SetGridy();
3333  gPad->SetGridx();
3334  gPad->SetLogz();
3335  h2Ceff->SetMarkerStyle(20);
3336  h2Ceff->SetMarkerSize(0.4);
3337  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3338  h2Ceff->SetXTitle("#eta \b");
3339  h2Ceff->SetYTitle("#phi \b");
3340  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HF \b");
3341  h2Ceff->SetMarkerColor(2);
3342  h2Ceff->SetLineColor(2);
3343  h2Ceff->Draw("COLZ");
3344  }
3345 
3346  cHE->cd(2);
3348  if (h2Ceff) {
3349  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3350  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HF", depth));
3351  h2Diffe->SetTitle(Form("HF Depth %d. Cut avg(ADCAmpl) > 20 \b", depth));
3352  int nx = h2Ceff->GetXaxis()->GetNbins();
3353  int ny = h2Ceff->GetYaxis()->GetNbins();
3354  for (int i = 1; i <= nx; i++) {
3355  for (int j = 1; j <= ny; j++) {
3356  double ccc1 = h2Ceff->GetBinContent(i, j);
3357  h2Diffe->SetBinContent(i, j, 0.);
3358  if (ccc1 > 20.)
3359  h2Diffe->SetBinContent(i, j, ccc1);
3360  }
3361  }
3362  gPad->SetGridy();
3363  gPad->SetGridx();
3364  gPad->SetLogz();
3365  h2Diffe->SetMarkerStyle(20);
3366  h2Diffe->SetMarkerSize(0.4);
3367  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3368  h2Diffe->SetXTitle("#eta \b");
3369  h2Diffe->SetYTitle("#phi \b");
3370  h2Diffe->SetZTitle("<ADCAmpl> bigger 20.- HF Depth1 \b");
3371  h2Diffe->SetMarkerColor(2);
3372  h2Diffe->SetLineColor(2);
3373  h2Diffe->Draw("COLZ");
3374  }
3375 
3376  cHE->cd(3);
3377  /*
3378  if (h2Ceff) {
3379  h1diffADCAmpl = new TH1F(Form("diffADCAmpl_Depth%d_HF",depth),"",
3380  100, -20.,200.);
3381  h1diffADCAmpl->SetTitle(Form("HF Depth %d \b",depth));
3382  int nx = h2Ceff->GetXaxis()->GetNbins();
3383  int ny = h2Ceff->GetYaxis()->GetNbins();
3384  for (int i=1;i<=nx;i++) {
3385  for (int j=1;j<=ny;j++) {
3386  if(h2Ceff->GetBinContent(i,j) !=0 ) {
3387  double ccc1 = h2Ceff->GetBinContent(i,j) ;
3388  h1diffADCAmpl->Fill(ccc1);
3389  }
3390  }
3391  }
3392  gPad->SetLogy();
3393  h1diffADCAmpl->SetMarkerStyle(20);
3394  h1diffADCAmpl->SetMarkerSize(0.4);
3395  h1diffADCAmpl->GetYaxis()->SetLabelSize(0.04);
3396  h1diffADCAmpl->SetXTitle("<ADCAmpl> in each cell \b");
3397  h1diffADCAmpl->SetMarkerColor(2);
3398  h1diffADCAmpl->SetLineColor(2);
3399  h1diffADCAmpl->Draw("");
3400  }
3401  */
3402  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HF", depth);
3403  TH2F *twod3 = (TH2F *)hfile->Get(hname3);
3404  if (!twod3 || !twod0) {
3405  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3406  ptext->AddText("Missing histo");
3407  std::cout << "specHF test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3408  if (!twod3)
3409  ptext->AddText(hname3);
3410  if (!twod0)
3411  ptext->AddText(hname0);
3412  ptext->Draw();
3413  continue;
3414  } else {
3415  // To IDENTIFY: see color different bins in eta-phi space
3416  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HF%d", depth));
3417  h3Ceff->SetTitle(Form("HF Depth %d. \b", depth));
3418  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3419  gPad->SetGridy();
3420  gPad->SetGridx();
3421  gPad->SetLogz();
3422  h3Ceff->SetMarkerStyle(20);
3423  h3Ceff->SetMarkerSize(0.4);
3424  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3425  h3Ceff->SetXTitle("#eta \b");
3426  h3Ceff->SetYTitle("#phi \b");
3427  h3Ceff->SetZTitle("rate for channels of HF \b");
3428  h3Ceff->SetMarkerColor(2);
3429  h3Ceff->SetLineColor(2);
3430  h3Ceff->Draw("COLZ");
3431  }
3432 
3433  cHE->Update();
3434  cHE->Print(Form("ChkErrA_HF%d.png", depth));
3435  cHE->Clear();
3436 
3437  if (h2Ceff)
3438  delete h2Ceff;
3439  if (h2Diffe)
3440  delete h2Diffe;
3441  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3442  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3443  if (twod1)
3444  delete twod1;
3445  if (twod3)
3446  delete twod3;
3447  if (h3Ceff)
3448  delete h3Ceff;
3449  } // depth
3450 
3451  std::cout << "************>>> average Amplitudes done" << std::endl;
3452 
3453  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3454  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3455  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3456  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3457  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3458 
3463 
3464  cout << " RBX analysis START for **************************" << endl;
3465  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3466  // int njeta = 22; int njphi = 18; int lsmax=2600;
3467  int njeta = 22;
3468  int njphi = 18;
3469  int lsmax = 2600;
3470  cout << ">>>>>>>>>>>>>>>>>>>>>>>> int njeta = 22; int njphi = 18; int lsmax=2600; "
3471  << endl;
3472 
3473  double alexall[njeta][njphi][lsmax];
3474 
3475  // for phi tables(!):
3476  double alexhb[njphi][lsmax];
3477  double alexhe[njphi][lsmax];
3478  double alexho[njphi][lsmax];
3479  double alexhf[njphi][lsmax];
3480 
3481  // for eta tables(!):
3482  double blexhb[njeta][lsmax];
3483  double blexhe[njeta][lsmax];
3484  double blexho[njeta][lsmax];
3485  double blexhf[njeta][lsmax];
3486 
3487  cout << ">>>>>>>>>>>>>>>>>>>>>>>> alexall [njeta][njphi][lsmax]; " << endl;
3488  int maxbinsRBX = MaxLum;
3489  int nx = maxbinsRBX; // # LS
3490  cout << ">>>>>>>>>>>>>>>>>>>>>>>> maxbinsRBX = MaxLum; " << endl;
3491  if (MaxLum > lsmax)
3492  cout << "*********************************** ERROR ERROR ERROR ERROR: MaxLum > 2600 " << endl;
3493  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3494 
3495  for (int i = 0; i < nx; i++) {
3496  for (int jphi = 0; jphi < njphi; jphi++) {
3497  alexhb[jphi][i] = 0.;
3498  alexhe[jphi][i] = 0.;
3499  alexho[jphi][i] = 0.;
3500  alexhf[jphi][i] = 0.;
3501 
3502  for (int jeta = 0; jeta < njeta; jeta++) {
3503  if (jphi == 0) {
3504  blexhb[jeta][i] = 0.;
3505  blexhe[jeta][i] = 0.;
3506  blexho[jeta][i] = 0.;
3507  blexhf[jeta][i] = 0.;
3508  }
3509 
3510  alexall[jeta][jphi][i] = 0.;
3511  }
3512  }
3513  }
3514 
3516  /*
3517  // j = ietaphi = 1- 396
3518  int ietaphimax = 396;
3519  int ny = ietaphimax + 1 ;
3520  for (int j=1;j<ny;j++) {
3521  int jeta = (j-1)/znphi;
3522  int jphi = (j-1)-znphi*jeta+1;// jphi=1-18
3523  jeta += 1;// jeta = 1-22 }
3524 // Outout is jeta = 1-22 jphi=1-18
3525 HB: j = 7,8,9,10 11,12,13,14
3526 HE: j = 3,4,5, 6, 7 14,15,16,17,18
3527 HO: j = 7,8,9,10 11,12,13,14
3528 HF: j = 0,1,2, 3 18,19,20,21
3529 */
3530 
3532  //======================================================================
3533  //======================================================================
3534  //======================================================================
3535  cout << " RBX general for HB **************************" << endl;
3536  TH2F *Ghb1KKK = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs0");
3537  TH2F *Ghb1LLL = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs00");
3538  TH2F *Ghb1 = (TH2F *)Ghb1LLL->Clone("Ghb1");
3539  Ghb1->Divide(Ghb1KKK, Ghb1LLL, 1, 1, "B"); // average A
3540  // Ghb1->Sumw2();
3541  // int nx = Ghb1->GetXaxis()->GetNbins(); // # LS
3542  int ny = Ghb1->GetYaxis()->GetNbins(); // # jetaphi indexes = 396 = 18*22
3543  // cout<<"***************************************** HB 54 ny= "<< ny <<endl;
3544  for (int j = 1; j <= ny; j++) {
3545  int jeta = (j - 1) / njphi; // jeta = 0-21
3546  if (jeta > 6 && jeta < 15) {
3547  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
3548  // cout<<"HB 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
3549  // over LS:
3550  for (int i = 1; i <= nx; i++) {
3551  double ccc1 = Ghb1->GetBinContent(i, j);
3552  alexall[jeta][jphi][i - 1] = ccc1;
3553  // if( i == 1 ) cout<<"HB 54 for LS=1 ccc1= "<< ccc1 <<endl;
3554  // if( ccc1 <= 0 ) cout<<"HB 54 ccc1= "<< ccc1 <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3555  // cout<<"HB 54 ccc1= "<< ccc1 <<" j= "<< j <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3556  } //i
3557  } //if
3558  } //j
3559  // clean-up
3560  if (Ghb1KKK)
3561  delete Ghb1KKK;
3562  if (Ghb1LLL)
3563  delete Ghb1LLL;
3564  // if (Ghb1) delete Ghb1;
3565 
3566  //====================================================================== alexhb[k][i]
3567  for (int jphi = 0; jphi < njphi; jphi++) {
3568  for (int i = 0; i < nx; i++) {
3569  double sumccc1 = 0.;
3570  int isum = 0;
3571  for (int jeta = 0; jeta < njeta; jeta++) {
3572  double ccc1 = alexall[jeta][jphi][i];
3573  if (ccc1 > 0.) {
3574  sumccc1 += ccc1;
3575  isum++;
3576  }
3577  } // for jeta
3578  if (isum > 0.)
3579  sumccc1 /= isum;
3580  alexhb[jphi][i] = sumccc1;
3581  }
3582  } //for for
3583 
3584  //====================================================================== blexhb[k][i]
3585  for (int keta = 0; keta < njeta; keta++) {
3586  for (int i = 0; i < nx; i++) {
3587  double sumccc1 = 0.;
3588  int isum = 0;
3589  for (int kphi = 0; kphi < njphi; kphi++) {
3590  double ccc1 = alexall[keta][kphi][i];
3591  if (ccc1 > 0.) {
3592  sumccc1 += ccc1;
3593  isum++;
3594  }
3595  } // for kphi
3596  if (isum > 0.)
3597  sumccc1 /= isum;
3598  blexhb[keta][i] = sumccc1;
3599  }
3600  } //for for
3601 
3603  //========================================================================================== 11 HB:: 2D jeta = 0 - 21 jphi =0 - 17
3604  //======================================================================
3605  //======================================================================
3606  //======================================================================
3607  //======================================================================
3608  cout << " RBX HB 2D plot *****" << endl;
3609  cRBX1->Clear();
3611  cRBX1->Divide(1, 1);
3612  cRBX1->cd(1);
3613  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
3614  // TH2F* Ghb42D = new TH2F("Ghb42D","", 22, -11., 11., 18, 0., 18. );
3615  // TH2F* Ghb42D0 = new TH2F("Ghb42D0","", 22, -11., 11., 18, 0., 18. );
3616  TH2F *Ghb42D = new TH2F("Ghb42D", "", 23, -11.5, 11.5, 18, 0., 18.);
3617  TH2F *Ghb42D0 = new TH2F("Ghb42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
3618  TH2F *Ghb42DF = (TH2F *)Ghb42D0->Clone("Ghb42DF");
3619  for (int jphi = 0; jphi < njphi; jphi++) {
3620  for (int jeta = 0; jeta < njeta; jeta++) {
3621  for (int i = 0; i < nx; i++) {
3622  double ccc1 = alexall[jeta][jphi][i];
3623  int neweta = jeta - 11 - 0.5;
3624  if (jeta >= 11)
3625  neweta = jeta - 11 + 1.5;
3626  if (ccc1 > 0.) {
3627  Ghb42D->Fill(neweta, jphi, ccc1);
3628  Ghb42D0->Fill(neweta, jphi, 1.);
3629  }
3630  // if(ccc1>0.) {Ghb42D ->Fill(jeta-11,jphi,ccc1); Ghb42D0 ->Fill(jeta-11,jphi,1.); }
3631  }
3632  }
3633  }
3634  Ghb42DF->Divide(Ghb42D, Ghb42D0, 1, 1, "B"); // average A
3635  // Ghb1->Sumw2();
3636  gPad->SetGridy();
3637  gPad->SetGridx(); // gPad->SetLogz();
3638  Ghb42DF->SetMarkerStyle(20);
3639  Ghb42DF->SetMarkerSize(0.4);
3640  Ghb42DF->GetZaxis()->SetLabelSize(0.04);
3641  Ghb42DF->SetXTitle("<A>_RBX #eta \b");
3642  Ghb42DF->SetYTitle(" #phi \b");
3643  Ghb42DF->SetZTitle("<A>_RBX - All \b");
3644  Ghb42DF->SetMarkerColor(2);
3645  Ghb42DF->SetLineColor(2); // Ghb42DF->SetMaximum(1.000); // Ghb42DF->SetMinimum(1.0);
3646  Ghb42DF->Draw("COLZ");
3647 
3649  cRBX1->Update();
3650  cRBX1->Print("RBX-HB-2Dplot.png");
3651  cRBX1->Clear();
3652  // clean-up
3653  if (Ghb42D)
3654  delete Ghb42D;
3655  if (Ghb42D0)
3656  delete Ghb42D0;
3657  if (Ghb42DF)
3658  delete Ghb42DF;
3659 
3660  //========================================================================================== 61 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3661  //======================================================================
3662  //======================================================================
3663  //======================================================================
3664  //======================================================================
3665  cout << " RBX HB 1D plot *****" << endl;
3666  cRBX1->Clear();
3668  cRBX1->Divide(1, 1);
3669  cRBX1->cd(1);
3670  TH1F *GphiHB1D = new TH1F("GphiHB1D", "", 18, 0., 18.);
3671  TH1F *GphiHB1D0 = new TH1F("GphiHB1D0", "", 18, 0., 18.);
3672  TH1F *GphiHB1DF = (TH1F *)GphiHB1D0->Clone("GphiHB1DF");
3673  for (int jphi = 0; jphi < 18; jphi++) {
3674  for (int jeta = 0; jeta < 22; jeta++) {
3675  for (int i = 0; i < nx; i++) {
3676  double ccc1 = alexall[jeta][jphi][i];
3677  if (ccc1 > 0.) {
3678  GphiHB1D->Fill(jphi, ccc1);
3679  GphiHB1D0->Fill(jphi, 1.);
3680  }
3681  }
3682  }
3683  }
3684  // GphiHB1D->Sumw2();GphiHB1D0->Sumw2();
3685  GphiHB1DF->Divide(GphiHB1D, GphiHB1D0, 1, 1, "B"); // average A
3686  // GphiHB1DF->Sumw2();
3687  for (int jphi = 1; jphi < 19; jphi++) {
3688  GphiHB1DF->SetBinError(jphi, 0.01);
3689  }
3690  gPad->SetGridy();
3691  gPad->SetGridx(); // gPad->SetLogz();
3692  GphiHB1DF->SetMarkerStyle(20);
3693  GphiHB1DF->SetMarkerSize(1.4);
3694  GphiHB1DF->GetZaxis()->SetLabelSize(0.08);
3695  GphiHB1DF->SetXTitle("PHI of RBX\b");
3696  GphiHB1DF->SetYTitle(" <Amplitude> \b");
3697  GphiHB1DF->SetZTitle("<A>_PHI - All \b");
3698  GphiHB1DF->SetMarkerColor(4);
3699  GphiHB1DF->SetLineColor(4);
3700  GphiHB1DF->SetMinimum(0.8); // GphiHB1DF->SetMaximum(1.000);
3701  GphiHB1DF->Draw("Error");
3703  cRBX1->Update();
3704  cRBX1->Print("RBX-HB-1Dplot.png");
3705  cRBX1->Clear();
3706  // clean-up
3707  if (GphiHB1D)
3708  delete GphiHB1D;
3709  if (GphiHB1D0)
3710  delete GphiHB1D0;
3711  if (GphiHB1DF)
3712  delete GphiHB1DF;
3713 
3714  //========================================================================================== 62 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3715  //======================================================================
3716  //======================================================================
3717  //======================================================================
3718  //======================================================================
3719  cout << " RBX HB 11D plot *eta*" << endl;
3720  cRBX1->Clear();
3722  cRBX1->Divide(1, 1);
3723  cRBX1->cd(1);
3724  TH1F *GetaHB11D = new TH1F("GetaHB11D", "", 23, -11.5, 11.5);
3725  TH1F *GetaHB11D0 = new TH1F("GetaHB11D0", "", 23, -11.5, 11.5);
3726  TH1F *GetaHB11DF = (TH1F *)GetaHB11D0->Clone("GetaHB11DF");
3727 
3728  for (int jeta = 0; jeta < 22; jeta++) {
3729  for (int jphi = 0; jphi < 18; jphi++) {
3730  for (int i = 0; i < nx; i++) {
3731  double ccc1 = alexall[jeta][jphi][i];
3732  int neweta = jeta - 11 - 0.5;
3733  if (jeta >= 11)
3734  neweta = jeta - 11 + 1.5;
3735  if (ccc1 > 0.) {
3736  GetaHB11D->Fill(neweta, ccc1);
3737  GetaHB11D0->Fill(neweta, 1.);
3738  // if( i == 0 ) cout<<"62 HB: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
3739  }
3740  }
3741  }
3742  }
3743  // GetaHB11D->Sumw2();GetaHB11D0->Sumw2();
3744  GetaHB11DF->Divide(GetaHB11D, GetaHB11D0, 1, 1, "B"); // average A
3745  // GetaHB11DF->Sumw2();
3746  for (int jeta = 1; jeta < 24; jeta++) {
3747  GetaHB11DF->SetBinError(jeta, 0.01);
3748  }
3749  gPad->SetGridy();
3750  gPad->SetGridx(); // gPad->SetLogz();
3751  GetaHB11DF->SetMarkerStyle(20);
3752  GetaHB11DF->SetMarkerSize(1.4);
3753  GetaHB11DF->GetZaxis()->SetLabelSize(0.08);
3754  GetaHB11DF->SetXTitle("#eta \b");
3755  GetaHB11DF->SetYTitle(" <A> \b");
3756  GetaHB11DF->SetZTitle("<A>_ETA - All \b");
3757  GetaHB11DF->SetMarkerColor(4);
3758  GetaHB11DF->SetLineColor(4);
3759  GetaHB11DF->SetMinimum(0.8); // GetaHB11DF->SetMaximum(1.000);
3760  GetaHB11DF->Draw("Error");
3761 
3763  cRBX1->Update();
3764  cRBX1->Print("RBX-HB-11Dplot.png");
3765  cRBX1->Clear();
3766  // clean-up
3767  if (GetaHB11D)
3768  delete GetaHB11D;
3769  if (GetaHB11D0)
3770  delete GetaHB11D0;
3771  if (GetaHB11DF)
3772  delete GetaHB11DF;
3773 
3774  //========================================================================================== 22 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
3775  //======================================================================
3776  //======================================================================22.11.2018
3777  //======================================================================
3778  //======================================================================
3779 
3780  gStyle->SetOptStat(1110000);
3781  cout << " RBX HB Ratio plots *****" << endl;
3782  cRBX31->Clear();
3784  // gain stabilitY:
3785  // Rij = Aij / A1j , where i-over LSs, j-channels
3786  //
3787  // nx = maxbinsRBX; // # LS
3788  //
3789  double ccc0HB = 0.;
3790  cRBX31->Divide(3, 1);
3791  //================
3792  cRBX31->cd(1);
3793  // TH1F* Ghb5 = new TH1F("Ghb5","", nx, 1., nx+1.);
3794  TH1F *Ghb51 = new TH1F("Ghb51", "", nx, 1., nx + 1.);
3795  TH1F *Ghb50 = new TH1F("Ghb50", "", nx, 1., nx + 1.);
3796  TH1F *Ghb5 = (TH1F *)Ghb50->Clone("Ghb5");
3797  // j - etaphi index:
3798  for (int j = 1; j <= ny; j++) {
3799  ccc0HB = Ghb1->GetBinContent(1, j);
3800  // if(ccc0HB <=0.) for (int i=1;i<=nx;i++) {double ccc2 = Ghb1->GetBinContent(i,j);if(ccc2>0.){ccc0HB=ccc2;cout<<"!!! ccc0HB= "<<ccc0HB<<endl;break;} }
3801  if (ccc0HB <= 0.)
3802  for (int i = 1; i <= nx; i++) {
3803  double ccc2 = Ghb1->GetBinContent(i, j);
3804  if (ccc2 > 0.) {
3805  ccc0HB = ccc2;
3806  break;
3807  }
3808  }
3809  if (ccc0HB > 0.) {
3810  // i - # LSs:
3811  for (int i = 1; i <= nx; i++) {
3812  double ccc1 = Ghb1->GetBinContent(i, j);
3813  if (ccc1 > 0.) {
3814  double Rij = ccc1 / ccc0HB;
3815  // Ghb5 ->Fill( float(i), Rij);
3816  Ghb51->Fill(float(i), Rij);
3817  Ghb50->Fill(float(i), 1.);
3818  }
3819  }
3820  }
3821  }
3822  Ghb5->Divide(Ghb51, Ghb50, 1, 1, "B"); // average A
3823  for (int i = 1; i <= nx; i++) {
3824  Ghb5->SetBinError(i, 0.0001);
3825  }
3826  Ghb5->SetMarkerStyle(20);
3827  Ghb5->SetMarkerSize(0.4);
3828  Ghb5->GetYaxis()->SetLabelSize(0.04);
3829  Ghb5->SetMarkerColor(2);
3830  Ghb5->SetLineColor(0);
3831  Ghb5->SetXTitle(" iLS \b");
3832  Ghb5->SetYTitle(" <R> \b");
3833  Ghb5->SetTitle("<Ri> vs iLS \b");
3834  Ghb5->SetMinimum(0.); //Ghb5->SetMaximum(2.5);
3835  // gPad->SetLogy();
3836  gPad->SetGridy();
3837  gPad->SetGridx();
3838  Ghb5->SetStats(0);
3839  Ghb5->GetYaxis()->SetLabelSize(0.025);
3840  Ghb5->Draw("Error");
3841  //================
3842  cRBX31->cd(2);
3843  TH2F *Ghb60 = new TH2F("Ghb60", "", 22, -11., 11., 18, 0., 18.);
3844  TH2F *Ghb61 = new TH2F("Ghb61", "", 22, -11., 11., 18, 0., 18.);
3845  TH2F *Ghb6 = new TH2F("Ghb6", "", 22, -11., 11., 18, 0., 18.);
3846 
3847  TH2F *G20hb60 = new TH2F("G20hb60", "", 22, -11., 11., 18, 0., 18.);
3848  TH2F *G20hb61 = new TH2F("G20hb61", "", 22, -11., 11., 18, 0., 18.);
3849  TH2F *G20hb6 = new TH2F("G20hb6", "", 22, -11., 11., 18, 0., 18.);
3850  TH2F *G30hb60 = new TH2F("G30hb60", "", 22, -11., 11., 18, 0., 18.);
3851  TH2F *G30hb61 = new TH2F("G30hb61", "", 22, -11., 11., 18, 0., 18.);
3852  TH2F *G30hb6 = new TH2F("G30hb6", "", 22, -11., 11., 18, 0., 18.);
3853  TH2F *G40hb60 = new TH2F("G40hb60", "", 22, -11., 11., 18, 0., 18.);
3854  TH2F *G40hb61 = new TH2F("G40hb61", "", 22, -11., 11., 18, 0., 18.);
3855  TH2F *G40hb6 = new TH2F("G40hb6", "", 22, -11., 11., 18, 0., 18.);
3856  // j - etaphi index; i - # LSs;
3857  //
3858  // define mean and RMS:
3859  double sumjHB = 0.;
3860  int njHB = 0;
3861  double meanjHB = 0.;
3862  for (int j = 1; j <= ny; j++) {
3863  ccc0HB = Ghb1->GetBinContent(1, j);
3864  if (ccc0HB <= 0.)
3865  for (int i = 1; i <= nx; i++) {
3866  double ccc2 = Ghb1->GetBinContent(i, j);
3867  if (ccc2 > 0.) {
3868  ccc0HB = ccc2;
3869  break;
3870  }
3871  }
3872  if (ccc0HB > 0.) {
3873  for (int i = 1; i <= nx; i++) {
3874  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3875  if (ccc1 > 0.) {
3876  sumjHB += ccc1;
3877  njHB++;
3878  }
3879  }
3880  meanjHB = sumjHB / njHB;
3881  }
3882  } // j
3883 
3884  double ssumjHB = 0.;
3885  njHB = 0;
3886  double sigmajHB = 0.;
3887  for (int j = 1; j <= ny; j++) {
3888  ccc0HB = Ghb1->GetBinContent(1, j);
3889  if (ccc0HB <= 0.)
3890  for (int i = 1; i <= nx; i++) {
3891  double ccc2 = Ghb1->GetBinContent(i, j);
3892  if (ccc2 > 0.) {
3893  ccc0HB = ccc2;
3894  break;
3895  }
3896  }
3897  if (ccc0HB > 0.) {
3898  for (int i = 1; i <= nx; i++) {
3899  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3900  if (ccc1 > 0.) {
3901  ssumjHB += (ccc1 - meanjHB) * (ccc1 - meanjHB);
3902  njHB++;
3903  }
3904  }
3905  sigmajHB = sqrt(ssumjHB / njHB);
3906  }
3907  } // j
3908 
3909  double dif3rmsHBMIN = meanjHB - 3 * sigmajHB;
3910  if (dif3rmsHBMIN < 0.)
3911  dif3rmsHBMIN = 0.;
3912  double dif3rmsHBMAX = meanjHB + 3 * sigmajHB;
3913  cout << "22HB-2 meanjHB= " << meanjHB << " sigmajHB= " << sigmajHB << " dif3rmsHBMIN= " << dif3rmsHBMIN
3914  << " dif3rmsHBMAX= " << dif3rmsHBMAX << endl;
3915 
3916  double MAXdif3rmsHBMIN = dif3rmsHBMIN;
3917  double MINdif3rmsHBMAX = dif3rmsHBMAX;
3918  if (MAXdif3rmsHBMIN < 0.95)
3919  MAXdif3rmsHBMIN = 0.95;
3920  if (MINdif3rmsHBMAX > 1.05)
3921  MINdif3rmsHBMAX = 1.05;
3922  cout << "22HB-2 MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
3923  //
3924  for (int j = 1; j <= ny; j++) {
3925  ccc0HB = Ghb1->GetBinContent(1, j);
3926  if (ccc0HB <= 0.)
3927  for (int i = 1; i <= nx; i++) {
3928  double ccc2 = Ghb1->GetBinContent(i, j);
3929  if (ccc2 > 0.) {
3930  ccc0HB = ccc2;
3931  break;
3932  }
3933  }
3934  if (ccc0HB > 0.) {
3935  int jeta = (j - 1) / 18; // jeta = 0-21
3936  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
3937  // i - # LSs:
3938  for (int i = 1; i <= nx; i++) {
3939  double ccc1 = Ghb1->GetBinContent(i, j);
3940  if (ccc1 > 0.) {
3941  double Rij = ccc1 / ccc0HB;
3942  if (Rij < MAXdif3rmsHBMIN || Rij > MINdif3rmsHBMAX) {
3943  Ghb61->Fill(jeta - 11, jphi, Rij);
3944  Ghb60->Fill(jeta - 11, jphi, 1.);
3945  }
3946  if (Rij < 0.8 || Rij > 1.2) {
3947  G20hb61->Fill(jeta - 11, jphi, Rij);
3948  G20hb60->Fill(jeta - 11, jphi, 1.);
3949  }
3950  if (Rij < 0.7 || Rij > 1.3) {
3951  G30hb61->Fill(jeta - 11, jphi, Rij);
3952  G30hb60->Fill(jeta - 11, jphi, 1.);
3953  }
3954  if (Rij < 0.6 || Rij > 1.4) {
3955  G40hb61->Fill(jeta - 11, jphi, Rij);
3956  G40hb60->Fill(jeta - 11, jphi, 1.);
3957  }
3958  } //if(ccc1>0.
3959  } // i
3960  } //if(ccc0HB>0
3961  } // j
3962  Ghb6->Divide(Ghb61, Ghb60, 1, 1, "B"); // average R
3963  G20hb6->Divide(G20hb61, G20hb60, 1, 1, "B"); // average R
3964  G30hb6->Divide(G30hb61, G30hb60, 1, 1, "B"); // average R
3965  G40hb6->Divide(G40hb61, G40hb60, 1, 1, "B"); // average R
3966 
3967  Ghb6->GetZaxis()->SetLabelSize(0.025);
3968  Ghb6->SetXTitle(" #eta \b");
3969  Ghb6->SetYTitle(" #phi \b");
3970  Ghb6->SetTitle("<Rj> for |1-<R>| > 0.05 \b");
3971  Ghb6->SetStats(0);
3972  Ghb6->Draw("COLZ");
3973  //================
3974  cRBX31->cd(3);
3975  TH1F *Ghb7 = new TH1F("Ghb7", "", 120, 0.4, 1.6);
3976  // j - etaphi index:
3977  for (int j = 1; j <= ny; j++) {
3978  ccc0HB = Ghb1->GetBinContent(1, j);
3979  if (ccc0HB <= 0.)
3980  for (int i = 1; i <= nx; i++) {
3981  double ccc2 = Ghb1->GetBinContent(i, j);
3982  if (ccc2 > 0.) {
3983  ccc0HB = ccc2;
3984  break;
3985  }
3986  }
3987  if (ccc0HB > 0.) {
3988  // i - # LSs:
3989  for (int i = 1; i <= nx; i++) {
3990  double ccc1 = Ghb1->GetBinContent(i, j);
3991  if (ccc1 > 0.) {
3992  double Rij = ccc1 / ccc0HB;
3993  Ghb7->Fill(Rij);
3994  }
3995  }
3996  }
3997  }
3998  Ghb7->SetMarkerStyle(20);
3999  Ghb7->SetMarkerSize(0.4);
4000  Ghb7->GetYaxis()->SetLabelSize(0.04);
4001  Ghb7->SetMarkerColor(2);
4002  Ghb7->SetLineColor(0);
4003  Ghb7->SetYTitle(" N \b");
4004  Ghb7->SetXTitle(" Rij \b");
4005  Ghb7->SetTitle(" Rij \b");
4006  //Ghb7->SetMinimum(0.8);Ghb7->SetMaximum(500.);
4007  gPad->SetGridy();
4008  gPad->SetGridx(); // gPad->SetLogy();
4009  // Ghb7->SetStats(1110000);
4010  Ghb7->GetYaxis()->SetLabelSize(0.025);
4011  Ghb7->Draw("Error");
4012  Float_t ymaxHB = Ghb7->GetMaximum();
4013  cout << "22HB-3 ymaxHB= " << ymaxHB << " MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN
4014  << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
4015  TLine *lineHB = new TLine(MAXdif3rmsHBMIN, 0., MAXdif3rmsHBMIN, ymaxHB);
4016  lineHB->SetLineColor(kBlue);
4017  lineHB->Draw();
4018  TLine *line1HB = new TLine(MINdif3rmsHBMAX, 0., MINdif3rmsHBMAX, ymaxHB);
4019  line1HB->SetLineColor(kBlue);
4020  line1HB->Draw();
4021  //================
4023  cRBX31->Update();
4024  cRBX31->Print("RBX-HB-3plots.png");
4025  cRBX31->Clear();
4026  // clean-up
4027  if (Ghb5)
4028  delete Ghb5;
4029  if (Ghb60)
4030  delete Ghb60;
4031  if (Ghb61)
4032  delete Ghb61;
4033  if (Ghb6)
4034  delete Ghb6;
4035  if (Ghb7)
4036  delete Ghb7;
4037 
4038  if (G20hb60)
4039  delete G20hb60;
4040  if (G20hb61)
4041  delete G20hb61;
4042  if (G30hb60)
4043  delete G30hb60;
4044  if (G30hb61)
4045  delete G30hb61;
4046  if (G40hb60)
4047  delete G40hb60;
4048  if (G40hb61)
4049  delete G40hb61;
4050 
4051  if (Ghb1)
4052  delete Ghb1;
4053  //========================================================================================== 22-1 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4054  //======================================================================
4055  //======================================================================28.11.2018
4056  //======================================================================
4057  //======================================================================
4058 
4059  gStyle->SetOptStat(1110000);
4060  cout << " RBX HB Ratio plotsmore *****" << endl;
4061  cRBX31->Clear();
4063  cRBX31->Divide(3, 1);
4064  //================
4065  cRBX31->cd(1);
4066  G20hb6->GetZaxis()->SetLabelSize(0.025);
4067  G20hb6->SetXTitle(" #eta \b");
4068  G20hb6->SetYTitle(" #phi \b");
4069  G20hb6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4070  G20hb6->SetStats(0);
4071  G20hb6->Draw("COLZ");
4072  //================
4073  cRBX31->cd(2);
4074  G30hb6->GetZaxis()->SetLabelSize(0.025);
4075  G30hb6->SetXTitle(" #eta \b");
4076  G30hb6->SetYTitle(" #phi \b");
4077  G30hb6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4078  G30hb6->SetStats(0);
4079  G30hb6->Draw("COLZ");
4080  //================
4081  cRBX31->cd(3);
4082  G40hb6->GetZaxis()->SetLabelSize(0.025);
4083  G40hb6->SetXTitle(" #eta \b");
4084  G40hb6->SetYTitle(" #phi \b");
4085  G40hb6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4086  G40hb6->SetStats(0);
4087  G40hb6->Draw("COLZ");
4088  //================
4089 
4091  cRBX31->Update();
4092  cRBX31->Print("RBX-HB-3plotsmore.png");
4093  cRBX31->Clear();
4094 
4095  // clean-up
4096  if (G20hb6)
4097  delete G20hb6;
4098  if (G30hb6)
4099  delete G30hb6;
4100  if (G40hb6)
4101  delete G40hb6;
4102  gStyle->SetOptStat(0);
4103 
4105 
4106  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4107  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4108  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4109  for (int jphi = 0; jphi < njphi; jphi++) {
4110  for (int jeta = 0; jeta < njeta; jeta++) {
4111  for (int i = 0; i < nx; i++) {
4112  alexall[jeta][jphi][i] = 0.;
4113  }
4114  }
4115  } // nulling
4116 
4118 
4120  //======================================================================
4121  //======================================================================
4122  //======================================================================
4123  cout << " RBX general for HE **************************" << endl;
4124  TH2F *Ghe1KKK = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs1");
4125  TH2F *Ghe1LLL = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs10");
4126  TH2F *Ghe1 = (TH2F *)Ghe1LLL->Clone("Ghe1");
4127  Ghe1->Divide(Ghe1KKK, Ghe1LLL, 1, 1, "B"); // average A
4128  // Ghe1->Sumw2();
4129  // int nx = Ghe1->GetXaxis()->GetNbins(); // # LS
4130  // nx = maxbinsRBX; // # LS
4131  ny = Ghe1->GetYaxis()->GetNbins(); // # jetaphi indexes
4132  for (int j = 1; j <= ny; j++) {
4133  int jeta = (j - 1) / njphi; // jeta = 0-21
4134  if ((jeta < 8 && jeta > 2) || (jeta < 19 && jeta > 13)) {
4135  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4136  // cout<<"HE 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4137  // over LS:
4138  for (int i = 1; i <= nx; i++) {
4139  double ccc1 = Ghe1->GetBinContent(i, j);
4140  alexall[jeta][jphi][i - 1] = ccc1;
4141  // if( i == 1 ) cout<<"HE 54 for LS=1 ccc1= "<< ccc1 <<endl;
4142  } //i
4143  } //if
4144  } //j
4145  // clean-up
4146  if (Ghe1KKK)
4147  delete Ghe1KKK;
4148  if (Ghe1LLL)
4149  delete Ghe1LLL;
4150  // if (Ghe1) delete Ghe1;
4151 
4152  //====================================================================== alexhe[k][i]
4153  for (int jphi = 0; jphi < njphi; jphi++) {
4154  for (int i = 0; i < nx; i++) {
4155  double sumccc1 = 0.;
4156  int isum = 0;
4157  for (int jeta = 0; jeta < njeta; jeta++) {
4158  double ccc1 = alexall[jeta][jphi][i];
4159  if (ccc1 > 0.) {
4160  sumccc1 += ccc1;
4161  isum++;
4162  }
4163  } // for jeta
4164  if (isum > 0.)
4165  sumccc1 /= isum;
4166  alexhe[jphi][i] = sumccc1;
4167  }
4168  } //for for
4169  //====================================================================== blexhe[k][i]
4170  for (int keta = 0; keta < njeta; keta++) {
4171  for (int i = 0; i < nx; i++) {
4172  double sumccc1 = 0.;
4173  int isum = 0;
4174  for (int kphi = 0; kphi < njphi; kphi++) {
4175  double ccc1 = alexall[keta][kphi][i];
4176  if (ccc1 > 0.) {
4177  sumccc1 += ccc1;
4178  isum++;
4179  }
4180  } // for kphi
4181  if (isum > 0.)
4182  sumccc1 /= isum;
4183  blexhe[keta][i] = sumccc1;
4184  }
4185  } //for for
4187  //========================================================================================== 21 HE:: 2D jeta = 0 - 21 jphi =0 - 17
4188  //======================================================================
4189  //======================================================================
4190  //======================================================================
4191  //======================================================================
4192  cout << " RBX HE 2D plot *****" << endl;
4193  cRBX1->Clear();
4195  cRBX1->Divide(1, 1);
4196  cRBX1->cd(1);
4197  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4198  TH2F *Ghe42D = new TH2F("Ghe42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4199  TH2F *Ghe42D0 = new TH2F("Ghe42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4200  // TH2F* Ghe42D = new TH2F("Ghe42D","", 22, -11., 11., 18, 0., 18. );
4201  // TH2F* Ghe42D0 = new TH2F("Ghe42D0","", 22, -11., 11., 18, 0., 18. );
4202  TH2F *Ghe42DF = (TH2F *)Ghe42D0->Clone("Ghe42DF");
4203  for (int jphi = 0; jphi < njphi; jphi++) {
4204  for (int jeta = 0; jeta < njeta; jeta++) {
4205  for (int i = 0; i < nx; i++) {
4206  double ccc1 = alexall[jeta][jphi][i];
4207  int neweta = jeta - 11 - 0.5;
4208  if (jeta >= 11)
4209  neweta = jeta - 11 + 1.5;
4210  if (ccc1 > 0.) {
4211  Ghe42D->Fill(neweta, jphi, ccc1);
4212  Ghe42D0->Fill(neweta, jphi, 1.);
4213  }
4214  // if(ccc1>0.) {Ghe42D ->Fill(jeta-11,jphi,ccc1); Ghe42D0 ->Fill(jeta-11,jphi,1.); }
4215  }
4216  }
4217  }
4218  Ghe42DF->Divide(Ghe42D, Ghe42D0, 1, 1, "B"); // average A
4219  // Ghe1->Sumw2();
4220  gPad->SetGridy();
4221  gPad->SetGridx(); // gPad->SetLogz();
4222  Ghe42DF->SetMarkerStyle(20);
4223  Ghe42DF->SetMarkerSize(0.4);
4224  Ghe42DF->GetZaxis()->SetLabelSize(0.04);
4225  Ghe42DF->SetXTitle("<A>_RBX #eta \b");
4226  Ghe42DF->SetYTitle(" #phi \b");
4227  Ghe42DF->SetZTitle("<A>_RBX - All \b");
4228  Ghe42DF->SetMarkerColor(2);
4229  Ghe42DF->SetLineColor(2); // Ghe42DF->SetMaximum(1.000); // Ghe42DF->SetMinimum(1.0);
4230  Ghe42DF->Draw("COLZ");
4231 
4233  cRBX1->Update();
4234  cRBX1->Print("RBX-HE-2Dplot.png");
4235  cRBX1->Clear();
4236  // clean-up
4237  if (Ghe42D)
4238  delete Ghe42D;
4239  if (Ghe42D0)
4240  delete Ghe42D0;
4241  if (Ghe42DF)
4242  delete Ghe42DF;
4243 
4244  //========================================================================================== 61 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4245  //======================================================================
4246  //======================================================================
4247  //======================================================================
4248  //======================================================================
4249  cout << " RBX HE 1D plot *****" << endl;
4250  cRBX1->Clear();
4252  cRBX1->Divide(1, 1);
4253  cRBX1->cd(1);
4254  TH1F *GphiHE1D = new TH1F("GphiHE1D", "", 18, 0., 18.);
4255  TH1F *GphiHE1D0 = new TH1F("GphiHE1D0", "", 18, 0., 18.);
4256  TH1F *GphiHE1DF = (TH1F *)GphiHE1D0->Clone("GphiHE1DF");
4257  for (int jphi = 0; jphi < 18; jphi++) {
4258  for (int jeta = 0; jeta < 22; jeta++) {
4259  for (int i = 0; i < nx; i++) {
4260  double ccc1 = alexall[jeta][jphi][i];
4261  if (ccc1 > 0.) {
4262  GphiHE1D->Fill(jphi, ccc1);
4263  GphiHE1D0->Fill(jphi, 1.);
4264  }
4265  }
4266  }
4267  }
4268  // GphiHE1D->Sumw2();GphiHE1D0->Sumw2();
4269  GphiHE1DF->Divide(GphiHE1D, GphiHE1D0, 1, 1, "B"); // average A
4270  // GphiHE1DF->Sumw2();
4271  for (int jphi = 1; jphi < 19; jphi++) {
4272  GphiHE1DF->SetBinError(jphi, 0.01);
4273  }
4274  gPad->SetGridy();
4275  gPad->SetGridx(); // gPad->SetLogz();
4276  GphiHE1DF->SetMarkerStyle(20);
4277  GphiHE1DF->SetMarkerSize(1.4);
4278  GphiHE1DF->GetZaxis()->SetLabelSize(0.08);
4279  GphiHE1DF->SetXTitle("PHI of RBX\b");
4280  GphiHE1DF->SetYTitle(" <Amplitude> \b");
4281  GphiHE1DF->SetZTitle("<A>_PHI - All \b");
4282  GphiHE1DF->SetMarkerColor(4);
4283  GphiHE1DF->SetLineColor(4);
4284  GphiHE1DF->SetMinimum(0.8); // GphiHE1DF->SetMaximum(1.000);
4285  GphiHE1DF->Draw("Error");
4287  cRBX1->Update();
4288  cRBX1->Print("RBX-HE-1Dplot.png");
4289  cRBX1->Clear();
4290  // clean-up
4291  if (GphiHE1D)
4292  delete GphiHE1D;
4293  if (GphiHE1D0)
4294  delete GphiHE1D0;
4295  if (GphiHE1DF)
4296  delete GphiHE1DF;
4297 
4298  //========================================================================================== 62 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4299  //======================================================================
4300  //======================================================================
4301  //======================================================================
4302  //======================================================================
4303  cout << " RBX HE 11D plot *eta*" << endl;
4304  cRBX1->Clear();
4306  cRBX1->Divide(1, 1);
4307  cRBX1->cd(1);
4308  TH1F *GetaHE11D = new TH1F("GetaHE11D", "", 23, -11.5, 11.5);
4309  TH1F *GetaHE11D0 = new TH1F("GetaHE11D0", "", 23, -11.5, 11.5);
4310  TH1F *GetaHE11DF = (TH1F *)GetaHE11D0->Clone("GetaHE11DF");
4311 
4312  for (int jeta = 0; jeta < 22; jeta++) {
4313  for (int jphi = 0; jphi < 18; jphi++) {
4314  for (int i = 0; i < nx; i++) {
4315  double ccc1 = alexall[jeta][jphi][i];
4316  int neweta = jeta - 11 - 0.5;
4317  if (jeta >= 11)
4318  neweta = jeta - 11 + 1.5;
4319  if (ccc1 > 0.) {
4320  GetaHE11D->Fill(neweta, ccc1);
4321  GetaHE11D0->Fill(neweta, 1.);
4322  // if( i == 0 ) cout<<"62 HE: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4323  }
4324  }
4325  }
4326  }
4327  // GetaHE11D->Sumw2();GetaHE11D0->Sumw2();
4328  GetaHE11DF->Divide(GetaHE11D, GetaHE11D0, 1, 1, "B"); // average A
4329  // GetaHE11DF->Sumw2();
4330  for (int jeta = 1; jeta < 24; jeta++) {
4331  GetaHE11DF->SetBinError(jeta, 0.01);
4332  }
4333  gPad->SetGridy();
4334  gPad->SetGridx(); // gPad->SetLogz();
4335  GetaHE11DF->SetMarkerStyle(20);
4336  GetaHE11DF->SetMarkerSize(1.4);
4337  GetaHE11DF->GetZaxis()->SetLabelSize(0.08);
4338  GetaHE11DF->SetXTitle("#eta \b");
4339  GetaHE11DF->SetYTitle(" <A> \b");
4340  GetaHE11DF->SetZTitle("<A>_ETA - All \b");
4341  GetaHE11DF->SetMarkerColor(4);
4342  GetaHE11DF->SetLineColor(4);
4343  GetaHE11DF->SetMinimum(0.8); // GetaHE11DF->SetMaximum(1.000);
4344  GetaHE11DF->Draw("Error");
4345 
4347  cRBX1->Update();
4348  cRBX1->Print("RBX-HE-11Dplot.png");
4349  cRBX1->Clear();
4350  // clean-up
4351  if (GetaHE11D)
4352  delete GetaHE11D;
4353  if (GetaHE11D0)
4354  delete GetaHE11D0;
4355  if (GetaHE11DF)
4356  delete GetaHE11DF;
4357 
4358  //========================================================================================== 22 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4359  //======================================================================
4360  //======================================================================22.11.2018
4361  //======================================================================
4362  //======================================================================
4363 
4364  gStyle->SetOptStat(1110000);
4365  cout << " RBX HE Ratio plots *****" << endl;
4366  cRBX31->Clear();
4368  // gain stabilitY:
4369  // Rij = Aij / A1j , where i-over LSs, j-channels
4370  //
4371  // nx = maxbinsRBX; // # LS
4372  //
4373  double ccc0HE = 0.;
4374  cRBX31->Divide(3, 1);
4375  //================
4376  cRBX31->cd(1);
4377  // TH1F* Ghe5 = new TH1F("Ghe5","", nx, 1., nx+1.);
4378  TH1F *Ghe51 = new TH1F("Ghe51", "", nx, 1., nx + 1.);
4379  TH1F *Ghe50 = new TH1F("Ghe50", "", nx, 1., nx + 1.);
4380  TH1F *Ghe5 = (TH1F *)Ghe50->Clone("Ghe5");
4381  // j - etaphi index:
4382  for (int j = 1; j <= ny; j++) {
4383  ccc0HE = Ghe1->GetBinContent(1, j);
4384  // if(ccc0HE <=0.) for (int i=1;i<=nx;i++) {double ccc2 = Ghe1->GetBinContent(i,j);if(ccc2>0.){ccc0HE=ccc2;cout<<"!!! ccc0HE= "<<ccc0HE<<endl;break;} }
4385  if (ccc0HE <= 0.)
4386  for (int i = 1; i <= nx; i++) {
4387  double ccc2 = Ghe1->GetBinContent(i, j);
4388  if (ccc2 > 0.) {
4389  ccc0HE = ccc2;
4390  break;
4391  }
4392  }
4393  if (ccc0HE > 0.) {
4394  // i - # LSs:
4395  for (int i = 1; i <= nx; i++) {
4396  double ccc1 = Ghe1->GetBinContent(i, j);
4397  if (ccc1 > 0.) {
4398  double Rij = ccc1 / ccc0HE;
4399  // Ghe5 ->Fill( float(i), Rij);
4400  Ghe51->Fill(float(i), Rij);
4401  Ghe50->Fill(float(i), 1.);
4402  }
4403  }
4404  }
4405  }
4406  Ghe5->Divide(Ghe51, Ghe50, 1, 1, "B"); // average A
4407  for (int i = 1; i <= nx; i++) {
4408  Ghe5->SetBinError(i, 0.0001);
4409  }
4410  Ghe5->SetMarkerStyle(20);
4411  Ghe5->SetMarkerSize(0.4);
4412  Ghe5->GetYaxis()->SetLabelSize(0.04);
4413  Ghe5->SetMarkerColor(2);
4414  Ghe5->SetLineColor(0);
4415  Ghe5->SetXTitle(" iLS \b");
4416  Ghe5->SetYTitle(" <R> \b");
4417  Ghe5->SetTitle("<Ri> vs iLS \b");
4418  Ghe5->SetMinimum(0.); //Ghe5->SetMaximum(2.5);
4419  // gPad->SetLogy();
4420  gPad->SetGridy();
4421  gPad->SetGridx();
4422  Ghe5->SetStats(0);
4423  Ghe5->GetYaxis()->SetLabelSize(0.025);
4424  Ghe5->Draw("Error");
4425  //================
4426  cRBX31->cd(2);
4427  TH2F *Ghe60 = new TH2F("Ghe60", "", 22, -11., 11., 18, 0., 18.);
4428  TH2F *Ghe61 = new TH2F("Ghe61", "", 22, -11., 11., 18, 0., 18.);
4429  TH2F *Ghe6 = new TH2F("Ghe6", "", 22, -11., 11., 18, 0., 18.);
4430 
4431  TH2F *G20he60 = new TH2F("G20he60", "", 22, -11., 11., 18, 0., 18.);
4432  TH2F *G20he61 = new TH2F("G20he61", "", 22, -11., 11., 18, 0., 18.);
4433  TH2F *G20he6 = new TH2F("G20he6", "", 22, -11., 11., 18, 0., 18.);
4434  TH2F *G30he60 = new TH2F("G30he60", "", 22, -11., 11., 18, 0., 18.);
4435  TH2F *G30he61 = new TH2F("G30he61", "", 22, -11., 11., 18, 0., 18.);
4436  TH2F *G30he6 = new TH2F("G30he6", "", 22, -11., 11., 18, 0., 18.);
4437  TH2F *G40he60 = new TH2F("G40he60", "", 22, -11., 11., 18, 0., 18.);
4438  TH2F *G40he61 = new TH2F("G40he61", "", 22, -11., 11., 18, 0., 18.);
4439  TH2F *G40he6 = new TH2F("G40he6", "", 22, -11., 11., 18, 0., 18.);
4440  // j - etaphi index; i - # LSs;
4441  //
4442  // define mean and RMS:
4443  double sumjHE = 0.;
4444  int njHE = 0;
4445  double meanjHE = 0.;
4446  for (int j = 1; j <= ny; j++) {
4447  ccc0HE = Ghe1->GetBinContent(1, j);
4448  if (ccc0HE <= 0.)
4449  for (int i = 1; i <= nx; i++) {
4450  double ccc2 = Ghe1->GetBinContent(i, j);
4451  if (ccc2 > 0.) {
4452  ccc0HE = ccc2;
4453  break;
4454  }
4455  }
4456  if (ccc0HE > 0.) {
4457  for (int i = 1; i <= nx; i++) {
4458  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4459  if (ccc1 > 0.) {
4460  sumjHE += ccc1;
4461  njHE++;
4462  }
4463  }
4464  meanjHE = sumjHE / njHE;
4465  }
4466  } // j
4467 
4468  double ssumjHE = 0.;
4469  njHE = 0;
4470  double sigmajHE = 0.;
4471  for (int j = 1; j <= ny; j++) {
4472  ccc0HE = Ghe1->GetBinContent(1, j);
4473  if (ccc0HE <= 0.)
4474  for (int i = 1; i <= nx; i++) {
4475  double ccc2 = Ghe1->GetBinContent(i, j);
4476  if (ccc2 > 0.) {
4477  ccc0HE = ccc2;
4478  break;
4479  }
4480  }
4481  if (ccc0HE > 0.) {
4482  for (int i = 1; i <= nx; i++) {
4483  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4484  if (ccc1 > 0.) {
4485  ssumjHE += (ccc1 - meanjHE) * (ccc1 - meanjHE);
4486  njHE++;
4487  }
4488  }
4489  sigmajHE = sqrt(ssumjHE / njHE);
4490  }
4491  } // j
4492 
4493  double dif3rmsHEMIN = meanjHE - 3 * sigmajHE;
4494  if (dif3rmsHEMIN < 0.)
4495  dif3rmsHEMIN = 0.;
4496  double dif3rmsHEMAX = meanjHE + 3 * sigmajHE;
4497  cout << "22HE-2 meanjHE= " << meanjHE << " sigmajHE= " << sigmajHE << " dif3rmsHEMIN= " << dif3rmsHEMIN
4498  << " dif3rmsHEMAX= " << dif3rmsHEMAX << endl;
4499 
4500  double MAXdif3rmsHEMIN = dif3rmsHEMIN;
4501  double MINdif3rmsHEMAX = dif3rmsHEMAX;
4502  if (MAXdif3rmsHEMIN < 0.95)
4503  MAXdif3rmsHEMIN = 0.95;
4504  if (MINdif3rmsHEMAX > 1.05)
4505  MINdif3rmsHEMAX = 1.05;
4506  cout << "22HE-2 MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4507  //
4508  for (int j = 1; j <= ny; j++) {
4509  ccc0HE = Ghe1->GetBinContent(1, j);
4510  if (ccc0HE <= 0.)
4511  for (int i = 1; i <= nx; i++) {
4512  double ccc2 = Ghe1->GetBinContent(i, j);
4513  if (ccc2 > 0.) {
4514  ccc0HE = ccc2;
4515  break;
4516  }
4517  }
4518  if (ccc0HE > 0.) {
4519  int jeta = (j - 1) / 18; // jeta = 0-21
4520  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
4521  // i - # LSs:
4522  for (int i = 1; i <= nx; i++) {
4523  double ccc1 = Ghe1->GetBinContent(i, j);
4524  if (ccc1 > 0.) {
4525  double Rij = ccc1 / ccc0HE;
4526  if (Rij < MAXdif3rmsHEMIN || Rij > MINdif3rmsHEMAX) {
4527  Ghe61->Fill(jeta - 11, jphi, Rij);
4528  Ghe60->Fill(jeta - 11, jphi, 1.);
4529  }
4530  if (Rij < 0.8 || Rij > 1.2) {
4531  G20he61->Fill(jeta - 11, jphi, Rij);
4532  G20he60->Fill(jeta - 11, jphi, 1.);
4533  }
4534  if (Rij < 0.7 || Rij > 1.3) {
4535  G30he61->Fill(jeta - 11, jphi, Rij);
4536  G30he60->Fill(jeta - 11, jphi, 1.);
4537  }
4538  if (Rij < 0.6 || Rij > 1.4) {
4539  G40he61->Fill(jeta - 11, jphi, Rij);
4540  G40he60->Fill(jeta - 11, jphi, 1.);
4541  }
4542  } //if(ccc1>0.
4543  } // i
4544  } //if(ccc0HE>0
4545  } // j
4546  Ghe6->Divide(Ghe61, Ghe60, 1, 1, "B"); // average R
4547  G20he6->Divide(G20he61, G20he60, 1, 1, "B"); // average R
4548  G30he6->Divide(G30he61, G30he60, 1, 1, "B"); // average R
4549  G40he6->Divide(G40he61, G40he60, 1, 1, "B"); // average R
4550 
4551  // Ghe6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
4552  // Ghe6->GetZaxis()->SetLabelOffset(-0.05);
4553  Ghe6->GetZaxis()->SetLabelSize(0.025);
4554 
4555  Ghe6->SetXTitle(" #eta \b");
4556  Ghe6->SetYTitle(" #phi \b");
4557  Ghe6->SetTitle(
4558  "<Rj> for |1-<R>| > 0.05 \b"); // Ghe6->SetMaximum(1.000); // Ghe6->SetMinimum(1.0); //Ghe6->SetZTitle("Rij averaged over LSs \b"); //Ghe6->GetZaxis()->SetLabelSize(0.04); //Ghe6->SetMarkerStyle(20);// Ghe6->SetMarkerSize(0.4);//Ghe6->SetMarkerColor(2); //Ghe6->SetLineColor(2);
4559  //gStyle->SetOptStat(kFALSE);
4560  Ghe6->SetStats(0);
4561  Ghe6->Draw("COLZ");
4562  //================
4563  cRBX31->cd(3);
4564  TH1F *Ghe7 = new TH1F("Ghe7", "", 120, 0.4, 1.6);
4565  // j - etaphi index:
4566  for (int j = 1; j <= ny; j++) {
4567  ccc0HE = Ghe1->GetBinContent(1, j);
4568  if (ccc0HE <= 0.)
4569  for (int i = 1; i <= nx; i++) {
4570  double ccc2 = Ghe1->GetBinContent(i, j);
4571  if (ccc2 > 0.) {
4572  ccc0HE = ccc2;
4573  break;
4574  }
4575  }
4576  if (ccc0HE > 0.) {
4577  // i - # LSs:
4578  for (int i = 1; i <= nx; i++) {
4579  double ccc1 = Ghe1->GetBinContent(i, j);
4580  if (ccc1 > 0.) {
4581  double Rij = ccc1 / ccc0HE;
4582  Ghe7->Fill(Rij);
4583  }
4584  }
4585  }
4586  }
4587  Ghe7->SetMarkerStyle(20);
4588  Ghe7->SetMarkerSize(0.4);
4589  Ghe7->GetYaxis()->SetLabelSize(0.04);
4590  Ghe7->SetMarkerColor(2);
4591  Ghe7->SetLineColor(0);
4592  Ghe7->SetYTitle(" N \b");
4593  Ghe7->SetXTitle(" Rij \b");
4594  Ghe7->SetTitle(" Rij \b");
4595  //Ghe7->SetMinimum(0.8);Ghe7->SetMaximum(500.);
4596  gPad->SetGridy();
4597  gPad->SetGridx(); // gPad->SetLogy();
4598  // Ghe7->SetStats(1110000);
4599  Ghe7->GetYaxis()->SetLabelSize(0.025);
4600  Ghe7->Draw("Error");
4601  Float_t ymaxHE = Ghe7->GetMaximum();
4602  cout << "22HE-3 ymaxHE= " << ymaxHE << " MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN
4603  << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4604  TLine *lineHE = new TLine(MAXdif3rmsHEMIN, 0., MAXdif3rmsHEMIN, ymaxHE);
4605  lineHE->SetLineColor(kBlue);
4606  lineHE->Draw();
4607  TLine *line1HE = new TLine(MINdif3rmsHEMAX, 0., MINdif3rmsHEMAX, ymaxHE);
4608  line1HE->SetLineColor(kBlue);
4609  line1HE->Draw();
4610  //================
4612  cRBX31->Update();
4613  cRBX31->Print("RBX-HE-3plots.png");
4614  cRBX31->Clear();
4615  // clean-up
4616  if (Ghe5)
4617  delete Ghe5;
4618  if (Ghe60)
4619  delete Ghe60;
4620  if (Ghe61)
4621  delete Ghe61;
4622  if (Ghe6)
4623  delete Ghe6;
4624  if (Ghe7)
4625  delete Ghe7;
4626 
4627  if (G20he60)
4628  delete G20he60;
4629  if (G20he61)
4630  delete G20he61;
4631  if (G30he60)
4632  delete G30he60;
4633  if (G30he61)
4634  delete G30he61;
4635  if (G40he60)
4636  delete G40he60;
4637  if (G40he61)
4638  delete G40he61;
4639 
4640  if (Ghe1)
4641  delete Ghe1;
4642  //========================================================================================== 22-1 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4643  //======================================================================
4644  //======================================================================28.11.2018
4645  //======================================================================
4646  //======================================================================
4647 
4648  gStyle->SetOptStat(1110000);
4649  cout << " RBX HE Ratio plotsmore *****" << endl;
4650  cRBX31->Clear();
4652  cRBX31->Divide(3, 1);
4653  //================
4654  cRBX31->cd(1);
4655  G20he6->GetZaxis()->SetLabelSize(0.025);
4656  G20he6->SetXTitle(" #eta \b");
4657  G20he6->SetYTitle(" #phi \b");
4658  G20he6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4659  G20he6->SetStats(0);
4660  G20he6->Draw("COLZ");
4661  //================
4662  cRBX31->cd(2);
4663  G30he6->GetZaxis()->SetLabelSize(0.025);
4664  G30he6->SetXTitle(" #eta \b");
4665  G30he6->SetYTitle(" #phi \b");
4666  G30he6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4667  G30he6->SetStats(0);
4668  G30he6->Draw("COLZ");
4669  //================
4670  cRBX31->cd(3);
4671  G40he6->GetZaxis()->SetLabelSize(0.025);
4672  G40he6->SetXTitle(" #eta \b");
4673  G40he6->SetYTitle(" #phi \b");
4674  G40he6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4675  G40he6->SetStats(0);
4676  G40he6->Draw("COLZ");
4677  //================
4678 
4680  cRBX31->Update();
4681  cRBX31->Print("RBX-HE-3plotsmore.png");
4682  cRBX31->Clear();
4683 
4684  // clean-up
4685  if (G20he6)
4686  delete G20he6;
4687  if (G30he6)
4688  delete G30he6;
4689  if (G40he6)
4690  delete G40he6;
4691  gStyle->SetOptStat(0);
4693 
4694  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4695  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4696  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4697  for (int jphi = 0; jphi < njphi; jphi++) {
4698  for (int jeta = 0; jeta < njeta; jeta++) {
4699  for (int i = 0; i < nx; i++) {
4700  alexall[jeta][jphi][i] = 0.;
4701  }
4702  }
4703  } // nulling
4704 
4706 
4708  //======================================================================
4709  //======================================================================
4710  //======================================================================
4711  cout << " RBX general for HO **************************" << endl;
4712  TH2F *Gho1KKK = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs2");
4713  TH2F *Gho1LLL = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs20");
4714  TH2F *Gho1 = (TH2F *)Gho1LLL->Clone("Gho1");
4715  Gho1->Divide(Gho1KKK, Gho1LLL, 1, 1, "B"); // average A
4716  // Gho1->Sumw2();
4717  // int nx = Gho1->GetXaxis()->GetNbins(); // # LS
4718  // nx = maxbinsRBX; // # LS
4719  ny = Gho1->GetYaxis()->GetNbins(); // # jetaphi indexes
4720  for (int j = 1; j <= ny; j++) {
4721  int jeta = (j - 1) / njphi; // jeta = 0-21
4722  if (jeta < 15 && jeta > 6) {
4723  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4724  // cout<<"HO 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4725  // over LS:
4726  for (int i = 1; i <= nx; i++) {
4727  double ccc1 = Gho1->GetBinContent(i, j);
4728  alexall[jeta][jphi][i - 1] = ccc1;
4729  // if( i == 1 ) cout<<"HO 54 for LS=1 ccc1= "<< ccc1 <<endl;
4730  } //i
4731  } //if
4732  } //j
4733  // clean-up
4734  if (Gho1KKK)
4735  delete Gho1KKK;
4736  if (Gho1LLL)
4737  delete Gho1LLL;
4738  // if (Gho1) delete Gho1;
4739 
4740  //====================================================================== alexho[k][i]
4741  for (int jphi = 0; jphi < njphi; jphi++) {
4742  for (int i = 0; i < nx; i++) {
4743  double sumccc1 = 0.;
4744  int isum = 0;
4745  for (int jeta = 0; jeta < njeta; jeta++) {
4746  double ccc1 = alexall[jeta][jphi][i];
4747  if (ccc1 > 0.) {
4748  sumccc1 += ccc1;
4749  isum++;
4750  }
4751  } // for jeta
4752  if (isum > 0.)
4753  sumccc1 /= isum;
4754  alexho[jphi][i] = sumccc1;
4755  }
4756  } //for for
4757  //====================================================================== blexho[k][i]
4758  for (int keta = 0; keta < njeta; keta++) {
4759  for (int i = 0; i < nx; i++) {
4760  double sumccc1 = 0.;
4761  int isum = 0;
4762  for (int kphi = 0; kphi < njphi; kphi++) {
4763  double ccc1 = alexall[keta][kphi][i];
4764  if (ccc1 > 0.) {
4765  sumccc1 += ccc1;
4766  isum++;
4767  }
4768  } // for kphi
4769  if (isum > 0.)
4770  sumccc1 /= isum;
4771  blexho[keta][i] = sumccc1;
4772  }
4773  } //for for
4774 
4776  //========================================================================================== 33 HO:: 2D jeta = 0 - 21 jphi =0 - 17
4777  //======================================================================
4778  //======================================================================
4779  //======================================================================
4780  //======================================================================
4781  cout << " RBX HO 2D plot *****" << endl;
4782  cRBX1->Clear();
4784  cRBX1->Divide(1, 1);
4785  cRBX1->cd(1);
4786  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4787  TH2F *Gho42D = new TH2F("Gho42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4788  TH2F *Gho42D0 = new TH2F("Gho42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4789  // TH2F* Gho42D = new TH2F("Gho42D","", 22, -11., 11., 18, 0., 18. );
4790  // TH2F* Gho42D0 = new TH2F("Gho42D0","", 22, -11., 11., 18, 0., 18. );
4791  TH2F *Gho42DF = (TH2F *)Gho42D0->Clone("Gho42DF");
4792  for (int jphi = 0; jphi < njphi; jphi++) {
4793  for (int jeta = 0; jeta < njeta; jeta++) {
4794  for (int i = 0; i < nx; i++) {
4795  double ccc1 = alexall[jeta][jphi][i];
4796  int neweta = jeta - 11 - 0.5;
4797  if (jeta >= 11)
4798  neweta = jeta - 11 + 1.5;
4799  if (ccc1 > 0.) {
4800  Gho42D->Fill(neweta, jphi, ccc1);
4801  Gho42D0->Fill(neweta, jphi, 1.);
4802  }
4803  // if(ccc1>0.) {Gho42D ->Fill(jeta-11,jphi,ccc1); Gho42D0 ->Fill(jeta-11,jphi,1.); }
4804  }
4805  }
4806  }
4807  Gho42DF->Divide(Gho42D, Gho42D0, 1, 1, "B"); // average A
4808  // Gho1->Sumw2();
4809  gPad->SetGridy();
4810  gPad->SetGridx(); // gPad->SetLogz();
4811  Gho42DF->SetMarkerStyle(20);
4812  Gho42DF->SetMarkerSize(0.4);
4813  Gho42DF->GetZaxis()->SetLabelSize(0.04);
4814  Gho42DF->SetXTitle("<A>_RBX #eta \b");
4815  Gho42DF->SetYTitle(" #phi \b");
4816  Gho42DF->SetZTitle("<A>_RBX - All \b");
4817  Gho42DF->SetMarkerColor(2);
4818  Gho42DF->SetLineColor(2); // Gho42DF->SetMaximum(1.000); // Gho42DF->SetMinimum(1.0);
4819  Gho42DF->Draw("COLZ");
4820 
4822  cRBX1->Update();
4823  cRBX1->Print("RBX-HO-2Dplot.png");
4824  cRBX1->Clear();
4825  // clean-up
4826  if (Gho42D)
4827  delete Gho42D;
4828  if (Gho42D0)
4829  delete Gho42D0;
4830  if (Gho42DF)
4831  delete Gho42DF;
4832 
4833  //========================================================================================== 61 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4834  //======================================================================
4835  //======================================================================
4836  //======================================================================
4837  //======================================================================
4838  cout << " RBX HO 1D plot *****" << endl;
4839  cRBX1->Clear();
4841  cRBX1->Divide(1, 1);
4842  cRBX1->cd(1);
4843  TH1F *GphiHO1D = new TH1F("GphiHO1D", "", 18, 0., 18.);
4844  TH1F *GphiHO1D0 = new TH1F("GphiHO1D0", "", 18, 0., 18.);
4845  TH1F *GphiHO1DF = (TH1F *)GphiHO1D0->Clone("GphiHO1DF");
4846  for (int jphi = 0; jphi < 18; jphi++) {
4847  for (int jeta = 0; jeta < 22; jeta++) {
4848  for (int i = 0; i < nx; i++) {
4849  double ccc1 = alexall[jeta][jphi][i];
4850  if (ccc1 > 0.) {
4851  GphiHO1D->Fill(jphi, ccc1);
4852  GphiHO1D0->Fill(jphi, 1.);
4853  }
4854  }
4855  }
4856  }
4857  // GphiHO1D->Sumw2();GphiHO1D0->Sumw2();
4858  GphiHO1DF->Divide(GphiHO1D, GphiHO1D0, 1, 1, "B"); // average A
4859  // GphiHO1DF->Sumw2();
4860  for (int jphi = 1; jphi < 19; jphi++) {
4861  GphiHO1DF->SetBinError(jphi, 0.01);
4862  }
4863  gPad->SetGridy();
4864  gPad->SetGridx(); // gPad->SetLogz();
4865  GphiHO1DF->SetMarkerStyle(20);
4866  GphiHO1DF->SetMarkerSize(1.4);
4867  GphiHO1DF->GetZaxis()->SetLabelSize(0.08);
4868  GphiHO1DF->SetXTitle("PHI of RBX\b");
4869  GphiHO1DF->SetYTitle(" <Amplitude> \b");
4870  GphiHO1DF->SetZTitle("<A>_PHI - All \b");
4871  GphiHO1DF->SetMarkerColor(4);
4872  GphiHO1DF->SetLineColor(4);
4873  GphiHO1DF->SetMinimum(0.8); // GphiHO1DF->SetMaximum(1.000);
4874  GphiHO1DF->Draw("Error");
4876  cRBX1->Update();
4877  cRBX1->Print("RBX-HO-1Dplot.png");
4878  cRBX1->Clear();
4879  // clean-up
4880  if (GphiHO1D)
4881  delete GphiHO1D;
4882  if (GphiHO1D0)
4883  delete GphiHO1D0;
4884  if (GphiHO1DF)
4885  delete GphiHO1DF;
4886 
4887  //========================================================================================== 62 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4888  //======================================================================
4889  //======================================================================
4890  //======================================================================
4891  //======================================================================
4892  cout << " RBX HO 11D plot *eta*" << endl;
4893  cRBX1->Clear();
4895  cRBX1->Divide(1, 1);
4896  cRBX1->cd(1);
4897  TH1F *GetaHO11D = new TH1F("GetaHO11D", "", 23, -11.5, 11.5);
4898  TH1F *GetaHO11D0 = new TH1F("GetaHO11D0", "", 23, -11.5, 11.5);
4899  TH1F *GetaHO11DF = (TH1F *)GetaHO11D0->Clone("GetaHO11DF");
4900 
4901  for (int jeta = 0; jeta < 22; jeta++) {
4902  for (int jphi = 0; jphi < 18; jphi++) {
4903  for (int i = 0; i < nx; i++) {
4904  double ccc1 = alexall[jeta][jphi][i];
4905  int neweta = jeta - 11 - 0.5;
4906  if (jeta >= 11)
4907  neweta = jeta - 11 + 1.5;
4908  if (ccc1 > 0.) {
4909  GetaHO11D->Fill(neweta, ccc1);
4910  GetaHO11D0->Fill(neweta, 1.);
4911  // if( i == 0 ) cout<<"62 HO: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4912  }
4913  }
4914  }
4915  }
4916  // GetaHO11D->Sumw2();GetaHO11D0->Sumw2();
4917  GetaHO11DF->Divide(GetaHO11D, GetaHO11D0, 1, 1, "B"); // average A
4918  // GetaHO11DF->Sumw2();
4919  for (int jeta = 1; jeta < 24; jeta++) {
4920  GetaHO11DF->SetBinError(jeta, 0.01);
4921  }
4922  gPad->SetGridy();
4923  gPad->SetGridx(); // gPad->SetLogz();
4924  GetaHO11DF->SetMarkerStyle(20);
4925  GetaHO11DF->SetMarkerSize(1.4);
4926  GetaHO11DF->GetZaxis()->SetLabelSize(0.08);
4927  GetaHO11DF->SetXTitle("#eta \b");
4928  GetaHO11DF->SetYTitle(" <A> \b");
4929  GetaHO11DF->SetZTitle("<A>_ETA - All \b");
4930  GetaHO11DF->SetMarkerColor(4);
4931  GetaHO11DF->SetLineColor(4);
4932  GetaHO11DF->SetMinimum(0.8); // GetaHO11DF->SetMaximum(1.000);
4933  GetaHO11DF->Draw("Error");
4934 
4936  cRBX1->Update();
4937  cRBX1->Print("RBX-HO-11Dplot.png");
4938  cRBX1->Clear();
4939  // clean-up
4940  if (GetaHO11D)
4941  delete GetaHO11D;
4942  if (GetaHO11D0)
4943  delete GetaHO11D0;
4944  if (GetaHO11DF)
4945  delete GetaHO11DF;
4946 
4947  //========================================================================================== 22 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4948  //======================================================================
4949  //======================================================================22.11.2018
4950  //======================================================================
4951  //======================================================================
4952 
4953  gStyle->SetOptStat(1110000);
4954  cout << " RBX HO Ratio plots *****" << endl;
4955  cRBX31->Clear();
4957  // gain stabilitY:
4958  // Rij = Aij / A1j , where i-over LSs, j-channels
4959  //
4960  // nx = maxbinsRBX; // # LS
4961  //
4962  double ccc0HO = 0.;
4963  cRBX31->Divide(3, 1);
4964  //================
4965  cRBX31->cd(1);
4966  // TH1F* Gho5 = new TH1F("Gho5","", nx, 1., nx+1.);
4967  TH1F *Gho51 = new TH1F("Gho51", "", nx, 1., nx + 1.);
4968  TH1F *Gho50 = new TH1F("Gho50", "", nx, 1., nx + 1.);
4969  TH1F *Gho5 = (TH1F *)Gho50->Clone("Gho5");
4970  // j - etaphi index:
4971  for (int j = 1; j <= ny; j++) {
4972  ccc0HO = Gho1->GetBinContent(1, j);
4973  // if(ccc0HO <=0.) for (int i=1;i<=nx;i++) {double ccc2 = Gho1->GetBinContent(i,j);if(ccc2>0.){ccc0HO=ccc2;cout<<"!!! ccc0HO= "<<ccc0HO<<endl;break;} }
4974  if (ccc0HO <= 0.)
4975  for (int i = 1; i <= nx; i++) {
4976  double ccc2 = Gho1->GetBinContent(i, j);
4977  if (ccc2 > 0.) {
4978  ccc0HO = ccc2;
4979  break;
4980  }
4981  }
4982  if (ccc0HO > 0.) {
4983  // i - # LSs:
4984  for (int i = 1; i <= nx; i++) {
4985  double ccc1 = Gho1->GetBinContent(i, j);
4986  if (ccc1 > 0.) {
4987  double Rij = ccc1 / ccc0HO;
4988  // Gho5 ->Fill( float(i), Rij);
4989  Gho51->Fill(float(i), Rij);
4990  Gho50->Fill(float(i), 1.);
4991  }
4992  }
4993  }
4994  }
4995  Gho5->Divide(Gho51, Gho50, 1, 1, "B"); // average A
4996  for (int i = 1; i <= nx; i++) {
4997  Gho5->SetBinError(i, 0.0001);
4998  }
4999  Gho5->SetMarkerStyle(20);
5000  Gho5->SetMarkerSize(0.4);
5001  Gho5->GetYaxis()->SetLabelSize(0.04);
5002  Gho5->SetMarkerColor(2);
5003  Gho5->SetLineColor(0);
5004  Gho5->SetXTitle(" iLS \b");
5005  Gho5->SetYTitle(" <R> \b");
5006  Gho5->SetTitle("<Ri> vs iLS \b");
5007  Gho5->SetMinimum(0.); //Gho5->SetMaximum(2.5);
5008  // gPad->SetLogy();
5009  gPad->SetGridy();
5010  gPad->SetGridx();
5011  Gho5->SetStats(0);
5012  Gho5->GetYaxis()->SetLabelSize(0.025);
5013  Gho5->Draw("Error");
5014  //================
5015  cRBX31->cd(2);
5016  TH2F *Gho60 = new TH2F("Gho60", "", 22, -11., 11., 18, 0., 18.);
5017  TH2F *Gho61 = new TH2F("Gho61", "", 22, -11., 11., 18, 0., 18.);
5018  TH2F *Gho6 = new TH2F("Gho6", "", 22, -11., 11., 18, 0., 18.);
5019 
5020  TH2F *G20ho60 = new TH2F("G20ho60", "", 22, -11., 11., 18, 0., 18.);
5021  TH2F *G20ho61 = new TH2F("G20ho61", "", 22, -11., 11., 18, 0., 18.);
5022  TH2F *G20ho6 = new TH2F("G20ho6", "", 22, -11., 11., 18, 0., 18.);
5023  TH2F *G30ho60 = new TH2F("G30ho60", "", 22, -11., 11., 18, 0., 18.);
5024  TH2F *G30ho61 = new TH2F("G30ho61", "", 22, -11., 11., 18, 0., 18.);
5025  TH2F *G30ho6 = new TH2F("G30ho6", "", 22, -11., 11., 18, 0., 18.);
5026  TH2F *G40ho60 = new TH2F("G40ho60", "", 22, -11., 11., 18, 0., 18.);
5027  TH2F *G40ho61 = new TH2F("G40ho61", "", 22, -11., 11., 18, 0., 18.);
5028  TH2F *G40ho6 = new TH2F("G40ho6", "", 22, -11., 11., 18, 0., 18.);
5029 
5030  // j - etaphi index; i - # LSs;
5031  //
5032  // define mean and RMS:
5033  double sumjHO = 0.;
5034  int njHO = 0;
5035  double meanjHO = 0.;
5036  for (int j = 1; j <= ny; j++) {
5037  ccc0HO = Gho1->GetBinContent(1, j);
5038  if (ccc0HO <= 0.)
5039  for (int i = 1; i <= nx; i++) {
5040  double ccc2 = Gho1->GetBinContent(i, j);
5041  if (ccc2 > 0.) {
5042  ccc0HO = ccc2;
5043  break;
5044  }
5045  }
5046  if (ccc0HO > 0.) {
5047  for (int i = 1; i <= nx; i++) {
5048  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5049  if (ccc1 > 0.) {
5050  sumjHO += ccc1;
5051  njHO++;
5052  }
5053  }
5054  meanjHO = sumjHO / njHO;
5055  }
5056  } // j
5057 
5058  double ssumjHO = 0.;
5059  njHO = 0;
5060  double sigmajHO = 0.;
5061  for (int j = 1; j <= ny; j++) {
5062  ccc0HO = Gho1->GetBinContent(1, j);
5063  if (ccc0HO <= 0.)
5064  for (int i = 1; i <= nx; i++) {
5065  double ccc2 = Gho1->GetBinContent(i, j);
5066  if (ccc2 > 0.) {
5067  ccc0HO = ccc2;
5068  break;
5069  }
5070  }
5071  if (ccc0HO > 0.) {
5072  for (int i = 1; i <= nx; i++) {
5073  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5074  if (ccc1 > 0.) {
5075  ssumjHO += (ccc1 - meanjHO) * (ccc1 - meanjHO);
5076  njHO++;
5077  }
5078  }
5079  sigmajHO = sqrt(ssumjHO / njHO);
5080  }
5081  } // j
5082 
5083  double dif3rmsHOMIN = meanjHO - 3 * sigmajHO;
5084  if (dif3rmsHOMIN < 0.)
5085  dif3rmsHOMIN = 0.;
5086  double dif3rmsHOMAX = meanjHO + 3 * sigmajHO;
5087  cout << "22HO-2 meanjHO= " << meanjHO << " sigmajHO= " << sigmajHO << " dif3rmsHOMIN= " << dif3rmsHOMIN
5088  << " dif3rmsHOMAX= " << dif3rmsHOMAX << endl;
5089 
5090  double MAXdif3rmsHOMIN = dif3rmsHOMIN;
5091  double MINdif3rmsHOMAX = dif3rmsHOMAX;
5092  if (MAXdif3rmsHOMIN < 0.95)
5093  MAXdif3rmsHOMIN = 0.95;
5094  if (MINdif3rmsHOMAX > 1.05)
5095  MINdif3rmsHOMAX = 1.05;
5096  cout << "22HO-2 MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5097  //
5098  for (int j = 1; j <= ny; j++) {
5099  ccc0HO = Gho1->GetBinContent(1, j);
5100  if (ccc0HO <= 0.)
5101  for (int i = 1; i <= nx; i++) {
5102  double ccc2 = Gho1->GetBinContent(i, j);
5103  if (ccc2 > 0.) {
5104  ccc0HO = ccc2;
5105  break;
5106  }
5107  }
5108  if (ccc0HO > 0.) {
5109  int jeta = (j - 1) / 18; // jeta = 0-21
5110  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5111  // i - # LSs:
5112  for (int i = 1; i <= nx; i++) {
5113  double ccc1 = Gho1->GetBinContent(i, j);
5114  if (ccc1 > 0.) {
5115  double Rij = ccc1 / ccc0HO;
5116  if (Rij < MAXdif3rmsHOMIN || Rij > MINdif3rmsHOMAX) {
5117  Gho61->Fill(jeta - 11, jphi, Rij);
5118  Gho60->Fill(jeta - 11, jphi, 1.);
5119  }
5120  if (Rij < 0.8 || Rij > 1.2) {
5121  G20ho61->Fill(jeta - 11, jphi, Rij);
5122  G20ho60->Fill(jeta - 11, jphi, 1.);
5123  }
5124  if (Rij < 0.7 || Rij > 1.3) {
5125  G30ho61->Fill(jeta - 11, jphi, Rij);
5126  G30ho60->Fill(jeta - 11, jphi, 1.);
5127  }
5128  if (Rij < 0.6 || Rij > 1.4) {
5129  G40ho61->Fill(jeta - 11, jphi, Rij);
5130  G40ho60->Fill(jeta - 11, jphi, 1.);
5131  }
5132  } //if(ccc1>0.
5133  } // i
5134  } //if(ccc0HO>0
5135  } // j
5136  Gho6->Divide(Gho61, Gho60, 1, 1, "B"); // average R
5137  G20ho6->Divide(G20ho61, G20ho60, 1, 1, "B"); // average R
5138  G30ho6->Divide(G30ho61, G30ho60, 1, 1, "B"); // average R
5139  G40ho6->Divide(G40ho61, G40ho60, 1, 1, "B"); // average R
5140  // Gho6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5141  // Gho6->GetZaxis()->SetLabelOffset(-0.05);
5142  Gho6->GetZaxis()->SetLabelSize(0.025);
5143 
5144  Gho6->SetXTitle(" #eta \b");
5145  Gho6->SetYTitle(" #phi \b");
5146  Gho6->SetTitle(
5147  "<Rj> for |1-<R>| > 0.05 \b"); // Gho6->SetMaximum(1.000); // Gho6->SetMinimum(1.0); //Gho6->SetZTitle("Rij averaged over LSs \b"); //Gho6->GetZaxis()->SetLabelSize(0.04); //Gho6->SetMarkerStyle(20);// Gho6->SetMarkerSize(0.4);//Gho6->SetMarkerColor(2); //Gho6->SetLineColor(2);
5148  //gStyle->SetOptStat(kFALSE);
5149  Gho6->SetStats(0);
5150  Gho6->Draw("COLZ");
5151  //================
5152  cRBX31->cd(3);
5153  TH1F *Gho7 = new TH1F("Gho7", "", 120, 0.4, 1.6);
5154  // j - etaphi index:
5155  for (int j = 1; j <= ny; j++) {
5156  ccc0HO = Gho1->GetBinContent(1, j);
5157  if (ccc0HO <= 0.)
5158  for (int i = 1; i <= nx; i++) {
5159  double ccc2 = Gho1->GetBinContent(i, j);
5160  if (ccc2 > 0.) {
5161  ccc0HO = ccc2;
5162  break;
5163  }
5164  }
5165  if (ccc0HO > 0.) {
5166  // i - # LSs:
5167  for (int i = 1; i <= nx; i++) {
5168  double ccc1 = Gho1->GetBinContent(i, j);
5169  if (ccc1 > 0.) {
5170  double Rij = ccc1 / ccc0HO;
5171  Gho7->Fill(Rij);
5172  }
5173  }
5174  }
5175  }
5176  Gho7->SetMarkerStyle(20);
5177  Gho7->SetMarkerSize(0.4);
5178  Gho7->GetYaxis()->SetLabelSize(0.04);
5179  Gho7->SetMarkerColor(2);
5180  Gho7->SetLineColor(0);
5181  Gho7->SetYTitle(" N \b");
5182  Gho7->SetXTitle(" Rij \b");
5183  Gho7->SetTitle(" Rij \b");
5184  //Gho7->SetMinimum(0.8);Gho7->SetMaximum(500.);
5185  gPad->SetGridy();
5186  gPad->SetGridx(); // gPad->SetLogy();
5187  // Gho7->SetStats(1110000);
5188  Gho7->GetYaxis()->SetLabelSize(0.025);
5189  Gho7->Draw("Error");
5190  Float_t ymaxHO = Gho7->GetMaximum();
5191  cout << "22HO-3 ymaxHO= " << ymaxHO << " MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN
5192  << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5193  TLine *lineHO = new TLine(MAXdif3rmsHOMIN, 0., MAXdif3rmsHOMIN, ymaxHO);
5194  lineHO->SetLineColor(kBlue);
5195  lineHO->Draw();
5196  TLine *line1HO = new TLine(MINdif3rmsHOMAX, 0., MINdif3rmsHOMAX, ymaxHO);
5197  line1HO->SetLineColor(kBlue);
5198  line1HO->Draw();
5199  //================
5201  cRBX31->Update();
5202  cRBX31->Print("RBX-HO-3plots.png");
5203  cRBX31->Clear();
5204  // clean-up
5205  if (Gho5)
5206  delete Gho5;
5207  if (Gho60)
5208  delete Gho60;
5209  if (Gho61)
5210  delete Gho61;
5211  if (Gho6)
5212  delete Gho6;
5213  if (Gho7)
5214  delete Gho7;
5215 
5216  if (G20ho60)
5217  delete G20ho60;
5218  if (G20ho61)
5219  delete G20ho61;
5220  if (G30ho60)
5221  delete G30ho60;
5222  if (G30ho61)
5223  delete G30ho61;
5224  if (G40ho60)
5225  delete G40ho60;
5226  if (G40ho61)
5227  delete G40ho61;
5228 
5229  if (Gho1)
5230  delete Gho1;
5231  //========================================================================================== 22-1 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5232  //======================================================================
5233  //======================================================================28.11.2018
5234  //======================================================================
5235  //======================================================================
5236 
5237  gStyle->SetOptStat(1110000);
5238  cout << " RBX HO Ratio plotsmore *****" << endl;
5239  cRBX31->Clear();
5241  cRBX31->Divide(3, 1);
5242  //================
5243  cRBX31->cd(1);
5244  G20ho6->GetZaxis()->SetLabelSize(0.025);
5245  G20ho6->SetXTitle(" #eta \b");
5246  G20ho6->SetYTitle(" #phi \b");
5247  G20ho6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5248  G20ho6->SetStats(0);
5249  G20ho6->Draw("COLZ");
5250  //================
5251  cRBX31->cd(2);
5252  G30ho6->GetZaxis()->SetLabelSize(0.025);
5253  G30ho6->SetXTitle(" #eta \b");
5254  G30ho6->SetYTitle(" #phi \b");
5255  G30ho6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5256  G30ho6->SetStats(0);
5257  G30ho6->Draw("COLZ");
5258  //================
5259  cRBX31->cd(3);
5260  G40ho6->GetZaxis()->SetLabelSize(0.025);
5261  G40ho6->SetXTitle(" #eta \b");
5262  G40ho6->SetYTitle(" #phi \b");
5263  G40ho6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5264  G40ho6->SetStats(0);
5265  G40ho6->Draw("COLZ");
5266  //================
5267 
5269  cRBX31->Update();
5270  cRBX31->Print("RBX-HO-3plotsmore.png");
5271  cRBX31->Clear();
5272 
5273  // clean-up
5274  if (G20ho6)
5275  delete G20ho6;
5276  if (G30ho6)
5277  delete G30ho6;
5278  if (G40ho6)
5279  delete G40ho6;
5280  gStyle->SetOptStat(0);
5282 
5283  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5284  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5285  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5286  for (int jphi = 0; jphi < njphi; jphi++) {
5287  for (int jeta = 0; jeta < njeta; jeta++) {
5288  for (int i = 0; i < nx; i++) {
5289  alexall[jeta][jphi][i] = 0.;
5290  }
5291  }
5292  } // nulling
5293 
5295 
5297  //======================================================================
5298  //======================================================================
5299  //======================================================================
5300  cout << " RBX general for HF **************************" << endl;
5301  TH2F *Ghf1KKK = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs3");
5302  TH2F *Ghf1LLL = (TH2F *)hfile->Get("h_2DsumADCAmplEtaPhiLs30");
5303  TH2F *Ghf1 = (TH2F *)Ghf1LLL->Clone("Ghf1");
5304  Ghf1->Divide(Ghf1KKK, Ghf1LLL, 1, 1, "B"); // average A
5305  // Ghf1->Sumw2();
5306  // int nx = Ghf1->GetXaxis()->GetNbins(); // # LS
5307  // nx = maxbinsRBX; // # LS
5308  ny = Ghf1->GetYaxis()->GetNbins(); // # jetaphi indexes
5309  for (int j = 1; j <= ny; j++) {
5310  int jeta = (j - 1) / njphi; // jeta = 0-21
5311  if (jeta < 4 || jeta > 17) {
5312  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
5313  // cout<<"HF 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
5314  // over LS:
5315  for (int i = 1; i <= nx; i++) {
5316  double ccc1 = Ghf1->GetBinContent(i, j);
5317  alexall[jeta][jphi][i - 1] = ccc1;
5318  // if( i == 1 ) cout<<"HF 54 for LS=1 ccc1= "<< ccc1 <<endl;
5319  } //i
5320  } //if
5321  } //j
5322  // clean-up
5323  if (Ghf1KKK)
5324  delete Ghf1KKK;
5325  if (Ghf1LLL)
5326  delete Ghf1LLL;
5327  // if (Ghf1) delete Ghf1;
5328 
5329  //====================================================================== alexhf[k][i]
5330  for (int jphi = 0; jphi < njphi; jphi++) {
5331  for (int i = 0; i < nx; i++) {
5332  double sumccc1 = 0.;
5333  int isum = 0;
5334  for (int jeta = 0; jeta < njeta; jeta++) {
5335  double ccc1 = alexall[jeta][jphi][i];
5336  if (ccc1 > 0.) {
5337  sumccc1 += ccc1;
5338  isum++;
5339  }
5340  } // for jeta
5341  if (isum > 0.)
5342  sumccc1 /= isum;
5343  alexhf[jphi][i] = sumccc1;
5344  }
5345  } //for for
5346  //====================================================================== blexhf[k][i]
5347  for (int keta = 0; keta < njeta; keta++) {
5348  for (int i = 0; i < nx; i++) {
5349  double sumccc1 = 0.;
5350  int isum = 0;
5351  for (int kphi = 0; kphi < njphi; kphi++) {
5352  double ccc1 = alexall[keta][kphi][i];
5353  if (ccc1 > 0.) {
5354  sumccc1 += ccc1;
5355  isum++;
5356  }
5357  } // for kphi
5358  if (isum > 0.)
5359  sumccc1 /= isum;
5360  blexhf[keta][i] = sumccc1;
5361  }
5362  } //for for
5364  //========================================================================================== 60 HF:: 2D jeta = 0 - 21 jphi =0 - 17
5365  //======================================================================
5366  //======================================================================
5367  //======================================================================
5368  //======================================================================
5369  cout << " RBX HF 2D plot *****" << endl;
5370  cRBX1->Clear();
5372  cRBX1->Divide(1, 1);
5373  cRBX1->cd(1);
5374  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
5375  TH2F *Ghf42D = new TH2F("Ghf42D", "", 23, -11.5, 11.5, 18, 0., 18.);
5376  TH2F *Ghf42D0 = new TH2F("Ghf42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
5377  // TH2F* Ghf42D = new TH2F("Ghf42D","", 22, -11., 11., 18, 0., 18. );
5378  // TH2F* Ghf42D0 = new TH2F("Ghf42D0","", 22, -11., 11., 18, 0., 18. );
5379  TH2F *Ghf42DF = (TH2F *)Ghf42D0->Clone("Ghf42DF");
5380  for (int jphi = 0; jphi < njphi; jphi++) {
5381  for (int jeta = 0; jeta < njeta; jeta++) {
5382  for (int i = 0; i < nx; i++) {
5383  double ccc1 = alexall[jeta][jphi][i];
5384  int neweta = jeta - 11 - 0.5;
5385  if (jeta >= 11)
5386  neweta = jeta - 11 + 1.5;
5387  if (ccc1 > 0.) {
5388  Ghf42D->Fill(neweta, jphi, ccc1);
5389  Ghf42D0->Fill(neweta, jphi, 1.);
5390  }
5391  // if(ccc1>0.) {Ghf42D ->Fill(jeta-11,jphi,ccc1); Ghf42D0 ->Fill(jeta-11,jphi,1.); }
5392  }
5393  }
5394  }
5395  Ghf42DF->Divide(Ghf42D, Ghf42D0, 1, 1, "B"); // average A
5396  // Ghf1->Sumw2();
5397  gPad->SetGridy();
5398  gPad->SetGridx(); // gPad->SetLogz();
5399  Ghf42DF->SetMarkerStyle(20);
5400  Ghf42DF->SetMarkerSize(0.4);
5401  Ghf42DF->GetZaxis()->SetLabelSize(0.04);
5402  Ghf42DF->SetXTitle("<A>_RBX #eta \b");
5403  Ghf42DF->SetYTitle(" #phi \b");
5404  Ghf42DF->SetZTitle("<A>_RBX - All \b");
5405  Ghf42DF->SetMarkerColor(2);
5406  Ghf42DF->SetLineColor(2); // Ghf42DF->SetMaximum(1.000); // Ghf42DF->SetMinimum(1.0);
5407  Ghf42DF->Draw("COLZ");
5408 
5410  cRBX1->Update();
5411  cRBX1->Print("RBX-HF-2Dplot.png");
5412  cRBX1->Clear();
5413  // clean-up
5414  if (Ghf42D)
5415  delete Ghf42D;
5416  if (Ghf42D0)
5417  delete Ghf42D0;
5418  if (Ghf42DF)
5419  delete Ghf42DF;
5420 
5421  //========================================================================================== 61 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5422  //======================================================================
5423  //======================================================================
5424  //======================================================================
5425  //======================================================================
5426  cout << " RBX HF 1D plot *****" << endl;
5427  cRBX1->Clear();
5429  cRBX1->Divide(1, 1);
5430  cRBX1->cd(1);
5431  TH1F *GphiHF1D = new TH1F("GphiHF1D", "", 18, 0., 18.);
5432  TH1F *GphiHF1D0 = new TH1F("GphiHF1D0", "", 18, 0., 18.);
5433  TH1F *GphiHF1DF = (TH1F *)GphiHF1D0->Clone("GphiHF1DF");
5434  for (int jphi = 0; jphi < 18; jphi++) {
5435  for (int jeta = 0; jeta < 22; jeta++) {
5436  for (int i = 0; i < nx; i++) {
5437  double ccc1 = alexall[jeta][jphi][i];
5438  if (ccc1 > 0.) {
5439  GphiHF1D->Fill(jphi, ccc1);
5440  GphiHF1D0->Fill(jphi, 1.);
5441  }
5442  }
5443  }
5444  }
5445  // GphiHF1D->Sumw2();GphiHF1D0->Sumw2();
5446  GphiHF1DF->Divide(GphiHF1D, GphiHF1D0, 1, 1, "B"); // average A
5447  // GphiHF1DF->Sumw2();
5448  for (int jphi = 1; jphi < 19; jphi++) {
5449  GphiHF1DF->SetBinError(jphi, 0.01);
5450  }
5451  gPad->SetGridy();
5452  gPad->SetGridx(); // gPad->SetLogz();
5453  GphiHF1DF->SetMarkerStyle(20);
5454  GphiHF1DF->SetMarkerSize(1.4);
5455  GphiHF1DF->GetZaxis()->SetLabelSize(0.08);
5456  GphiHF1DF->SetXTitle("PHI of RBX\b");
5457  GphiHF1DF->SetYTitle(" <Amplitude> \b");
5458  GphiHF1DF->SetZTitle("<A>_PHI - All \b");
5459  GphiHF1DF->SetMarkerColor(4);
5460  GphiHF1DF->SetLineColor(4);
5461  GphiHF1DF->SetMinimum(0.8); // GphiHF1DF->SetMaximum(1.000);
5462  GphiHF1DF->Draw("Error");
5464  cRBX1->Update();
5465  cRBX1->Print("RBX-HF-1Dplot.png");
5466  cRBX1->Clear();
5467  // clean-up
5468  if (GphiHF1D)
5469  delete GphiHF1D;
5470  if (GphiHF1D0)
5471  delete GphiHF1D0;
5472  if (GphiHF1DF)
5473  delete GphiHF1DF;
5474 
5475  //========================================================================================== 62 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5476  //======================================================================
5477  //======================================================================
5478  //======================================================================
5479  //======================================================================
5480  cout << " RBX HF 11D plot *eta*" << endl;
5481  cRBX1->Clear();
5483  cRBX1->Divide(1, 1);
5484  cRBX1->cd(1);
5485  TH1F *GetaHF11D = new TH1F("GetaHF11D", "", 23, -11.5, 11.5);
5486  TH1F *GetaHF11D0 = new TH1F("GetaHF11D0", "", 23, -11.5, 11.5);
5487  TH1F *GetaHF11DF = (TH1F *)GetaHF11D0->Clone("GetaHF11DF");
5488 
5489  for (int jeta = 0; jeta < 22; jeta++) {
5490  for (int jphi = 0; jphi < 18; jphi++) {
5491  for (int i = 0; i < nx; i++) {
5492  double ccc1 = alexall[jeta][jphi][i];
5493  int neweta = jeta - 11 - 0.5;
5494  if (jeta >= 11)
5495  neweta = jeta - 11 + 1.5;
5496  if (ccc1 > 0.) {
5497  GetaHF11D->Fill(neweta, ccc1);
5498  GetaHF11D0->Fill(neweta, 1.);
5499  // if( i == 0 ) cout<<"62 HF: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
5500  }
5501  }
5502  }
5503  }
5504  // GetaHF11D->Sumw2();GetaHF11D0->Sumw2();
5505  GetaHF11DF->Divide(GetaHF11D, GetaHF11D0, 1, 1, "B"); // average A
5506  // GetaHF11DF->Sumw2();
5507  for (int jeta = 1; jeta < 24; jeta++) {
5508  GetaHF11DF->SetBinError(jeta, 0.01);
5509  }
5510  gPad->SetGridy();
5511  gPad->SetGridx(); // gPad->SetLogz();
5512  GetaHF11DF->SetMarkerStyle(20);
5513  GetaHF11DF->SetMarkerSize(1.4);
5514  GetaHF11DF->GetZaxis()->SetLabelSize(0.08);
5515  GetaHF11DF->SetXTitle("#eta \b");
5516  GetaHF11DF->SetYTitle(" <A> \b");
5517  GetaHF11DF->SetZTitle("<A>_ETA - All \b");
5518  GetaHF11DF->SetMarkerColor(4);
5519  GetaHF11DF->SetLineColor(4);
5520  GetaHF11DF->SetMinimum(0.8); // GetaHF11DF->SetMaximum(1.000);
5521  GetaHF11DF->Draw("Error");
5522 
5524  cRBX1->Update();
5525  cRBX1->Print("RBX-HF-11Dplot.png");
5526  cRBX1->Clear();
5527  // clean-up
5528  if (GetaHF11D)
5529  delete GetaHF11D;
5530  if (GetaHF11D0)
5531  delete GetaHF11D0;
5532  if (GetaHF11DF)
5533  delete GetaHF11DF;
5534 
5535  //========================================================================================== 22 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5536  //======================================================================
5537  //======================================================================22.11.2018
5538  //======================================================================
5539  //======================================================================
5540 
5541  gStyle->SetOptStat(1110000);
5542  cout << " RBX HF Ratio plots *****" << endl;
5543  cRBX31->Clear();
5545  // gain stabilitY:
5546  // Rij = Aij / A1j , where i-over LSs, j-channels
5547  //
5548  // nx = maxbinsRBX; // # LS
5549  //
5550  double ccc0HF = 0.;
5551  cRBX31->Divide(3, 1);
5552  //================
5553  cRBX31->cd(1);
5554  // TH1F* Ghf5 = new TH1F("Ghf5","", nx, 1., nx+1.);
5555  TH1F *Ghf51 = new TH1F("Ghf51", "", nx, 1., nx + 1.);
5556  TH1F *Ghf50 = new TH1F("Ghf50", "", nx, 1., nx + 1.);
5557  TH1F *Ghf5 = (TH1F *)Ghf50->Clone("Ghf5");
5558  // j - etaphi index:
5559  for (int j = 1; j <= ny; j++) {
5560  ccc0HF = Ghf1->GetBinContent(1, j);
5561  // if(ccc0HF <=0.) for (int i=1;i<=nx;i++) {double ccc2 = Ghf1->GetBinContent(i,j);if(ccc2>0.){ccc0HF=ccc2;cout<<"!!! ccc0HF= "<<ccc0HF<<endl;break;} }
5562  if (ccc0HF <= 0.)
5563  for (int i = 1; i <= nx; i++) {
5564  double ccc2 = Ghf1->GetBinContent(i, j);
5565  if (ccc2 > 0.) {
5566  ccc0HF = ccc2;
5567  break;
5568  }
5569  }
5570  if (ccc0HF > 0.) {
5571  // i - # LSs:
5572  for (int i = 1; i <= nx; i++) {
5573  double ccc1 = Ghf1->GetBinContent(i, j);
5574  if (ccc1 > 0.) {
5575  double Rij = ccc1 / ccc0HF;
5576  // Ghf5 ->Fill( float(i), Rij);
5577  Ghf51->Fill(float(i), Rij);
5578  Ghf50->Fill(float(i), 1.);
5579  }
5580  }
5581  }
5582  }
5583  Ghf5->Divide(Ghf51, Ghf50, 1, 1, "B"); // average A
5584  for (int i = 1; i <= nx; i++) {
5585  Ghf5->SetBinError(i, 0.0001);
5586  }
5587  Ghf5->SetMarkerStyle(20);
5588  Ghf5->SetMarkerSize(0.4);
5589  Ghf5->GetYaxis()->SetLabelSize(0.04);
5590  Ghf5->SetMarkerColor(2);
5591  Ghf5->SetLineColor(0);
5592  Ghf5->SetXTitle(" iLS \b");
5593  Ghf5->SetYTitle(" <R> \b");
5594  Ghf5->SetTitle("<Ri> vs iLS \b");
5595  Ghf5->SetMinimum(0.); //Ghf5->SetMaximum(2.5);
5596  // gPad->SetLogy();
5597  gPad->SetGridy();
5598  gPad->SetGridx();
5599  Ghf5->SetStats(0);
5600  Ghf5->GetYaxis()->SetLabelSize(0.025);
5601  Ghf5->Draw("Error");
5602  //================
5603  cRBX31->cd(2);
5604  TH2F *Ghf60 = new TH2F("Ghf60", "", 22, -11., 11., 18, 0., 18.);
5605  TH2F *Ghf61 = new TH2F("Ghf61", "", 22, -11., 11., 18, 0., 18.);
5606  TH2F *Ghf6 = new TH2F("Ghf6", "", 22, -11., 11., 18, 0., 18.);
5607 
5608  TH2F *G20hf60 = new TH2F("G20hf60", "", 22, -11., 11., 18, 0., 18.);
5609  TH2F *G20hf61 = new TH2F("G20hf61", "", 22, -11., 11., 18, 0., 18.);
5610  TH2F *G20hf6 = new TH2F("G20hf6", "", 22, -11., 11., 18, 0., 18.);
5611  TH2F *G30hf60 = new TH2F("G30hf60", "", 22, -11., 11., 18, 0., 18.);
5612  TH2F *G30hf61 = new TH2F("G30hf61", "", 22, -11., 11., 18, 0., 18.);
5613  TH2F *G30hf6 = new TH2F("G30hf6", "", 22, -11., 11., 18, 0., 18.);
5614  TH2F *G40hf60 = new TH2F("G40hf60", "", 22, -11., 11., 18, 0., 18.);
5615  TH2F *G40hf61 = new TH2F("G40hf61", "", 22, -11., 11., 18, 0., 18.);
5616  TH2F *G40hf6 = new TH2F("G40hf6", "", 22, -11., 11., 18, 0., 18.);
5617  // j - etaphi index; i - # LSs;
5618  //
5619  // define mean and RMS:
5620  double sumjHF = 0.;
5621  int njHF = 0;
5622  double meanjHF = 0.;
5623  for (int j = 1; j <= ny; j++) {
5624  ccc0HF = Ghf1->GetBinContent(1, j);
5625  if (ccc0HF <= 0.)
5626  for (int i = 1; i <= nx; i++) {
5627  double ccc2 = Ghf1->GetBinContent(i, j);
5628  if (ccc2 > 0.) {
5629  ccc0HF = ccc2;
5630  break;
5631  }
5632  }
5633  if (ccc0HF > 0.) {
5634  for (int i = 1; i <= nx; i++) {
5635  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5636  if (ccc1 > 0.) {
5637  sumjHF += ccc1;
5638  njHF++;
5639  }
5640  }
5641  meanjHF = sumjHF / njHF;
5642  }
5643  } // j
5644 
5645  double ssumjHF = 0.;
5646  njHF = 0;
5647  double sigmajHF = 0.;
5648  for (int j = 1; j <= ny; j++) {
5649  ccc0HF = Ghf1->GetBinContent(1, j);
5650  if (ccc0HF <= 0.)
5651  for (int i = 1; i <= nx; i++) {
5652  double ccc2 = Ghf1->GetBinContent(i, j);
5653  if (ccc2 > 0.) {
5654  ccc0HF = ccc2;
5655  break;
5656  }
5657  }
5658  if (ccc0HF > 0.) {
5659  for (int i = 1; i <= nx; i++) {
5660  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5661  if (ccc1 > 0.) {
5662  ssumjHF += (ccc1 - meanjHF) * (ccc1 - meanjHF);
5663  njHF++;
5664  }
5665  }
5666  sigmajHF = sqrt(ssumjHF / njHF);
5667  }
5668  } // j
5669 
5670  double dif3rmsHFMIN = meanjHF - 3 * sigmajHF;
5671  if (dif3rmsHFMIN < 0.)
5672  dif3rmsHFMIN = 0.;
5673  double dif3rmsHFMAX = meanjHF + 3 * sigmajHF;
5674  cout << "22HF-2 meanjHF= " << meanjHF << " sigmajHF= " << sigmajHF << " dif3rmsHFMIN= " << dif3rmsHFMIN
5675  << " dif3rmsHFMAX= " << dif3rmsHFMAX << endl;
5676 
5677  double MAXdif3rmsHFMIN = dif3rmsHFMIN;
5678  double MINdif3rmsHFMAX = dif3rmsHFMAX;
5679  if (MAXdif3rmsHFMIN < 0.95)
5680  MAXdif3rmsHFMIN = 0.95;
5681  if (MINdif3rmsHFMAX > 1.05)
5682  MINdif3rmsHFMAX = 1.05;
5683  cout << "22HF-2 MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5684  //
5685  for (int j = 1; j <= ny; j++) {
5686  ccc0HF = Ghf1->GetBinContent(1, j);
5687  if (ccc0HF <= 0.)
5688  for (int i = 1; i <= nx; i++) {
5689  double ccc2 = Ghf1->GetBinContent(i, j);
5690  if (ccc2 > 0.) {
5691  ccc0HF = ccc2;
5692  break;
5693  }
5694  }
5695  if (ccc0HF > 0.) {
5696  int jeta = (j - 1) / 18; // jeta = 0-21
5697  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5698  // i - # LSs:
5699  for (int i = 1; i <= nx; i++) {
5700  double ccc1 = Ghf1->GetBinContent(i, j);
5701  if (ccc1 > 0.) {
5702  double Rij = ccc1 / ccc0HF;
5703  if (Rij < MAXdif3rmsHFMIN || Rij > MINdif3rmsHFMAX) {
5704  Ghf61->Fill(jeta - 11, jphi, Rij);
5705  Ghf60->Fill(jeta - 11, jphi, 1.);
5706  }
5707  if (Rij < 0.8 || Rij > 1.2) {
5708  G20hf61->Fill(jeta - 11, jphi, Rij);
5709  G20hf60->Fill(jeta - 11, jphi, 1.);
5710  }
5711  if (Rij < 0.7 || Rij > 1.3) {
5712  G30hf61->Fill(jeta - 11, jphi, Rij);
5713  G30hf60->Fill(jeta - 11, jphi, 1.);
5714  }
5715  if (Rij < 0.6 || Rij > 1.4) {
5716  G40hf61->Fill(jeta - 11, jphi, Rij);
5717  G40hf60->Fill(jeta - 11, jphi, 1.);
5718  }
5719  } //if(ccc1>0.
5720  } // i
5721  } //if(ccc0HF>0
5722  } // j
5723  Ghf6->Divide(Ghf61, Ghf60, 1, 1, "B"); // average R
5724  G20hf6->Divide(G20hf61, G20hf60, 1, 1, "B"); // average R
5725  G30hf6->Divide(G30hf61, G30hf60, 1, 1, "B"); // average R
5726  G40hf6->Divide(G40hf61, G40hf60, 1, 1, "B"); // average R
5727  // Ghf6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5728  // Ghf6->GetZaxis()->SetLabelOffset(-0.05);
5729  Ghf6->GetZaxis()->SetLabelSize(0.025);
5730 
5731  Ghf6->SetXTitle(" #eta \b");
5732  Ghf6->SetYTitle(" #phi \b");
5733  Ghf6->SetTitle(
5734  "<Rj> for |1-<R>| > 0.05 \b"); // Ghf6->SetMaximum(1.000); // Ghf6->SetMinimum(1.0); //Ghf6->SetZTitle("Rij averaged over LSs \b"); //Ghf6->GetZaxis()->SetLabelSize(0.04); //Ghf6->SetMarkerStyle(20);// Ghf6->SetMarkerSize(0.4);//Ghf6->SetMarkerColor(2); //Ghf6->SetLineColor(2);
5735  //gStyle->SetOptStat(kFALSE);
5736  Ghf6->SetStats(0);
5737  Ghf6->Draw("COLZ");
5738  //================
5739  cRBX31->cd(3);
5740  TH1F *Ghf7 = new TH1F("Ghf7", "", 120, 0.4, 1.6);
5741  // j - etaphi index:
5742  for (int j = 1; j <= ny; j++) {
5743  ccc0HF = Ghf1->GetBinContent(1, j);
5744  if (ccc0HF <= 0.)
5745  for (int i = 1; i <= nx; i++) {
5746  double ccc2 = Ghf1->GetBinContent(i, j);
5747  if (ccc2 > 0.) {
5748  ccc0HF = ccc2;
5749  break;
5750  }
5751  }
5752  if (ccc0HF > 0.) {
5753  // i - # LSs:
5754  for (int i = 1; i <= nx; i++) {
5755  double ccc1 = Ghf1->GetBinContent(i, j);
5756  if (ccc1 > 0.) {
5757  double Rij = ccc1 / ccc0HF;
5758  Ghf7->Fill(Rij);
5759  }
5760  }
5761  }
5762  }
5763  Ghf7->SetMarkerStyle(20);
5764  Ghf7->SetMarkerSize(0.4);
5765  Ghf7->GetYaxis()->SetLabelSize(0.04);
5766  Ghf7->SetMarkerColor(2);
5767  Ghf7->SetLineColor(0);
5768  Ghf7->SetYTitle(" N \b");
5769  Ghf7->SetXTitle(" Rij \b");
5770  Ghf7->SetTitle(" Rij \b");
5771  //Ghf7->SetMinimum(0.8);Ghf7->SetMaximum(500.);
5772  gPad->SetGridy();
5773  gPad->SetGridx(); // gPad->SetLogy();
5774  // Ghf7->SetStats(1110000);
5775  Ghf7->GetYaxis()->SetLabelSize(0.025);
5776  Ghf7->Draw("Error");
5777  Float_t ymaxHF = Ghf7->GetMaximum();
5778  cout << "22HF-3 ymaxHF= " << ymaxHF << " MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN
5779  << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5780  TLine *lineHF = new TLine(MAXdif3rmsHFMIN, 0., MAXdif3rmsHFMIN, ymaxHF);
5781  lineHF->SetLineColor(kBlue);
5782  lineHF->Draw();
5783  TLine *line1HF = new TLine(MINdif3rmsHFMAX, 0., MINdif3rmsHFMAX, ymaxHF);
5784  line1HF->SetLineColor(kBlue);
5785  line1HF->Draw();
5786  //================
5788  cRBX31->Update();
5789  cRBX31->Print("RBX-HF-3plots.png");
5790  cRBX31->Clear();
5791  // clean-up
5792  if (Ghf5)
5793  delete Ghf5;
5794  if (Ghf60)
5795  delete Ghf60;
5796  if (Ghf61)
5797  delete Ghf61;
5798  if (Ghf6)
5799  delete Ghf6;
5800  if (Ghf7)
5801  delete Ghf7;
5802 
5803  if (G20hf60)
5804  delete G20hf60;
5805  if (G20hf61)
5806  delete G20hf61;
5807  if (G30hf60)
5808  delete G30hf60;
5809  if (G30hf61)
5810  delete G30hf61;
5811  if (G40hf60)
5812  delete G40hf60;
5813  if (G40hf61)
5814  delete G40hf61;
5815 
5816  if (Ghf1)
5817  delete Ghf1;
5818  //========================================================================================== 22-1 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5819  //======================================================================
5820  //======================================================================28.11.2018
5821  //======================================================================
5822  //======================================================================
5823 
5824  gStyle->SetOptStat(1110000);
5825  cout << " RBX HF Ratio plotsmore *****" << endl;
5826  cRBX31->Clear();
5828  cRBX31->Divide(3, 1);
5829  //================
5830  cRBX31->cd(1);
5831  G20hf6->GetZaxis()->SetLabelSize(0.025);
5832  G20hf6->SetXTitle(" #eta \b");
5833  G20hf6->SetYTitle(" #phi \b");
5834  G20hf6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5835  G20hf6->SetStats(0);
5836  G20hf6->Draw("COLZ");
5837  //================
5838  cRBX31->cd(2);
5839  G30hf6->GetZaxis()->SetLabelSize(0.025);
5840  G30hf6->SetXTitle(" #eta \b");
5841  G30hf6->SetYTitle(" #phi \b");
5842  G30hf6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5843  G30hf6->SetStats(0);
5844  G30hf6->Draw("COLZ");
5845  //================
5846  cRBX31->cd(3);
5847  G40hf6->GetZaxis()->SetLabelSize(0.025);
5848  G40hf6->SetXTitle(" #eta \b");
5849  G40hf6->SetYTitle(" #phi \b");
5850  G40hf6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5851  G40hf6->SetStats(0);
5852  G40hf6->Draw("COLZ");
5853  //================
5854 
5856  cRBX31->Update();
5857  cRBX31->Print("RBX-HF-3plotsmore.png");
5858  cRBX31->Clear();
5859 
5860  // clean-up
5861  if (G20hf6)
5862  delete G20hf6;
5863  if (G30hf6)
5864  delete G30hf6;
5865  if (G40hf6)
5866  delete G40hf6;
5867  gStyle->SetOptStat(0);
5869  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5870  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5871  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5873 
5875 
5877  //=============================================================================== occupancyHB
5878  // For occupancy plots. Produces OccPlots_HBx.png (x=1)
5879  int mymaxbins = MaxLum;
5880  {
5881  cHB->Clear();
5882  cHB->Divide(2, 1);
5884  cHB->cd(1);
5885  TH2F *occhbm = (TH2F *)hfile->Get("h_RatioOccupancy_HBM");
5886  TH1F *uyhbm = new TH1F("uyhbm", "", mymaxbins, 1., mymaxbins + 1.);
5887  for (int i = 1; i <= occhbm->GetXaxis()->GetNbins(); i++) {
5888  double ccc1 = occhbm->GetBinContent(i);
5889  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5890  if (ccc1 > 0.)
5891  uyhbm->Fill(float(i), ccc1);
5892  }
5893  // gPad->SetLogy();
5894  uyhbm->SetMarkerStyle(20);
5895  uyhbm->SetMarkerSize(0.6);
5896  uyhbm->GetYaxis()->SetLabelSize(0.04);
5897  uyhbm->SetXTitle("min/av occupancy - HBM \b");
5898  uyhbm->SetMarkerColor(2);
5899  uyhbm->SetLineColor(0);
5900  uyhbm->SetMaximum(1.0);
5901  uyhbm->SetMinimum(0.2);
5902  gPad->SetGridy();
5903  uyhbm->Draw("Error");
5905  cHB->cd(2);
5906  TH2F *occhbp = (TH2F *)hfile->Get("h_RatioOccupancy_HBP");
5907  TH1F *uyhbp = new TH1F("uyhbp", "", mymaxbins, 1., mymaxbins + 1.);
5908  for (int i = 1; i <= occhbp->GetXaxis()->GetNbins(); i++) {
5909  double ccc1 = occhbp->GetBinContent(i);
5910  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5911  if (ccc1 > 0.)
5912  uyhbp->Fill(float(i), ccc1);
5913  }
5914  // gPad->SetLogy();
5915  uyhbp->SetMarkerStyle(20);
5916  uyhbp->SetMarkerSize(0.6);
5917  uyhbp->GetYaxis()->SetLabelSize(0.04);
5918  uyhbp->SetXTitle("min/av occupancy - HBP \b");
5919  uyhbp->SetMarkerColor(2);
5920  uyhbp->SetLineColor(0);
5921  uyhbp->SetMaximum(1.0);
5922  uyhbp->SetMinimum(0.2);
5923  gPad->SetGridy();
5924  uyhbp->Draw("Error");
5926 
5928  cHB->Update();
5929  cHB->Print(Form("OccPlots_HB.png"));
5930  cHB->Clear();
5931 
5932  // clean-up
5933  if (occhbm)
5934  delete occhbm;
5935  if (uyhbm)
5936  delete uyhbm;
5937  if (occhbp)
5938  delete occhbp;
5939  if (uyhbp)
5940  delete uyhbp;
5941  }
5942  //=============================================================================== occupancyHE
5943  // For occupancy plots. Produces OccPlots_HEx.png (x=1)
5944  {
5945  cHB->Clear();
5946  cHB->Divide(2, 1);
5948  cHB->cd(1);
5949  TH2F *occhem = (TH2F *)hfile->Get("h_RatioOccupancy_HEM");
5950  TH1F *uyhem = new TH1F("uyhem", "", mymaxbins, 1., mymaxbins + 1.);
5951  for (int i = 1; i <= occhem->GetXaxis()->GetNbins(); i++) {
5952  double ccc1 = occhem->GetBinContent(i);
5953  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5954  if (ccc1 > 0.)
5955  uyhem->Fill(float(i), ccc1);
5956  }
5957  // gPad->SetLogy();
5958  uyhem->SetMarkerStyle(20);
5959  uyhem->SetMarkerSize(0.6);
5960  uyhem->GetYaxis()->SetLabelSize(0.04);
5961  uyhem->SetXTitle("min/av occupancy - HEM \b");
5962  uyhem->SetMarkerColor(2);
5963  uyhem->SetLineColor(0);
5964  uyhem->SetMaximum(1.0);
5965  uyhem->SetMinimum(0.2);
5966  gPad->SetGridy();
5967  uyhem->Draw("Error");
5969  cHB->cd(2);
5970  TH2F *occhep = (TH2F *)hfile->Get("h_RatioOccupancy_HEP");
5971  TH1F *uyhep = new TH1F("uyhep", "", mymaxbins, 1., mymaxbins + 1.);
5972  for (int i = 1; i <= occhep->GetXaxis()->GetNbins(); i++) {
5973  double ccc1 = occhep->GetBinContent(i);
5974  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5975  if (ccc1 > 0.)
5976  uyhep->Fill(float(i), ccc1);
5977  }
5978  // gPad->SetLogy();
5979  uyhep->SetMarkerStyle(20);
5980  uyhep->SetMarkerSize(0.6);
5981  uyhep->GetYaxis()->SetLabelSize(0.04);
5982  uyhep->SetXTitle("min/av occupancy - HEP \b");
5983  uyhep->SetMarkerColor(2);
5984  uyhep->SetLineColor(0);
5985  uyhep->SetMaximum(1.0);
5986  uyhep->SetMinimum(0.2);
5987  gPad->SetGridy();
5988  uyhep->Draw("Error");
5990 
5992  cHB->Update();
5993  cHB->Print(Form("OccPlots_HE.png"));
5994  cHB->Clear();
5995 
5996  // clean-up
5997  if (occhem)
5998  delete occhem;
5999  if (uyhem)
6000  delete uyhem;
6001  if (occhep)
6002  delete occhep;
6003  if (uyhep)
6004  delete uyhep;
6005  }
6006  //=============================================================================== occupancyHO
6007  // For occupancy plots. Produces OccPlots_HOx.png (x=1)
6008  {
6009  cHB->Clear();
6010  cHB->Divide(2, 1);
6012  cHB->cd(1);
6013  TH2F *occhom = (TH2F *)hfile->Get("h_RatioOccupancy_HOM");
6014  TH1F *uyhom = new TH1F("uyhom", "", mymaxbins, 1., mymaxbins + 1.);
6015  for (int i = 1; i <= occhom->GetXaxis()->GetNbins(); i++) {
6016  double ccc1 = occhom->GetBinContent(i);
6017  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6018  if (ccc1 > 0.)
6019  uyhom->Fill(float(i), ccc1);
6020  }
6021  // gPad->SetLogy();
6022  uyhom->SetMarkerStyle(20);
6023  uyhom->SetMarkerSize(0.6);
6024  uyhom->GetYaxis()->SetLabelSize(0.04);
6025  uyhom->SetXTitle("min/av occupancy - HOM \b");
6026  uyhom->SetMarkerColor(2);
6027  uyhom->SetLineColor(0);
6028  uyhom->SetMaximum(1.0);
6029  uyhom->SetMinimum(0.2);
6030  gPad->SetGridy();
6031  uyhom->Draw("Error");
6033  cHB->cd(2);
6034  TH2F *occhop = (TH2F *)hfile->Get("h_RatioOccupancy_HOP");
6035  TH1F *uyhop = new TH1F("uyhop", "", mymaxbins, 1., mymaxbins + 1.);
6036  for (int i = 1; i <= occhop->GetXaxis()->GetNbins(); i++) {
6037  double ccc1 = occhop->GetBinContent(i);
6038  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6039  if (ccc1 > 0.)
6040  uyhop->Fill(float(i), ccc1);
6041  }
6042  // gPad->SetLogy();
6043  uyhop->SetMarkerStyle(20);
6044  uyhop->SetMarkerSize(0.6);
6045  uyhop->GetYaxis()->SetLabelSize(0.04);
6046  uyhop->SetXTitle("min/av occupancy - HOP \b");
6047  uyhop->SetMarkerColor(2);
6048  uyhop->SetLineColor(0);
6049  uyhop->SetMaximum(1.0);
6050  uyhop->SetMinimum(0.2);
6051  gPad->SetGridy();
6052  uyhop->Draw("Error");
6054 
6056  cHB->Update();
6057  cHB->Print(Form("OccPlots_HO.png"));
6058  cHB->Clear();
6059 
6060  // clean-up
6061  if (occhom)
6062  delete occhom;
6063  if (uyhom)
6064  delete uyhom;
6065  if (occhop)
6066  delete occhop;
6067  if (uyhop)
6068  delete uyhop;
6069  }
6070  //=============================================================================== occupancyHF
6071  // For occupancy plots. Produces OccPlots_HFx.png (x=1)
6072  {
6073  cHB->Clear();
6074  cHB->Divide(2, 1);
6076  cHB->cd(1);
6077  TH2F *occhfm = (TH2F *)hfile->Get("h_RatioOccupancy_HFM");
6078  TH1F *uyhfm = new TH1F("uyhfm", "", mymaxbins, 1., mymaxbins + 1.);
6079  for (int i = 1; i <= occhfm->GetXaxis()->GetNbins(); i++) {
6080  double ccc1 = occhfm->GetBinContent(i);
6081  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6082  if (ccc1 > 0.)
6083  uyhfm->Fill(float(i), ccc1);
6084  }
6085  // gPad->SetLogy();
6086  uyhfm->SetMarkerStyle(20);
6087  uyhfm->SetMarkerSize(0.6);
6088  uyhfm->GetYaxis()->SetLabelSize(0.04);
6089  uyhfm->SetXTitle("min/av occupancy - HFM \b");
6090  uyhfm->SetMarkerColor(2);
6091  uyhfm->SetLineColor(0);
6092  uyhfm->SetMaximum(1.0);
6093  uyhfm->SetMinimum(0.2);
6094  gPad->SetGridy();
6095  uyhfm->Draw("Error");
6097  cHB->cd(2);
6098  TH2F *occhfp = (TH2F *)hfile->Get("h_RatioOccupancy_HFP");
6099  TH1F *uyhfp = new TH1F("uyhfp", "", mymaxbins, 1., mymaxbins + 1.);
6100  for (int i = 1; i <= occhfp->GetXaxis()->GetNbins(); i++) {
6101  double ccc1 = occhfp->GetBinContent(i);
6102  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6103  if (ccc1 > 0.)
6104  uyhfp->Fill(float(i), ccc1);
6105  }
6106  // gPad->SetLogy();
6107  uyhfp->SetMarkerStyle(20);
6108  uyhfp->SetMarkerSize(0.6);
6109  uyhfp->GetYaxis()->SetLabelSize(0.04);
6110  uyhfp->SetXTitle("min/av occupancy - HFP \b");
6111  uyhfp->SetMarkerColor(2);
6112  uyhfp->SetLineColor(0);
6113  uyhfp->SetMaximum(1.0);
6114  uyhfp->SetMinimum(0.2);
6115  gPad->SetGridy();
6116  uyhfp->Draw("Error");
6118 
6120  cHB->Update();
6121  cHB->Print(Form("OccPlots_HF.png"));
6122  cHB->Clear();
6123 
6124  // clean-up
6125  if (occhfm)
6126  delete occhfm;
6127  if (uyhfm)
6128  delete uyhfm;
6129  if (occhfp)
6130  delete occhfp;
6131  if (uyhfp)
6132  delete uyhfp;
6133  }
6134  std::cout << "************>>> occupancy plots done" << std::endl;
6135 
6140  //************************* ***** Signal *****
6141  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots " << endl;
6142  int maxbins = MaxLum;
6143  cout << ">>>> maxbins = " << maxbins << endl;
6144  TH1F *SummedAmplitudeHisto[4]; // 1d histogramm for subdet
6145  SummedAmplitudeHisto[0] = (TH1F *)hfile->Get("h_averSIGNALsumamplitude_HB");
6146  SummedAmplitudeHisto[1] = (TH1F *)hfile->Get("h_averSIGNALsumamplitude_HE");
6147  SummedAmplitudeHisto[2] = (TH1F *)hfile->Get("h_averSIGNALsumamplitude_HO");
6148  SummedAmplitudeHisto[3] = (TH1F *)hfile->Get("h_averSIGNALsumamplitude_HF");
6149  TH1F *SummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6150  SummedAmplitudeOccupancyHisto[0] = (TH1F *)hfile->Get("h_averSIGNALoccupancy_HB");
6151  SummedAmplitudeOccupancyHisto[1] = (TH1F *)hfile->Get("h_averSIGNALoccupancy_HE");
6152  SummedAmplitudeOccupancyHisto[2] = (TH1F *)hfile->Get("h_averSIGNALoccupancy_HO");
6153  SummedAmplitudeOccupancyHisto[3] = (TH1F *)hfile->Get("h_averSIGNALoccupancy_HF");
6154  for (int sub = 0; sub < 4; sub++) {
6155  cHE->Clear();
6156  cHE->Divide(2, 1);
6157  cHE->cd(1);
6158  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6159  // cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sub = "<< sub <<endl;
6160  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6161  double ccc1 = 0.;
6162  if (SummedAmplitudeHisto[sub])
6163  ccc1 = SummedAmplitudeHisto[sub]->GetBinContent(i);
6164  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6165  if (ccc1 > 0.)
6166  kslpq->Fill(float(i), ccc1);
6167  }
6168  // gPad->SetLogy();
6169  kslpq->SetMarkerStyle(20);
6170  kslpq->SetMarkerSize(0.8);
6171  kslpq->GetYaxis()->SetLabelSize(0.04);
6172  kslpq->SetXTitle("SumA of channels w/ signal per LS \b");
6173  kslpq->SetMarkerColor(2);
6174  kslpq->SetLineColor(0);
6175  // kslpq->SetMinimum(0.8);
6176  gPad->SetGridx();
6177  kslpq->Draw("Error");
6179  cHE->cd(2);
6180  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6181  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6182  double ccc1 = 0.;
6183  if (SummedAmplitudeOccupancyHisto[sub])
6184  ccc1 = SummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6185  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6186  if (ccc1 > 0.)
6187  pqmks->Fill(float(i), ccc1);
6188  }
6189  // gPad->SetLogy();
6190  pqmks->SetMarkerStyle(20);
6191  pqmks->SetMarkerSize(0.8);
6192  pqmks->GetYaxis()->SetLabelSize(0.04);
6193  pqmks->SetXTitle("Occupancy of channels w/ signal per LS \b");
6194  pqmks->SetMarkerColor(4);
6195  pqmks->SetLineColor(0);
6196  // pqmks->SetMinimum(0.8);
6197  gPad->SetGridx();
6198  pqmks->Draw("Error");
6199  cHE->Update();
6200  if (sub == 0)
6201  cHE->Print("SummedAmplitudesSignal_HB.png");
6202  if (sub == 1)
6203  cHE->Print("SummedAmplitudesSignal_HE.png");
6204  if (sub == 2)
6205  cHE->Print("SummedAmplitudesSignal_HO.png");
6206  if (sub == 3)
6207  cHE->Print("SummedAmplitudesSignal_HF.png");
6208  cHE->Clear();
6209  if (kslpq)
6210  delete kslpq;
6211  if (pqmks)
6212  delete pqmks;
6213  } //for
6214  // clean-up
6215  //for (unsigned int i=0; i<4; i++) {delete SummedAmplitudeHisto[i];delete SummedAmplitudeOccupancyHisto[i];}
6216 
6219  //************************* ***** NoSignal *****
6220  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots NoSignal " << endl;
6221  TH1F *NoSignalSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6222  NoSignalSummedAmplitudeHisto[0] = (TH1F *)hfile->Get("h_averNOSIGNALsumamplitude_HB");
6223  NoSignalSummedAmplitudeHisto[1] = (TH1F *)hfile->Get("h_averNOSIGNALsumamplitude_HE");
6224  NoSignalSummedAmplitudeHisto[2] = (TH1F *)hfile->Get("h_averNOSIGNALsumamplitude_HO");
6225  NoSignalSummedAmplitudeHisto[3] = (TH1F *)hfile->Get("h_averNOSIGNALsumamplitude_HF");
6226  TH1F *NoSignalSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6227  NoSignalSummedAmplitudeOccupancyHisto[0] = (TH1F *)hfile->Get("h_averNOSIGNALoccupancy_HB");
6228  NoSignalSummedAmplitudeOccupancyHisto[1] = (TH1F *)hfile->Get("h_averNOSIGNALoccupancy_HE");
6229  NoSignalSummedAmplitudeOccupancyHisto[2] = (TH1F *)hfile->Get("h_averNOSIGNALoccupancy_HO");
6230  NoSignalSummedAmplitudeOccupancyHisto[3] = (TH1F *)hfile->Get("h_averNOSIGNALoccupancy_HF");
6231  for (int sub = 0; sub < 4; sub++) {
6232  cHE->Clear();
6233  cHE->Divide(2, 1);
6234 
6235  cHE->cd(1);
6236  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6237  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6238  double ccc1 = 0.;
6239  if (NoSignalSummedAmplitudeHisto[sub])
6240  ccc1 = NoSignalSummedAmplitudeHisto[sub]->GetBinContent(i);
6241  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6242  if (ccc1 > 0.)
6243  kslpq->Fill(float(i), ccc1);
6244  }
6245  // gPad->SetLogy();
6246  kslpq->SetMarkerStyle(20);
6247  kslpq->SetMarkerSize(0.8);
6248  kslpq->GetYaxis()->SetLabelSize(0.04);
6249  kslpq->SetXTitle("SumA of channels w/o signal per LS \b");
6250  kslpq->SetMarkerColor(2);
6251  kslpq->SetLineColor(0);
6252  if (sub == 0) {
6253  kslpq->SetMaximum(20000.);
6254  kslpq->SetMinimum(5000.);
6255  } else if (sub == 1) {
6256  kslpq->SetMaximum(40000.);
6257  kslpq->SetMinimum(0.);
6258  } else if (sub == 2) {
6259  kslpq->SetMaximum(10000.);
6260  kslpq->SetMinimum(15000.);
6261  } else if (sub == 3) {
6262  kslpq->SetMaximum(100000.);
6263  kslpq->SetMinimum(0.);
6264  }
6265  gPad->SetGridx();
6266  kslpq->Draw("Error");
6268  cHE->cd(2);
6269  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6270  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6271  double ccc1 = 0.;
6272  if (NoSignalSummedAmplitudeOccupancyHisto[sub])
6273  ccc1 = NoSignalSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6274  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6275  if (ccc1 > 0.)
6276  pqmks->Fill(float(i), ccc1);
6277  }
6278  // gPad->SetLogy();
6279  pqmks->SetMarkerStyle(20);
6280  pqmks->SetMarkerSize(0.8);
6281  pqmks->GetYaxis()->SetLabelSize(0.04);
6282  pqmks->SetXTitle("Occupancy of channels w/o signal per LS \b");
6283  pqmks->SetMarkerColor(4);
6284  pqmks->SetLineColor(0);
6285  if (sub == 0) {
6286  pqmks->SetMaximum(600.);
6287  pqmks->SetMinimum(200.);
6288  } else if (sub == 1) {
6289  pqmks->SetMaximum(910.);
6290  pqmks->SetMinimum(10.);
6291  } else if (sub == 2) {
6292  pqmks->SetMaximum(200.);
6293  pqmks->SetMinimum(50.);
6294  } else if (sub == 3) {
6295  pqmks->SetMaximum(866.);
6296  pqmks->SetMinimum(856.);
6297  }
6298  gPad->SetGridx();
6299  pqmks->Draw("Error");
6300  cHE->Update();
6301  if (sub == 0)
6302  cHE->Print("NoSignalSummedAmplitudes_HB.png");
6303  if (sub == 1)
6304  cHE->Print("NoSignalSummedAmplitudes_HE.png");
6305  if (sub == 2)
6306  cHE->Print("NoSignalSummedAmplitudes_HO.png");
6307  if (sub == 3)
6308  cHE->Print("NoSignalSummedAmplitudes_HF.png");
6309  cHE->Clear();
6310  if (kslpq)
6311  delete kslpq;
6312  if (pqmks)
6313  delete pqmks;
6314  } //for
6315  // clean-up
6316  //for (unsigned int i=0; i<4; i++) {delete NoSignalSummedAmplitudeHisto[i];delete NoSignalSummedAmplitudeOccupancyHisto[i];}
6318 
6321  //************************* ***** MaxxValues *****
6322  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots Maxx " << endl;
6323  TH1F *MaxxSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6324  MaxxSummedAmplitudeHisto[0] = (TH1F *)hfile->Get("h_maxxSUMAmpl_HB");
6325  MaxxSummedAmplitudeHisto[1] = (TH1F *)hfile->Get("h_maxxSUMAmpl_HE");
6326  MaxxSummedAmplitudeHisto[2] = (TH1F *)hfile->Get("h_maxxSUMAmpl_HO");
6327  MaxxSummedAmplitudeHisto[3] = (TH1F *)hfile->Get("h_maxxSUMAmpl_HF");
6328  TH1F *MaxxSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6329  MaxxSummedAmplitudeOccupancyHisto[0] = (TH1F *)hfile->Get("h_maxxOCCUP_HB");
6330  MaxxSummedAmplitudeOccupancyHisto[1] = (TH1F *)hfile->Get("h_maxxOCCUP_HE");
6331  MaxxSummedAmplitudeOccupancyHisto[2] = (TH1F *)hfile->Get("h_maxxOCCUP_HO");
6332  MaxxSummedAmplitudeOccupancyHisto[3] = (TH1F *)hfile->Get("h_maxxOCCUP_HF");
6333  TH1F *SAmplitudeHisto[4]; // 1d histogramm for subdet
6334  SAmplitudeHisto[0] = (TH1F *)hfile->Get("h_eventamplitude_HB");
6335  SAmplitudeHisto[1] = (TH1F *)hfile->Get("h_eventamplitude_HE");
6336  SAmplitudeHisto[2] = (TH1F *)hfile->Get("h_eventamplitude_HO");
6337  SAmplitudeHisto[3] = (TH1F *)hfile->Get("h_eventamplitude_HF");
6338  TH1F *OccupancyHisto[4]; // 1d histogramm for subdet
6339  OccupancyHisto[0] = (TH1F *)hfile->Get("h_eventoccupancy_HB");
6340  OccupancyHisto[1] = (TH1F *)hfile->Get("h_eventoccupancy_HE");
6341  OccupancyHisto[2] = (TH1F *)hfile->Get("h_eventoccupancy_HO");
6342  OccupancyHisto[3] = (TH1F *)hfile->Get("h_eventoccupancy_HF");
6343 
6344  int countamplmaxHB = 0;
6345  int countamplmaxHE = 0;
6346  int countamplmaxHO = 0;
6347  int countamplmaxHF = 0;
6348  int countoccumaxHB = 0;
6349  int countoccumaxHE = 0;
6350  int countoccumaxHO = 0;
6351  int countoccumaxHF = 0;
6352  unsigned long int countamplHB = 0;
6353  unsigned long int countamplHE = 0;
6354  unsigned long int countamplHO = 0;
6355  unsigned long int countamplHF = 0;
6356  unsigned long int countoccuHB = 0;
6357  unsigned long int countoccuHE = 0;
6358  unsigned long int countoccuHO = 0;
6359  unsigned long int countoccuHF = 0;
6360  gStyle->SetOptStat(110000);
6361  for (int sub = 0; sub < 4; sub++) {
6362  cFour->Clear();
6363  cFour->Divide(2, 2);
6364 
6365  cFour->cd(1);
6366  TH1F *lpqxc = new TH1F("lpqxc", "", maxbins, 1., maxbins + 1.);
6367  for (int i = 1; i <= lpqxc->GetXaxis()->GetNbins(); i++) {
6368  double ccc1 = 0.;
6369  if (MaxxSummedAmplitudeHisto[sub])
6370  ccc1 = MaxxSummedAmplitudeHisto[sub]->GetBinContent(i);
6371  // if(ccc1>0.) cout<<"111111111111111111111111111 iLS = "<<i<<" LS= "<<ccc1<<endl;
6372  if (ccc1 > 0.)
6373  lpqxc->Fill(float(i), ccc1);
6374  if (sub == 0 && ccc1 > 60000.)
6375  countamplmaxHB++;
6376  if (sub == 1 && ccc1 > 60000.)
6377  countamplmaxHE++;
6378  if (sub == 2 && ccc1 > 150000.)
6379  countamplmaxHO++;
6380  if (sub == 3 && ccc1 > 22000.)
6381  countamplmaxHF++;
6382  }
6383  // gPad->SetLogy();
6384  lpqxc->SetMarkerStyle(20);
6385  lpqxc->SetMarkerSize(0.8);
6386  // lpqxc->GetYaxis()->SetLabelSize(0.08);
6387  if (sub == 0)
6388  lpqxc->SetXTitle("HB: max SA over LS-events per LS \b");
6389  if (sub == 1)
6390  lpqxc->SetXTitle("HE: max SA over LS-events per LS \b");
6391  if (sub == 2)
6392  lpqxc->SetXTitle("HO: max SA over LS-events per LS \b");
6393  if (sub == 3)
6394  lpqxc->SetXTitle("HF: max SA over LS-events per LS \b");
6395  lpqxc->SetMarkerColor(2);
6396  lpqxc->SetLineColor(0);
6397  gPad->SetGridx();
6398  lpqxc->Draw("Error");
6399 
6401  cFour->cd(2);
6402  TH1F *hpzlm = new TH1F("hpzlm", "", maxbins, 1., maxbins + 1.);
6403  for (int i = 1; i <= hpzlm->GetXaxis()->GetNbins(); i++) {
6404  double ccc1 = 0.;
6405  if (MaxxSummedAmplitudeOccupancyHisto[sub])
6406  ccc1 = MaxxSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6407  // if(ccc1>0.) cout<<"2222222222222222222222222 iLS = "<<i<<" LS= "<<ccc1<<endl;
6408  if (ccc1 > 0.)
6409  hpzlm->Fill(float(i), ccc1);
6410  if (sub == 0 && ccc1 > 2000.)
6411  countoccumaxHB++;
6412  if (sub == 1 && ccc1 > 1200.)
6413  countoccumaxHE++;
6414  if (sub == 2 && ccc1 > 2000.)
6415  countoccumaxHO++;
6416  if (sub == 3 && ccc1 > 860.)
6417  countoccumaxHF++;
6418  }
6419  // gPad->SetLogy();
6420  hpzlm->SetMarkerStyle(20);
6421  hpzlm->SetMarkerSize(0.8);
6422  // hpzlm->GetYaxis()->SetLabelSize(0.08);
6423  if (sub == 0)
6424  hpzlm->SetXTitle("HB: max Occupancy over LS-events per LS \b");
6425  if (sub == 1)
6426  hpzlm->SetXTitle("HE: max Occupancy over LS-events per LS \b");
6427  if (sub == 2)
6428  hpzlm->SetXTitle("HO: max Occupancy over LS-events per LS \b");
6429  if (sub == 3)
6430  hpzlm->SetXTitle("HF: max Occupancy over LS-events per LS \b");
6431  hpzlm->SetMarkerColor(4);
6432  hpzlm->SetLineColor(0);
6433  gPad->SetGridx();
6434  if (sub == 3) {
6435  hpzlm->SetMaximum(866.);
6436  hpzlm->SetMinimum(856.);
6437  }
6438  hpzlm->Draw("Error");
6439 
6441  cFour->cd(3);
6442  gPad->SetLogy();
6443  if (SAmplitudeHisto[sub]) {
6444  for (int i = 1; i <= SAmplitudeHisto[sub]->GetXaxis()->GetNbins(); i++) {
6445  // if(sub==0 && i * 800> 60000.) {
6446  // cout<<">=>=>>=> countamplHB= "<<countamplHB<<" content = "<<SAmplitudeHisto[sub]->GetBinContent(i)<<" sub= "<<sub<<" i= "<<i<< endl;
6447  // countamplHB+=SAmplitudeHisto[sub]->GetBinContent(i);
6448  // }
6449  if (sub == 0 && i * 800 > 60000.)
6450  countamplHB += SAmplitudeHisto[sub]->GetBinContent(i);
6451  if (sub == 1 && i * 1000 > 60000.)
6452  countamplHE += SAmplitudeHisto[sub]->GetBinContent(i);
6453  if (sub == 2 && i * 2500 > 150000.)
6454  countamplHO += SAmplitudeHisto[sub]->GetBinContent(i);
6455  if (sub == 3 && i * 1400 > 22000.)
6456  countamplHF += SAmplitudeHisto[sub]->GetBinContent(i);
6457  }
6458  SAmplitudeHisto[sub]->SetMarkerStyle(20);
6459  SAmplitudeHisto[sub]->SetMarkerSize(0.8);
6460  if (sub == 0)
6461  SAmplitudeHisto[sub]->SetTitle("HB event Amplitude\b");
6462  if (sub == 1)
6463  SAmplitudeHisto[sub]->SetTitle("HE event Amplitude\b");
6464  if (sub == 2)
6465  SAmplitudeHisto[sub]->SetTitle("HO event Amplitude\b");
6466  if (sub == 3)
6467  SAmplitudeHisto[sub]->SetTitle("HF event Amplitude\b");
6468  // SAmplitudeHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6469  SAmplitudeHisto[sub]->SetXTitle("event amplitude \b");
6470  SAmplitudeHisto[sub]->SetMarkerColor(2);
6471  SAmplitudeHisto[sub]->SetLineColor(2);
6472  SAmplitudeHisto[sub]->Draw("");
6473  }
6475  cFour->cd(4);
6476  gPad->SetLogy();
6477  if (OccupancyHisto[sub]) {
6478  for (int i = 1; i <= OccupancyHisto[sub]->GetXaxis()->GetNbins(); i++) {
6479  if (sub == 0 && i * 30 > 2000.)
6480  countoccuHB += OccupancyHisto[sub]->GetBinContent(i);
6481  if (sub == 1 && i * 20 > 1200.)
6482  countoccuHE += OccupancyHisto[sub]->GetBinContent(i);
6483  if (sub == 2 && i * 25 > 2000.)
6484  countoccuHO += OccupancyHisto[sub]->GetBinContent(i);
6485  if (sub == 3 && i * 10 > 860.)
6486  countoccuHF += OccupancyHisto[sub]->GetBinContent(i);
6487  }
6488  OccupancyHisto[sub]->SetMarkerStyle(20);
6489  OccupancyHisto[sub]->SetMarkerSize(0.8);
6490  if (sub == 0)
6491  OccupancyHisto[sub]->SetTitle("HB event Occupancy\b");
6492  if (sub == 1)
6493  OccupancyHisto[sub]->SetTitle("HE event Occupancy\b");
6494  if (sub == 2)
6495  OccupancyHisto[sub]->SetTitle("HO event Occupancy\b");
6496  if (sub == 3)
6497  OccupancyHisto[sub]->SetTitle("HF event Occupancy\b");
6498  // OccupancyHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6499  OccupancyHisto[sub]->SetXTitle("event occupancy \b");
6500  OccupancyHisto[sub]->SetMarkerColor(4);
6501  OccupancyHisto[sub]->SetLineColor(4);
6502  OccupancyHisto[sub]->Draw("");
6503  }
6504 
6505  cFour->Update();
6506  if (sub == 0)
6507  cFour->Print("MaxxSummedAmplitudes_HB.png");
6508  if (sub == 1)
6509  cFour->Print("MaxxSummedAmplitudes_HE.png");
6510  if (sub == 2)
6511  cFour->Print("MaxxSummedAmplitudes_HO.png");
6512  if (sub == 3)
6513  cFour->Print("MaxxSummedAmplitudes_HF.png");
6514  cFour->Clear();
6515  if (lpqxc)
6516  delete lpqxc;
6517  if (hpzlm)
6518  delete hpzlm;
6519  } //for
6520  gStyle->SetOptStat(0);
6522  cout << ">=>=>>=> countamplmaxHB= " << countamplmaxHB << " countamplmaxHE= " << countamplmaxHE
6523  << " countamplmaxHO= " << countamplmaxHO << " countamplmaxHF= " << countamplmaxHF << endl;
6524  cout << ">=>=>>=> countoccumaxHB= " << countoccumaxHB << " countoccumaxHE= " << countoccumaxHE
6525  << " countoccumaxHO= " << countoccumaxHO << " countoccumaxHF= " << countoccumaxHF << endl;
6526  cout << ">=>=>>=> countamplHB= " << countamplHB << " countamplHE= " << countamplHE << " countamplHO= " << countamplHO
6527  << " countamplHF= " << countamplHF << endl;
6528  cout << ">=>=>>=> countoccuHB= " << countoccuHB << " countoccuHE= " << countoccuHE << " countoccuHO= " << countoccuHO
6529  << " countoccuHF= " << countoccuHF << endl;
6530 
6533  //************************* ***** channelsummedA over depths *****
6534  cout << ">>>>>>>>>>>>>>>>>>>>>>>>channelsummedA over depths " << endl;
6535  TH1F *ChannelDepthsummedAmplitudesPlots[4]; // 1d histogramm for subdet
6536  ChannelDepthsummedAmplitudesPlots[0] = (TH1F *)hfile->Get("h_sumamplitudechannel_HB");
6537  ChannelDepthsummedAmplitudesPlots[1] = (TH1F *)hfile->Get("h_sumamplitudechannel_HE");
6538  ChannelDepthsummedAmplitudesPlots[2] = (TH1F *)hfile->Get("h_sumamplitudechannel_HO");
6539  ChannelDepthsummedAmplitudesPlots[3] = (TH1F *)hfile->Get("h_sumamplitudechannel_HF");
6540  TLine *litebdt[4];
6541  if (ChannelDepthsummedAmplitudesPlots[0])
6542  litebdt[0] = new TLine(80., 0.8, 80., ChannelDepthsummedAmplitudesPlots[0]->GetBinContent(4) + 100.);
6543  if (ChannelDepthsummedAmplitudesPlots[1])
6544  litebdt[1] = new TLine(200., 0.8, 200., ChannelDepthsummedAmplitudesPlots[1]->GetBinContent(7) + 100.);
6545  if (ChannelDepthsummedAmplitudesPlots[2])
6546  litebdt[2] = new TLine(1200., 0.8, 1200., ChannelDepthsummedAmplitudesPlots[2]->GetBinContent(17) + 100.);
6547  if (ChannelDepthsummedAmplitudesPlots[3])
6548  litebdt[3] = new TLine(600., 0.8, 600., ChannelDepthsummedAmplitudesPlots[3]->GetBinContent(6) + 100.);
6549 
6550  gStyle->SetOptStat(110000);
6551  cFour1->Clear();
6552  cFour1->Divide(2, 2);
6553  for (int sub = 0; sub < 4; sub++) {
6554  if (sub == 0)
6555  cFour1->cd(1);
6556  if (sub == 1)
6557  cFour1->cd(2);
6558  if (sub == 2)
6559  cFour1->cd(3);
6560  if (sub == 3)
6561  cFour1->cd(4);
6562  gPad->SetLogy();
6563  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerStyle(20);
6564  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerSize(0.8);
6565  if (sub == 0)
6566  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HB channel Amplitudes\b");
6567  if (sub == 1)
6568  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HE channel Amplitudes\b");
6569  if (sub == 2)
6570  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HO channel Amplitudes\b");
6571  if (sub == 3)
6572  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HF channel Amplitudes\b");
6573  if (sub == 0)
6574  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HB channel depths summed Amplitudes \b");
6575  if (sub == 1)
6576  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HE channel depths summed Amplitudes \b");
6577  if (sub == 2)
6578  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HO channel depths summed Amplitudes \b");
6579  if (sub == 3)
6580  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HF channel depths summed Amplitudes \b");
6581  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerColor(2);
6582  ChannelDepthsummedAmplitudesPlots[sub]->SetLineColor(2);
6583  ChannelDepthsummedAmplitudesPlots[sub]->Draw("");
6584  litebdt[sub]->SetLineColor(kBlue);
6585  litebdt[sub]->Draw("s");
6586  } //for
6587  cFour1->Update();
6588  cFour1->Print("ChannelDepthsummedAmplitudes.png");
6589  cFour1->Clear();
6590  gStyle->SetOptStat(0);
6591 
6594  //************************* ***** Ataildepth1_HB *****
6595  cout << ">>>>>>>>>>>>>>>>>>>>>>>>2DAtaildepth " << endl;
6597  cHB->Clear();
6598  cHB->Divide(2, 1);
6599 
6600  TH2F *DAtaildepth1[2]; // 1d histogramm for subdet
6601  DAtaildepth1[0] = (TH2F *)hfile->Get("h_2DAtaildepth1_HB");
6602  DAtaildepth1[1] = (TH2F *)hfile->Get("h_2D0Ataildepth1_HB");
6603  cHB->cd(1);
6604  if (!DAtaildepth1[0] || !DAtaildepth1[1]) {
6605  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 1" << endl;
6606  } else {
6607  TH2F *tail1 = (TH2F *)DAtaildepth1[0]->Clone("tail1");
6608  tail1->Divide(DAtaildepth1[0], DAtaildepth1[1], 1, 1, "B");
6609  // tail1->Sumw2();
6610  gPad->SetGridy();
6611  gPad->SetGridx();
6612  gPad->SetLogz();
6613  tail1->SetMarkerStyle(20);
6614  tail1->SetMarkerSize(0.4);
6615  tail1->SetTitle("Amplitudes for tail-events (HBdepth1) \b");
6616  tail1->SetXTitle("#eta \b");
6617  tail1->SetYTitle("#phi \b");
6618  tail1->SetZTitle("2D <A> in the tail - HB Depth1 \b");
6619  tail1->SetMarkerColor(2);
6620  tail1->SetLineColor(2);
6621  tail1->Draw("COLZ");
6622  }
6623  TH2F *DAtaildepth2[2]; // 1d histogramm for subdet
6624  DAtaildepth2[0] = (TH2F *)hfile->Get("h_2DAtaildepth2_HB");
6625  DAtaildepth2[1] = (TH2F *)hfile->Get("h_2D0Ataildepth2_HB");
6626  cHB->cd(2);
6627  if (!DAtaildepth2[0] || !DAtaildepth2[1]) {
6628  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 2" << endl;
6629  } else {
6630  TH2F *tail2 = (TH2F *)DAtaildepth2[0]->Clone("tail2");
6631  tail2->Divide(DAtaildepth2[0], DAtaildepth2[1], 1, 1, "B");
6632  // tail2->Sumw2();
6633  gPad->SetGridy();
6634  gPad->SetGridx();
6635  gPad->SetLogz();
6636  tail2->SetMarkerStyle(20);
6637  tail2->SetMarkerSize(0.4);
6638  tail2->SetTitle("Amplitudes for tail-events (HBdepth2) \b");
6639  tail2->SetXTitle("#eta \b");
6640  tail2->SetYTitle("#phi \b");
6641  tail2->SetZTitle("2D <A> in the tail - HB Depth2 \b");
6642  tail2->SetMarkerColor(2);
6643  tail2->SetLineColor(2);
6644  tail2->Draw("COLZ");
6645  }
6646 
6647  cHB->Update();
6648  cHB->Print("AtaildepthHB.png");
6649  cHB->Clear();
6650 
6653  //************************* ***** sum(Signal+NoSignal) occupancy for HF *****
6654  cout << ">>>>>>>>>>>>>>>>>>>>>>>>sumOccupancyHF " << endl;
6656  cHB->Clear();
6657  cHB->Divide(1, 1);
6658  cHB->cd(1);
6659  if (SummedAmplitudeOccupancyHisto[3]) {
6660  TH1F *ufrew1 = (TH1F *)SummedAmplitudeOccupancyHisto[3]->Clone("ufrew1");
6661  if (SummedAmplitudeOccupancyHisto[3] && NoSignalSummedAmplitudeOccupancyHisto[3])
6662  ufrew1->Add(SummedAmplitudeOccupancyHisto[3], NoSignalSummedAmplitudeOccupancyHisto[3], 1, 1);
6663  ufrew1->GetXaxis()->SetRangeUser(1., maxbins + 1.);
6664  gPad->SetGridx();
6665  ufrew1->SetMarkerStyle(20);
6666  ufrew1->SetMarkerSize(0.8);
6667  ufrew1->GetYaxis()->SetLabelSize(0.04);
6668  ufrew1->SetTitle("HF Occupancy vs LS\b");
6669  ufrew1->SetXTitle("average occupancy per LS HF\b");
6670  ufrew1->SetMarkerColor(4);
6671  ufrew1->SetLineColor(0);
6672  ufrew1->SetMaximum(866.);
6673  ufrew1->SetMinimum(856.);
6674  ufrew1->Draw("Error");
6675  cHB->Update();
6676  cHB->Print("sumOccupancyHF.png");
6677  cHB->Clear();
6678  if (ufrew1)
6679  delete ufrew1;
6680  }
6681 
6689  //====================================================================================================================
6690  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =====================================================================" << endl;
6691 
6692  //=====================================================================================================
6693  cout << ">>>>>>>>>>>>>>>>>>>>>>>> ==================================================" << endl;
6694 
6695  //=====================================================================================
6696  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6697  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6698  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6699  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6700 
6701  cout << ">>>>>>> START NOW CREATING OF HTML PAGES <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
6702  //======================================================================
6703  // Creating each test kind for each subdet html pages:
6704  std::string raw_class;
6705  int ind = 0;
6706  ofstream htmlFile;
6707  for (int test = 0; test <= 5; test++) { //Test: 0,
6708  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
6709 
6710  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
6711  if (test == 0) {
6712  if (sub == 1) {
6713  htmlFile.open("HB_CapID.html");
6714  }
6715  if (sub == 2) {
6716  htmlFile.open("HE_CapID.html");
6717  }
6718  if (sub == 3) {
6719  htmlFile.open("HO_CapID.html");
6720  }
6721  if (sub == 4) {
6722  htmlFile.open("HF_CapID.html");
6723  }
6724  }
6725  if (test == 1) {
6726  if (sub == 1) {
6727  htmlFile.open("HB_ADCampl.html");
6728  }
6729  if (sub == 2) {
6730  htmlFile.open("HE_ADCampl.html");
6731  }
6732  if (sub == 3) {
6733  htmlFile.open("HO_ADCampl.html");
6734  }
6735  if (sub == 4) {
6736  htmlFile.open("HF_ADCampl.html");
6737  }
6738  }
6739  if (test == 2) {
6740  if (sub == 1) {
6741  htmlFile.open("HB_Width.html");
6742  }
6743  if (sub == 2) {
6744  htmlFile.open("HE_Width.html");
6745  }
6746  if (sub == 3) {
6747  htmlFile.open("HO_Width.html");
6748  }
6749  if (sub == 4) {
6750  htmlFile.open("HF_Width.html");
6751  }
6752  }
6753  if (test == 3) {
6754  if (sub == 1) {
6755  htmlFile.open("HB_Ratio.html");
6756  }
6757  if (sub == 2) {
6758  htmlFile.open("HE_Ratio.html");
6759  }
6760  if (sub == 3) {
6761  htmlFile.open("HO_Ratio.html");
6762  }
6763  if (sub == 4) {
6764  htmlFile.open("HF_Ratio.html");
6765  }
6766  }
6767  if (test == 4) {
6768  if (sub == 1) {
6769  htmlFile.open("HB_Tmean.html");
6770  }
6771  if (sub == 2) {
6772  htmlFile.open("HE_Tmean.html");
6773  }
6774  if (sub == 3) {
6775  htmlFile.open("HO_Tmean.html");
6776  }
6777  if (sub == 4) {
6778  htmlFile.open("HF_Tmean.html");
6779  }
6780  }
6781  if (test == 5) {
6782  if (sub == 1) {
6783  htmlFile.open("HB_Tmax.html");
6784  }
6785  if (sub == 2) {
6786  htmlFile.open("HE_Tmax.html");
6787  }
6788  if (sub == 3) {
6789  htmlFile.open("HO_Tmax.html");
6790  }
6791  if (sub == 4) {
6792  htmlFile.open("HF_Tmax.html");
6793  }
6794  }
6795 
6796  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
6797  htmlFile << "<head>" << std::endl;
6798  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
6799  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
6800  htmlFile << "<style type=\"text/css\">" << std::endl;
6801  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
6802  << std::endl;
6803  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
6804  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
6805  "text-align: center;}"
6806  << std::endl;
6807  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
6808  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
6809  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
6810  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
6811  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
6812  htmlFile << "</style>" << std::endl;
6813  htmlFile << "<body>" << std::endl;
6814 
6815  if (test == 0) {
6816  if (sub == 1)
6817  htmlFile << "<h1> Cap ID estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6818  if (sub == 2)
6819  htmlFile << "<h1> Cap ID estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6820  if (sub == 3)
6821  htmlFile << "<h1> Cap ID estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6822  if (sub == 4)
6823  htmlFile << "<h1> Cap ID estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6824  }
6825  if (test == 1) {
6826  if (sub == 1)
6827  htmlFile << "<h1> Mean ADC Amplitude estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6828  if (sub == 2)
6829  htmlFile << "<h1> Mean ADC Amplitude estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6830  if (sub == 3)
6831  htmlFile << "<h1> Mean ADC Amplitude estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6832  if (sub == 4)
6833  htmlFile << "<h1> Mean ADC Amplitude estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6834  }
6835  if (test == 2) {
6836  if (sub == 1)
6837  htmlFile << "<h1> Width estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6838  if (sub == 2)
6839  htmlFile << "<h1> Width estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6840  if (sub == 3)
6841  htmlFile << "<h1> Width estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6842  if (sub == 4)
6843  htmlFile << "<h1> Width estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6844  }
6845  if (test == 3) {
6846  if (sub == 1)
6847  htmlFile << "<h1> Ratio estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6848  if (sub == 2)
6849  htmlFile << "<h1> Ratio estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6850  if (sub == 3)
6851  htmlFile << "<h1> Ratio estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6852  if (sub == 4)
6853  htmlFile << "<h1> Ratio estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6854  }
6855  if (test == 4) {
6856  if (sub == 1)
6857  htmlFile << "<h1> Mean bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6858  if (sub == 2)
6859  htmlFile << "<h1> Mean bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6860  if (sub == 3)
6861  htmlFile << "<h1> Mean bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6862  if (sub == 4)
6863  htmlFile << "<h1> Mean bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6864  }
6865  if (test == 5) {
6866  if (sub == 1)
6867  htmlFile << "<h1> Maximum bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6868  if (sub == 2)
6869  htmlFile << "<h1> Maximum bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6870  if (sub == 3)
6871  htmlFile << "<h1> Maximum bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6872  if (sub == 4)
6873  htmlFile << "<h1> Maximum bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6874  }
6875 
6876  if (test == 1) {
6877  htmlFile << "<a name=\"Top\"></a>\n";
6878  htmlFile << "<b>Contents:<br>\n";
6879  htmlFile << "1. <a href=\"#Aij\">A_ij_LS (averaged over events in LS) </a><br>\n";
6880  htmlFile << "2. <a href=\"#OverflowAij\">A_ij_LS in overflow & underflow</a><br>\n";
6881  htmlFile << "3. <a href=\"#MainEstimator\">Main Estimator !!! </a><br>\n";
6882  htmlFile << "4. <a href=\"#ErrorA\">Error type A </a><br>\n";
6883  htmlFile << "5. <a href=\"#ErrorAaverage\">ErrorA cross check</a><br>\n";
6884  htmlFile << "6. <a href=\"#ErrorAoccupancy\">ErrorA occupancy plots</a><br>\n";
6885  htmlFile << "7. <a href=\"#ErrorB\">Error type B</a><br>\n";
6886  htmlFile << "8. <a href=\"#LSstatus\">Table of Average channel-Amplitude in Depthes over LSs </a><br>\n";
6887  htmlFile << "9. <a href=\"#RBXstatus\">RBX Status </a><br>\n";
6888  htmlFile << "10. <a href=\"#RBXPHItable\">Table of Average RBX-Amplitude in Phi over LSs </a><br>\n";
6889  htmlFile << "11. <a href=\"#RBXETAtable\">Table of Average RBX-Amplitude in Eta over LSs </a><br>\n";
6890  htmlFile << "12. <a href=\"#RBX3plots\">RBX A-Ratio to 1st LS: 3 plots </a><br>\n";
6892  }
6893 
6894  // htmlFile << "<a href=\"#Top\">to top</a><br>\n";
6895 
6896  htmlFile << "<br>" << std::endl;
6897  if (test == 0) {
6898  htmlFile << "<h2> 0. Rate of CapID failures over all events of Run </h2>" << std::endl;
6899  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
6900  if (sub == 1)
6901  htmlFile << " <img src=\"MapCapIdErrorHB.png\" />" << std::endl;
6902  if (sub == 2)
6903  htmlFile << " <img src=\"MapCapIdErrorHE.png\" />" << std::endl;
6904  if (sub == 3)
6905  htmlFile << " <img src=\"MapCapIdErrorHO.png\" />" << std::endl;
6906  if (sub == 4)
6907  htmlFile << " <img src=\"MapCapIdErrorHF.png\" />" << std::endl;
6908  }
6909  if (test == 1)
6910  htmlFile << "<a name=\"Aij\"></a>\n";
6911  if (test != 0)
6912  htmlFile << "<h2> 1. Distribution of estimator averaged over events in LS, histogramed over all channels and "
6913  "all LSs </h2>"
6914  << std::endl;
6915  if (test == 0) {
6916  if (sub == 1)
6917  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6918  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6919  if (sub == 2)
6920  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6921  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2), " << CutAb[sub][3]
6922  << " (Depth3).</h2>" << std::endl;
6923  if (sub == 3)
6924  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6925  << CutAb[sub][1] << " (Depth4).</h2>" << std::endl;
6926  if (sub == 4)
6927  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6928  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6929  }
6930 
6931  if (test != 0)
6932  htmlFile << "<h3> see Overflow and Underflow </h3>" << std::endl;
6933  if (test == 0)
6934  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
6935 
6936  if (test == 0) {
6937  if (sub == 1)
6938  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HB.png\" />" << std::endl;
6939  if (sub == 2)
6940  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HE.png\" />" << std::endl;
6941  if (sub == 3)
6942  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HO.png\" />" << std::endl;
6943  if (sub == 4)
6944  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HF.png\" />" << std::endl;
6945  }
6946  if (test == 1) {
6947  if (sub == 1)
6948  htmlFile << " <img src=\"H_ADCamplHB.png\" />" << std::endl;
6949  if (sub == 2)
6950  htmlFile << " <img src=\"H_ADCamplHE.png\" />" << std::endl;
6951  if (sub == 3)
6952  htmlFile << " <img src=\"H_ADCamplHO.png\" />" << std::endl;
6953  if (sub == 4)
6954  htmlFile << " <img src=\"H_ADCamplHF.png\" />" << std::endl;
6955  }
6956  if (test == 2) {
6957  if (sub == 1)
6958  htmlFile << " <img src=\"H_WidthHB.png\" />" << std::endl;
6959  if (sub == 2)
6960  htmlFile << " <img src=\"H_WidthHE.png\" />" << std::endl;
6961  if (sub == 3)
6962  htmlFile << " <img src=\"H_WidthHO.png\" />" << std::endl;
6963  if (sub == 4)
6964  htmlFile << " <img src=\"H_WidthHF.png\" />" << std::endl;
6965  }
6966  if (test == 3) {
6967  if (sub == 1)
6968  htmlFile << " <img src=\"H_RatioHB.png\" />" << std::endl;
6969  if (sub == 2)
6970  htmlFile << " <img src=\"H_RatioHE.png\" />" << std::endl;
6971  if (sub == 3)
6972  htmlFile << " <img src=\"H_RatioHO.png\" />" << std::endl;
6973  if (sub == 4)
6974  htmlFile << " <img src=\"H_RatioHF.png\" />" << std::endl;
6975  }
6976  if (test == 4) {
6977  if (sub == 1)
6978  htmlFile << " <img src=\"H_TmeanHB.png\" />" << std::endl;
6979  if (sub == 2)
6980  htmlFile << " <img src=\"H_TmeanHE.png\" />" << std::endl;
6981  if (sub == 3)
6982  htmlFile << " <img src=\"H_TmeanHO.png\" />" << std::endl;
6983  if (sub == 4)
6984  htmlFile << " <img src=\"H_TmeanHF.png\" />" << std::endl;
6985  }
6986  if (test == 5) {
6987  if (sub == 1)
6988  htmlFile << " <img src=\"H_TmaxHB.png\" />" << std::endl;
6989  if (sub == 2)
6990  htmlFile << " <img src=\"H_TmaxHE.png\" />" << std::endl;
6991  if (sub == 3)
6992  htmlFile << " <img src=\"H_TmaxHO.png\" />" << std::endl;
6993  if (sub == 4)
6994  htmlFile << " <img src=\"H_TmaxHF.png\" />" << std::endl;
6995  }
6996  htmlFile << "<br>" << std::endl;
6997  if (test == 1)
6998  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
6999 
7000  if (test == 0)
7001  htmlFile << "<h2> 2a. Number of bad channels per event distribution in Run</h2>" << std::endl;
7002  if (test == 0)
7003  htmlFile << "<h3> Legends: dots correspond to BAD LS candidates. </h3>" << std::endl;
7004  if (test == 0) {
7005  if (sub == 1)
7006  htmlFile << " <img src=\"HistNBadChsHB.png\" />" << std::endl;
7007  if (sub == 2)
7008  htmlFile << " <img src=\"HistNBadChsHE.png\" />" << std::endl;
7009  if (sub == 3)
7010  htmlFile << " <img src=\"HistNBadChsHO.png\" />" << std::endl;
7011  if (sub == 4)
7012  htmlFile << " <img src=\"HistNBadChsHF.png\" />" << std::endl;
7013  }
7014 
7015  if (test == 1)
7016  htmlFile << "<a name=\"OverflowAij\"></a>\n";
7017  if (test != 0)
7018  htmlFile << "<h2> 2. Estimator averaged over all events in the RUN for entries in overflow and underflow of "
7019  "corresponding histogram above </h2>"
7020  << std::endl;
7021  // if (test !=0) htmlFile << "<h2> 2. Estimator averaged over all events in the RUN </h2>"<< std::endl;
7022  if (test == 0)
7023  htmlFile << "<h2> 2b. Averaged number of bad channels for each LS </h2>" << std::endl;
7024  // if (test !=0) htmlFile << "<h3> Channel legend: white - good, other colour - bad. </h3>"<< std::endl;
7025  if (test == 0) {
7026  if (sub == 1)
7027  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7028  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7029  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7030  if (sub == 2)
7031  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7032  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3) correspond BAD LS.</h3>"
7033  << std::endl;
7034  if (sub == 3)
7035  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7036  << " (Depth4) correspond BAD LS.</h3>" << std::endl;
7037  if (sub == 4)
7038  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7039  << Cut0[test][sub][2] << " (Depth2) correspond BAD LS.</h3>" << std::endl;
7040  }
7041  if (test == 0) {
7042  if (sub == 1)
7043  htmlFile << " <img src=\"HistNBCMNHB.png\" />" << std::endl;
7044  if (sub == 2)
7045  htmlFile << " <img src=\"HistNBCMNHE.png\" />" << std::endl;
7046  if (sub == 3)
7047  htmlFile << " <img src=\"HistNBCMNHO.png\" />" << std::endl;
7048  if (sub == 4)
7049  htmlFile << " <img src=\"HistNBCMNHF.png\" />" << std::endl;
7050  }
7051  if (test == 1) {
7052  if (sub == 1)
7053  htmlFile << " <img src=\"MapADCamplHB.png\" />" << std::endl;
7054  if (sub == 2)
7055  htmlFile << " <img src=\"MapADCamplHE.png\" />" << std::endl;
7056  if (sub == 3)
7057  htmlFile << " <img src=\"MapADCamplHO.png\" />" << std::endl;
7058  if (sub == 4)
7059  htmlFile << " <img src=\"MapADCamplHF.png\" />" << std::endl;
7060  }
7061  if (test == 2) {
7062  if (sub == 1)
7063  htmlFile << " <img src=\"MapWidthHB.png\" />" << std::endl;
7064  if (sub == 2)
7065  htmlFile << " <img src=\"MapWidthHE.png\" />" << std::endl;
7066  if (sub == 3)
7067  htmlFile << " <img src=\"MapWidthHO.png\" />" << std::endl;
7068  if (sub == 4)
7069  htmlFile << " <img src=\"MapWidthHF.png\" />" << std::endl;
7070  }
7071  if (test == 3) {
7072  if (sub == 1)
7073  htmlFile << " <img src=\"MapRatioHB.png\" />" << std::endl;
7074  if (sub == 2)
7075  htmlFile << " <img src=\"MapRatioHE.png\" />" << std::endl;
7076  if (sub == 3)
7077  htmlFile << " <img src=\"MapRatioHO.png\" />" << std::endl;
7078  if (sub == 4)
7079  htmlFile << " <img src=\"MapRatioHF.png\" />" << std::endl;
7080  }
7081  if (test == 4) {
7082  if (sub == 1)
7083  htmlFile << " <img src=\"MapTmeanHB.png\" />" << std::endl;
7084  if (sub == 2)
7085  htmlFile << " <img src=\"MapTmeanHE.png\" />" << std::endl;
7086  if (sub == 3)
7087  htmlFile << " <img src=\"MapTmeanHO.png\" />" << std::endl;
7088  if (sub == 4)
7089  htmlFile << " <img src=\"MapTmeanHF.png\" />" << std::endl;
7090  }
7091  if (test == 5) {
7092  if (sub == 1)
7093  htmlFile << " <img src=\"MapTmaxHB.png\" />" << std::endl;
7094  if (sub == 2)
7095  htmlFile << " <img src=\"MapTmaxHE.png\" />" << std::endl;
7096  if (sub == 3)
7097  htmlFile << " <img src=\"MapTmaxHO.png\" />" << std::endl;
7098  if (sub == 4)
7099  htmlFile << " <img src=\"MapTmaxHF.png\" />" << std::endl;
7100  }
7101  htmlFile << "<br>" << std::endl;
7102  if (test == 1)
7103  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7104 
7105  if (test == 1)
7106  htmlFile << "<a name=\"MainEstimator\"></a>\n";
7107  if (test != 0)
7108  htmlFile
7109  << "<h2> 3. Distribution of estimator averaged over events in LS and over all channels for each LS </h2>"
7110  << std::endl;
7111  if (test == 0) {
7112  if (sub == 1)
7113  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7114  << " (Depth2) in each LS.</h2>" << std::endl;
7115  if (sub == 2)
7116  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7117  << " (Depth2), " << CutPo[sub][3] << " (Depth3) in each LS.</h2>" << std::endl;
7118  if (sub == 3)
7119  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][4] << " (Depth4) in each LS.</h2>"
7120  << std::endl;
7121  if (sub == 4)
7122  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7123  << " (Depth2) in each LS.</h2>" << std::endl;
7124  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
7125  }
7126  if (test != 0) {
7127  if (sub == 1)
7128  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7129  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7130  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7131  if (sub == 2)
7132  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7133  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7134  << " (Depth4), " << Cut0[test][sub][5] << " (Depth5), " << Cut0[test][sub][6] << " (Depth6), "
7135  << Cut0[test][sub][7] << " (Depth7) correspond BAD LS. </h3>" << std::endl;
7136  if (sub == 3)
7137  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7138  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7139  if (sub == 4)
7140  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7141  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7142  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7143  }
7144  if (test == 0) {
7145  if (sub == 1)
7146  htmlFile << " <img src=\"HistPortHB.png\" />" << std::endl;
7147  if (sub == 2)
7148  htmlFile << " <img src=\"HistPortHE.png\" />" << std::endl;
7149  if (sub == 3)
7150  htmlFile << " <img src=\"HistPortHO.png\" />" << std::endl;
7151  if (sub == 4)
7152  htmlFile << " <img src=\"HistPortHF.png\" />" << std::endl;
7153  }
7154  if (test == 1) {
7155  if (sub == 1)
7156  htmlFile << " <img src=\"HistADCamplHB.png\" />" << std::endl;
7157  if (sub == 2)
7158  htmlFile << " <img src=\"HistADCamplHE.png\" />" << std::endl;
7159  if (sub == 3)
7160  htmlFile << " <img src=\"HistADCamplHO.png\" />" << std::endl;
7161  if (sub == 4)
7162  htmlFile << " <img src=\"HistADCamplHF.png\" />" << std::endl;
7163  }
7164  if (test == 2) {
7165  if (sub == 1)
7166  htmlFile << " <img src=\"HistWidthHB.png\" />" << std::endl;
7167  if (sub == 2)
7168  htmlFile << " <img src=\"HistWidthHE.png\" />" << std::endl;
7169  if (sub == 3)
7170  htmlFile << " <img src=\"HistWidthHO.png\" />" << std::endl;
7171  if (sub == 4)
7172  htmlFile << " <img src=\"HistWidthHF.png\" />" << std::endl;
7173  }
7174  if (test == 3) {
7175  if (sub == 1)
7176  htmlFile << " <img src=\"HistRatioHB.png\" />" << std::endl;
7177  if (sub == 2)
7178  htmlFile << " <img src=\"HistRatioHE.png\" />" << std::endl;
7179  if (sub == 3)
7180  htmlFile << " <img src=\"HistRatioHO.png\" />" << std::endl;
7181  if (sub == 4)
7182  htmlFile << " <img src=\"HistRatioHF.png\" />" << std::endl;
7183  }
7184  if (test == 4) {
7185  if (sub == 1)
7186  htmlFile << " <img src=\"HistTmeanHB.png\" />" << std::endl;
7187  if (sub == 2)
7188  htmlFile << " <img src=\"HistTmeanHE.png\" />" << std::endl;
7189  if (sub == 3)
7190  htmlFile << " <img src=\"HistTmeanHO.png\" />" << std::endl;
7191  if (sub == 4)
7192  htmlFile << " <img src=\"HistTmeanHF.png\" />" << std::endl;
7193  }
7194  if (test == 5) {
7195  if (sub == 1)
7196  htmlFile << " <img src=\"HistTmaxHB.png\" />" << std::endl;
7197  if (sub == 2)
7198  htmlFile << " <img src=\"HistTmaxHE.png\" />" << std::endl;
7199  if (sub == 3)
7200  htmlFile << " <img src=\"HistTmaxHO.png\" />" << std::endl;
7201  if (sub == 4)
7202  htmlFile << " <img src=\"HistTmaxHF.png\" />" << std::endl;
7203  }
7204  htmlFile << "<br>" << std::endl;
7205 
7206  if (test == 1) {
7207  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7208  htmlFile << "<a name=\"ErrorA\"></a>\n";
7209  htmlFile << "<h2> 4. Error type A</h2>\n";
7210  htmlFile << "<h3> note: no sence to see plots of this item if max difference is too large(due to very high A "
7211  "of some channels)</h3>\n";
7212  htmlFile << "<br>\n";
7213 
7214  //HB:
7215  if (sub == 1) {
7216  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.6 (p-p collisions) </h3>\n";
7217  htmlFile << " <img src=\"HistErrA_HB.png\" />\n";
7218  htmlFile << "<br>\n";
7219  if (flagErrAB_HB[0] == -1)
7220  htmlFile << "<h3>test was not possible</h3>\n";
7221  else if (flagErrAB_HB[0] == 0)
7222  htmlFile << "<h3> Fine:NoErrorA_HB (Mean of max difference " << avedelta_HB
7223  << " is within 0.1-1.6) </h3>\n";
7224  else if (flagErrAB_HB[0] == 1)
7225  htmlFile << "<<h3> ErrorA_HB is available once Mean of max difference " << avedelta_HB
7226  << " is out 0.1-1.6 (p-p collisions)</font></h3>\n";
7227  else
7228  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7229  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7230 
7231  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7232 
7233  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7234  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >25), "
7235  "3) with channel Amplitude (A<35); </h2>\n";
7236  htmlFile << " <img src=\"ChkErrA_HB1.png\" /><br><br>\n";
7237  htmlFile << " <img src=\"ChkErrA_HB2.png\" /><br>\n";
7238  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7239 
7240  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7241  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 25 "
7242  "(HBM:neg.eta;HBP:pos.eta) </h2>\n";
7243  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7244  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.6 at least for HF- or "
7245  "HF+ </h2>\n";
7246  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.6 and is the same "
7247  "for HF- and HF+ </h2>\n";
7248  htmlFile << " <img src=\"OccPlots_HB.png\" /><br><br>\n";
7249  htmlFile << "<br>\n";
7250  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7251 
7252  htmlFile << "<a name=\"ErrorB\"></a>\n";
7253  htmlFile << "<h2> 7. Error type B\n";
7254  htmlFile << "<h3> ErrorB identification: digi-collection size != 10.</h3>\n";
7255  htmlFile << " <img src=\"HistErrB_HB_1.png\" />\n<br>\n";
7256  htmlFile << " <img src=\"HistErrB_HB_2.png\" />\n<br>\n";
7257  htmlFile << "<br>\n";
7258  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HB << " LS </h3>\n";
7259  htmlFile << "<br>\n";
7260  }
7261 
7262  //HE:
7263  if (sub == 2) {
7264  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.2-1.8 (p-p collisions) </h3>\n";
7265  htmlFile << " <img src=\"HistErrA_HE.png\" />\n";
7266  htmlFile << "<br>\n";
7267  if (flagErrAB_HE[0] == -1)
7268  htmlFile << "<h3>test was not possible</h3>\n";
7269  else if (flagErrAB_HE[0] == 0)
7270  htmlFile << "<h3> Fine:NoErrorA_HE (Mean of max difference " << avedelta_HE
7271  << " is within 0.2-1.8) </h3>\n";
7272  else if (flagErrAB_HE[0] == 1)
7273  htmlFile << "<<h3> ErrorA_HE is available once Mean of max difference " << avedelta_HE
7274  << " is out 0.2-1.8 (p-p collisions)</font></h3>\n";
7275  else
7276  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7277  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7278 
7279  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7280 
7281  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7282  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> "
7283  ">1000.fC), 3) with channel Amplitude (A<500fC); </h2>\n";
7284  htmlFile << " <img src=\"ChkErrA_HE1.png\" /><br><br>\n";
7285  htmlFile << " <img src=\"ChkErrA_HE2.png\" /><br>\n";
7286  htmlFile << " <img src=\"ChkErrA_HE3.png\" /><br>\n";
7287  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7288 
7289  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7290  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 35 "
7291  "(HEM:neg.eta;HEP:pos.eta) </h2>\n";
7292  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7293  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.3 at least for HF- or "
7294  "HF+ </h2>\n";
7295  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.3 and is the same "
7296  "for HF- and HF+ </h2>\n";
7297  htmlFile << " <img src=\"OccPlots_HE.png\" /><br><br>\n";
7298  htmlFile << "<br>\n";
7299  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7300 
7301  htmlFile << "<a name=\"ErrorB\"></a>\n";
7302  htmlFile << "<h2> 7. Error type B\n";
7303  htmlFile << "<h3> ErrorB identification: digi-collection size != 8.</h3>\n";
7304  htmlFile << " <img src=\"HistErrB_HE_1.png\" />\n<br>\n";
7305  htmlFile << " <img src=\"HistErrB_HE_2.png\" />\n<br>\n";
7306  htmlFile << " <img src=\"HistErrB_HE_3.png\" />\n<br>\n";
7307  htmlFile << "<br>\n";
7308  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HE << " LS </h3>\n";
7309  htmlFile << "<br>\n";
7310  }
7311 
7312  //HO:
7313  if (sub == 3) {
7314  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.5 (p-p collisions) </h3>\n";
7315  htmlFile << " <img src=\"HistErrA_HO.png\" />\n";
7316  htmlFile << "<br>\n";
7317  if (flagErrAB_HO[0] == -1)
7318  htmlFile << "<h3>test was not possible</h3>\n";
7319  else if (flagErrAB_HO[0] == 0)
7320  htmlFile << "<h3> Fine:NoErrorA_HO (Mean of max difference " << avedelta_HO
7321  << " is within 0.1-1.5) </h3>\n";
7322  else if (flagErrAB_HO[0] == 1)
7323  htmlFile << "<<h3> ErrorA_HO is available once Mean of max difference " << avedelta_HO
7324  << " is out 0.1-1.5 (p-p collisions)</font></h3>\n";
7325  else
7326  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7327  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7328 
7329  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7330 
7331  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7332  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >80), "
7333  "3) with channel Amplitude (A<100); </h2>\n";
7334  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7335  htmlFile << " <img src=\"ChkErrA_HO4.png\" /><br><br>\n";
7336  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7337 
7338  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7339  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 80 "
7340  "(HOM:neg.eta;HOP:pos.eta) </h2>\n";
7341  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7342  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7343  "HF+ </h2>\n";
7344  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7345  "for HF- and HF+ </h2>\n";
7346  htmlFile << " <img src=\"OccPlots_HO.png\" /><br><br>\n";
7347  htmlFile << "<br>\n";
7348  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7349 
7350  htmlFile << "<a name=\"ErrorB\"></a>\n";
7351  htmlFile << "<h2> 7. Error type B\n";
7352  htmlFile << "<h3> ErrorB identification: digi-collection size != 10. </h3>\n";
7353  htmlFile << " <img src=\"HistErrB_HO_4.png\" />\n<br>\n";
7354  htmlFile << "<br>\n";
7355  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HO << " LS </h3>\n";
7356  htmlFile << "<br>\n";
7357  }
7358 
7359  //HF:
7360  if (sub == 4) {
7361  // flagSpecHF+=1;
7362  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.8-2.4 (p-p collisions) </h3>\n";
7363  htmlFile << " <img src=\"HistErrA_HF.png\" />\n";
7364  htmlFile << "<br>\n";
7365  if (flagErrAB_HF[0] == -1)
7366  htmlFile << "<h3>test was not possible</h3>\n";
7367  else if (flagErrAB_HF[0] == 0)
7368  htmlFile << "<h3> Fine:NoErrorA_HF (Mean of max difference " << avedelta_HF
7369  << " is within 0.8-2.4) </h3>\n";
7370  else if (flagErrAB_HF[0] == 1)
7371  htmlFile << "<<h3> ErrorA_HF is available once Mean of max difference " << avedelta_HF
7372  << " is out 0.8-2.4 (p-p collisions)</font></h3>\n";
7373  else
7374  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7375  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7376 
7377  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7378 
7379  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7380  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >20), "
7381  "3) with channel Amplitude (A<20); </h2>\n";
7382  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7383  htmlFile << " <img src=\"ChkErrA_HF1.png\" /><br><br>\n";
7384  htmlFile << " <img src=\"ChkErrA_HF2.png\" /><br>\n";
7385  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7386 
7387  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7388  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 20 "
7389  "(HFM:neg.eta;HFP:pos.eta) </h2>\n";
7390  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7391  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7392  "HF+ </h2>\n";
7393  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7394  "for HF- and HF+ </h2>\n";
7395  htmlFile << " <img src=\"OccPlots_HF.png\" /><br><br>\n";
7396  htmlFile << "<br>\n";
7397  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7398 
7399  htmlFile << "<a name=\"ErrorB\"></a>\n";
7400  htmlFile << "<h2> 7. Error type B\n";
7401  htmlFile << "<h3> ErrorB identification: digi-collection size != 4. </h3>\n";
7402  htmlFile << " <img src=\"HistErrB_HF_1.png\" />\n<br>\n";
7403  htmlFile << " <img src=\"HistErrB_HF_2.png\" />\n<br>\n";
7404  htmlFile << "<br>\n";
7405  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HF << " LS </h3>\n";
7406  htmlFile << "<br>\n";
7407  }
7408  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7409 
7410  } //test=1 Amplitude
7411 
7412  if (test == 1)
7413  htmlFile << "<a name=\"LSstatus\"></a>\n";
7414  // Continue with common sections
7415  if (sub == 1) {
7416  htmlFile << "<h2> 8.Lumisection Status for HB: </h2>" << std::endl;
7417  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: <td class=\"s6\" "
7418  "align=\"center\">"
7419  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2] << " (Depth2). </td></h3>" << std::endl;
7420  }
7421  if (sub == 2) {
7422  htmlFile << "<h2> 8.Lumisection Status for HE: </h2>" << std::endl;
7423  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7424  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3),"
7425  << Cut0[test][sub][4] << " (Depth4)," << Cut0[test][sub][5] << " (Depth5)," << Cut0[test][sub][6]
7426  << " (Depth6)," << Cut0[test][sub][7] << " (Depth7). </h3>" << std::endl;
7427  }
7428  if (sub == 3) {
7429  // htmlFile << Form("<h2> %d.Lumisection Status for HO </h2>",4+flagSpecHF)<< std::endl;
7430  htmlFile << "<h2> 8.Lumisection Status for HO: </h2>" << std::endl;
7431  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][4]
7432  << " (Depth4). </h3>" << std::endl;
7433  }
7434  if (sub == 4) {
7435  htmlFile << "<h2> 8.Lumisection Status for HF: </h2>" << std::endl;
7436  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7437  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), "
7438  << Cut0[test][sub][4] << " (Depth4), </h3>" << std::endl;
7439  }
7440  htmlFile << "<br>" << std::endl;
7441  htmlFile << "<table>" << std::endl;
7442  htmlFile << "<tr>";
7443  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7444  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7445  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7447 
7448  int kkkkkkmax = k_max[sub];
7449  if ((sub == 4 || sub == 2) && test == 1)
7450  kkkkkkmax = k_maxHFupgrade[sub];
7451  // if (test==1 && sub==4) kkkkkkmax = k_maxHFupgrade[sub];
7452 
7453  if (test == 0)
7454  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7455  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > Depth " << k << " </td>" << std::endl;
7456  if (test == 1)
7457  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7458  htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth " << k << " </td>" << std::endl;
7459  if (test == 2)
7460  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7461  htmlFile << "<td class=\"s1\" align=\"center\">< W > Depth " << k << " </td>" << std::endl;
7462  if (test == 3)
7463  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7464  htmlFile << "<td class=\"s1\" align=\"center\">< R > Depth " << k << " </td>" << std::endl;
7465  if (test == 4)
7466  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7467  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > Depth " << k << " </td>" << std::endl;
7468  if (test == 5)
7469  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7470  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > Depth " << k << " </td>" << std::endl;
7471  htmlFile << "</tr>" << std::endl;
7472 
7473  ind = 0;
7474  for (int i = 1; i <= MaxLum; i++) {
7475  if ((ind % 2) == 1)
7476  raw_class = "<td class=\"s2\" align=\"center\">";
7477  else
7478  raw_class = "<td class=\"s3\" align=\"center\">";
7479  htmlFile << "<tr>" << std::endl;
7480  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7481  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7482  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7483  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
7484  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k]) {
7485  if (test == 1)
7486  htmlFile << "<td class=\"s6\" align=\"center\">"
7487  << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7488  else
7489  htmlFile << "<td class=\"s6\" align=\"center\">" << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i))
7490  << "</td>" << std::endl;
7491  } else {
7492  if (test == 1)
7493  htmlFile << raw_class << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7494  else
7495  htmlFile << raw_class << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7496  }
7497  }
7498  htmlFile << "</tr>" << std::endl;
7499  ind += 1;
7500  }
7501  htmlFile << "</table>" << std::endl;
7502 
7503  htmlFile << "<br>" << std::endl;
7504  if (test == 1)
7505  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7506  htmlFile << "<br>" << std::endl;
7507 
7508  // Only for Amplitudes (test=1):
7510  if (test == 1) {
7513  htmlFile << "<a name=\"RBXstatus\"></a>\n";
7514 
7515  //HB j = 7,8,9,10 11,12,13,14
7516  if (sub == 1) {
7517  htmlFile << "<h2> 9. Average Amplitudes of RBX for HB: </h2>" << std::endl;
7518  htmlFile << "<h3> where </h3>" << std::endl;
7519  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7520  "(Positive direction); </h3>"
7521  << std::endl;
7522  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7523  // htmlFile << "<h3> jphi = 0, 1, 2, 3, 4, 5 (range 1) ............&& ............ jphi = 6, 7, 8, 9,10,11 (range 2) ............&& ............ jphi = 12,13,14,15,16,17 (range 3)</h3>"<< std::endl;
7524  htmlFile << " <img src=\"RBX-HB-2Dplot.png\" />\n";
7525  htmlFile << "<br>\n";
7526 
7527  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HB: </h2>" << std::endl;
7528  htmlFile << " <img src=\"RBX-HB-1Dplot.png\" />\n";
7529  htmlFile << "<br>\n";
7530 
7531  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HB: </h2>" << std::endl;
7532  htmlFile << " <img src=\"RBX-HB-11Dplot.png\" />\n";
7533  htmlFile << "<br>\n";
7534 
7535  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7536  }
7537  // HE: j = 3,4,5, 6, 7 14,15,16,17,18
7538  if (sub == 2) {
7539  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HE: </h2>" << std::endl;
7540  htmlFile << "<h3> where </h3>" << std::endl;
7541  htmlFile << "<h3> jeta = 3,4,5, 6, 7 (Negative direction); ............&& ............ jeta = "
7542  "14,15,16,17,18 (Positive direction); </h3>"
7543  << std::endl;
7544  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7545  // htmlFile << "<h3> jphi = 0, 1, 2, 3, 4, 5 (range 1) ............&& ............ jphi = 6, 7, 8, 9,10,11 (range 2) ............&& ............ jphi = 12,13,14,15,16,17 (range 3)</h3>"<< std::endl;
7546  htmlFile << " <img src=\"RBX-HE-2Dplot.png\" />\n";
7547  htmlFile << "<br>\n";
7548 
7549  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HE: </h2>" << std::endl;
7550  htmlFile << " <img src=\"RBX-HE-1Dplot.png\" />\n";
7551  htmlFile << "<br>\n";
7552 
7553  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HE: </h2>" << std::endl;
7554  htmlFile << " <img src=\"RBX-HE-11Dplot.png\" />\n";
7555  htmlFile << "<br>\n";
7556 
7557  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7558  }
7559  // HO: j = 7,8,9,10 11,12,13,14
7560  if (sub == 3) {
7561  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HO: </h2>" << std::endl;
7562  htmlFile << "<h3> where </h3>" << std::endl;
7563  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7564  "(Positive direction); </h3>"
7565  << std::endl;
7566  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7567  // htmlFile << "<h3> jphi = 0, 1, 2, 3, 4, 5 (range 1) ............&& ............ jphi = 6, 7, 8, 9,10,11 (range 2) ............&& ............ jphi = 12,13,14,15,16,17 (range 3)</h3>"<< std::endl;
7568  htmlFile << " <img src=\"RBX-HO-2Dplot.png\" />\n";
7569  htmlFile << "<br>\n";
7570 
7571  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HO: </h2>" << std::endl;
7572  htmlFile << " <img src=\"RBX-HO-1Dplot.png\" />\n";
7573  htmlFile << "<br>\n";
7574 
7575  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HO: </h2>" << std::endl;
7576  htmlFile << " <img src=\"RBX-HO-11Dplot.png\" />\n";
7577  htmlFile << "<br>\n";
7578 
7579  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7580  }
7581  //HF:j = 0,1,2, 3 18,19,20,21
7582  if (sub == 4) {
7583  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HF: </h2>" << std::endl;
7584  htmlFile << "<h3> where </h3>" << std::endl;
7585  htmlFile << "<h3> jeta = 0,1,2, 3 (Negative direction); ............&& ............ jeta = 18,19,20,21 "
7586  "(Positive direction); </h3>"
7587  << std::endl;
7588  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7589  // htmlFile << "<h3> jphi = 0, 1, 2, 3, 4, 5 (range 1) ............&& ............ jphi = 6, 7, 8, 9,10,11 (range 2) ............&& ............ jphi = 12,13,14,15,16,17 (range 3)</h3>"<< std::endl;
7590  htmlFile << " <img src=\"RBX-HF-2Dplot.png\" />\n";
7591  htmlFile << "<br>\n";
7592 
7593  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HF: </h2>" << std::endl;
7594  htmlFile << " <img src=\"RBX-HF-1Dplot.png\" />\n";
7595  htmlFile << "<br>\n";
7596 
7597  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HF: </h2>" << std::endl;
7598  htmlFile << " <img src=\"RBX-HF-11Dplot.png\" />\n";
7599  htmlFile << "<br>\n";
7600 
7601  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7602  }
7603  htmlFile << "<br>" << std::endl;
7604 
7607 
7608  htmlFile << "<a name=\"RBXPHItable\"></a>\n";
7609  int cutA_ALL = 0;
7610  // float cutA_HB = 100.;float cutA_HE = 1000000.;float cutA_HO = 150.;float cutA_HF = 500.;
7611  if (sub == 1) {
7612  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HB: </h2>" << std::endl;
7613  htmlFile
7614  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7615  << cutA_HB << std::endl;
7616  cutA_ALL = cutA_HB;
7617  }
7618  if (sub == 2) {
7619  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HE: </h2>" << std::endl;
7620  htmlFile
7621  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7622  << cutA_HE << std::endl;
7623  cutA_ALL = cutA_HE;
7624  }
7625  if (sub == 3) {
7626  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HO: </h2>" << std::endl;
7627  htmlFile
7628  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7629  << cutA_HO << std::endl;
7630  cutA_ALL = cutA_HO;
7631  }
7632  if (sub == 4) {
7633  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HF: </h2>" << std::endl;
7634  htmlFile
7635  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7636  << cutA_HF << std::endl;
7637  cutA_ALL = cutA_HF;
7638  }
7639 
7640  htmlFile << "<br>" << std::endl;
7641  htmlFile << "<table>" << std::endl;
7642  htmlFile << "<tr>";
7643  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7644  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7645  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7647 
7648  // k is jphi
7649  for (int k = 0; k < njphi; k++)
7650  htmlFile << "<td class=\"s1\" align=\"center\"> iPHI " << k << " </td>" << std::endl;
7651  htmlFile << "</tr>" << std::endl;
7653 
7654  ind = 0;
7655  // i is LS
7656  for (int i = 1; i <= MaxLum; i++) {
7657  if ((ind % 2) == 1)
7658  raw_class = "<td class=\"s2\" align=\"center\">";
7659  else
7660  raw_class = "<td class=\"s3\" align=\"center\">";
7661  htmlFile << "<tr>" << std::endl;
7662  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7663  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7664  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7665 
7666  // k is jphi
7667  for (int k = 0; k < njphi; k++) {
7668  if (sub == 1) {
7669  if (int(alexhb[k][i - 1]) > cutA_ALL) {
7670  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7671  } else {
7672  htmlFile << raw_class << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7673  }
7674  } // HB end
7675  if (sub == 2) {
7676  if (int(alexhe[k][i - 1]) > cutA_ALL) {
7677  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7678  } else {
7679  htmlFile << raw_class << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7680  }
7681  } // HE end
7682  if (sub == 3) {
7683  if (int(alexho[k][i - 1]) > cutA_ALL) {
7684  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexho[k][i - 1]) << "</td>" << std::endl;
7685  } else {
7686  htmlFile << raw_class << int(alexho[k][i - 1]) << "</td>" << std::endl;
7687  }
7688  } // HO end
7689  if (sub == 4) {
7690  if (int(alexhf[k][i - 1]) > cutA_ALL) {
7691  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7692  } else {
7693  htmlFile << raw_class << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7694  }
7695  } // HF end
7697  } // k over PHI-RBX
7698  htmlFile << "</tr>" << std::endl;
7699  ind += 1;
7700  } // i over LSs
7701  htmlFile << "</table>" << std::endl;
7702  htmlFile << "<br>" << std::endl;
7703  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7704  htmlFile << "<br>" << std::endl;
7706 
7707  htmlFile << "<a name=\"RBXETAtable\"></a>\n";
7708  int cutB_ALL = 0;
7709  // float cutB_HB = 100.;float cutB_HE = 1000000.;float cutB_HO = 150.;float cutB_HF = 500.;
7710  if (sub == 1) {
7711  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HB: </h2>" << std::endl;
7712  htmlFile
7713  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7714  << cutB_HB << std::endl;
7715  cutB_ALL = cutB_HB;
7716  }
7717  if (sub == 2) {
7718  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HE: </h2>" << std::endl;
7719  htmlFile
7720  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7721  << cutB_HE << std::endl;
7722  cutB_ALL = cutB_HE;
7723  }
7724  if (sub == 3) {
7725  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HO: </h2>" << std::endl;
7726  htmlFile
7727  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7728  << cutB_HO << std::endl;
7729  cutB_ALL = cutB_HO;
7730  }
7731  if (sub == 4) {
7732  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HF: </h2>" << std::endl;
7733  htmlFile
7734  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7735  << cutB_HF << std::endl;
7736  cutB_ALL = cutB_HF;
7737  }
7738 
7739  htmlFile << "<br>" << std::endl;
7740  htmlFile << "<table>" << std::endl;
7741  htmlFile << "<tr>";
7742  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7743  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7744  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7746 
7747  // k is jeta
7748  for (int k = 0; k < njeta; k++)
7749  htmlFile << "<td class=\"s1\" align=\"center\"> iETA " << k << " </td>" << std::endl;
7750  htmlFile << "</tr>" << std::endl;
7752 
7753  ind = 0;
7754  // i is LS
7755  for (int i = 1; i <= MaxLum; i++) {
7756  if ((ind % 2) == 1)
7757  raw_class = "<td class=\"s2\" align=\"center\">";
7758  else
7759  raw_class = "<td class=\"s3\" align=\"center\">";
7760  htmlFile << "<tr>" << std::endl;
7761  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7762  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7763  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7764 
7765  // k is jeta
7766  for (int k = 0; k < njeta; k++) {
7767  if (sub == 1) {
7768  if (int(blexhb[k][i - 1]) > cutB_ALL) {
7769  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7770  } else {
7771  htmlFile << raw_class << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7772  }
7773  } // HB end
7774  if (sub == 2) {
7775  if (int(blexhe[k][i - 1]) > cutB_ALL) {
7776  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7777  } else {
7778  htmlFile << raw_class << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7779  }
7780  } // HE end
7781  if (sub == 3) {
7782  if (int(blexho[k][i - 1]) > cutB_ALL) {
7783  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexho[k][i - 1]) << "</td>" << std::endl;
7784  } else {
7785  htmlFile << raw_class << int(blexho[k][i - 1]) << "</td>" << std::endl;
7786  }
7787  } // HO end
7788  if (sub == 4) {
7789  if (int(blexhf[k][i - 1]) > cutB_ALL) {
7790  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7791  } else {
7792  htmlFile << raw_class << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7793  }
7794  } // HF end
7796  } // k over ETA-RBX
7797  htmlFile << "</tr>" << std::endl;
7798  ind += 1;
7799  } // i over LSs
7800  htmlFile << "</table>" << std::endl;
7801  htmlFile << "<br>" << std::endl;
7802  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7803  htmlFile << "<br>" << std::endl;
7805 
7808  htmlFile << "<a name=\"RBX3plots\"></a>\n";
7809  htmlFile << "<br>\n";
7810  htmlFile << "<h2> 12. (Rij) - RBX-amplitudes normilized on reference LS (~=1st) </h2>" << std::endl;
7811  htmlFile << "<h3> ( Rji . . is ratio of . . . . A_j_i . . to . . A_j_ref . . . . for . . j-RBX . . and . . "
7812  "i-LS . ) </h3>"
7813  << std::endl;
7814 
7815  htmlFile << "<br>\n";
7816  htmlFile << "<h2> . . . . . . . . . . . . . . 1) . average Ri vs iLS:. . . . . . . . . . . . . . . . . . . . . "
7817  ". . 2) . average Rj shown for Rij outside meanValue range either 0.95-1.05 or 3RMS: . . . . . . . "
7818  ". . . . . . . . . . . . . . . . . . 3) . Rij: </h2>"
7819  << std::endl;
7820  htmlFile << "<br>\n";
7821  if (sub == 1) {
7822  htmlFile << " <img src=\"RBX-HB-3plots.png\" />\n";
7823  }
7824  if (sub == 2) {
7825  htmlFile << " <img src=\"RBX-HE-3plots.png\" />\n";
7826  }
7827  if (sub == 3) {
7828  htmlFile << " <img src=\"RBX-HO-3plots.png\" />\n";
7829  }
7830  if (sub == 4) {
7831  htmlFile << " <img src=\"RBX-HF-3plots.png\" />\n";
7832  }
7833  htmlFile << "<br>\n";
7834 
7835  htmlFile << "<br>\n";
7836  htmlFile << "<h2> . 4). average Rj shown for Rij outside meanValue range 0.80-1.20: . . . . . . . .5) . "
7837  "average Rj shown for Rij outside meanValue range 0.70-1.30: . . . . . . . .6). average Rj shown "
7838  "for Rij outside meanValue range 0.60-1.40: </h2>"
7839  << std::endl;
7840  htmlFile << "<br>\n";
7841  if (sub == 1) {
7842  htmlFile << " <img src=\"RBX-HB-3plotsmore.png\" />\n";
7843  }
7844  if (sub == 2) {
7845  htmlFile << " <img src=\"RBX-HE-3plotsmore.png\" />\n";
7846  }
7847  if (sub == 3) {
7848  htmlFile << " <img src=\"RBX-HO-3plotsmore.png\" />\n";
7849  }
7850  if (sub == 4) {
7851  htmlFile << " <img src=\"RBX-HF-3plotsmore.png\" />\n";
7852  }
7853  htmlFile << "<br>\n";
7854 
7855  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7856 
7857  //=========================================================
7858 
7859  } // test=1
7860 
7861  //===============================================================================
7862 
7863  htmlFile.close();
7864  } // sub main loop
7865  } //test main loop
7866  //===============================================================================
7867  //===============================================================================
7868  //===============================================================================
7869  //===============================================================================
7870  //===============================================================================
7871 
7872  //======================================================================
7873  // Creating tests html pages:
7874 
7875  for (int test = 0; test <= 5; test++) { //Test: 0,
7876  if (test == 0)
7877  htmlFile.open("CapID_GL.html");
7878  if (test == 1)
7879  htmlFile.open("ADCampl_GL.html");
7880  if (test == 2)
7881  htmlFile.open("Width_GL.html");
7882  if (test == 3)
7883  htmlFile.open("Ratio_GL.html");
7884  if (test == 4)
7885  htmlFile.open("Tmean_GL.html");
7886  if (test == 5)
7887  htmlFile.open("Tmax_GL.html");
7888 
7889  // cout<<"Creating tests html pages: test= "<< test << endl;
7890 
7891  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
7892  htmlFile << "<head>" << std::endl;
7893  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
7894  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
7895  htmlFile << "<style type=\"text/css\">" << std::endl;
7896  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
7897  << std::endl;
7898  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
7899  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
7900  "text-align: center;}"
7901  << std::endl;
7902  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
7903  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
7904  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
7905  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
7906  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
7907  htmlFile << "</style>" << std::endl;
7908  htmlFile << "<body>" << std::endl;
7909  if (test == 0)
7910  htmlFile << "<h1> CAP ID ERRORS, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7911  if (test == 1)
7912  htmlFile << "<h1> ADC AMPLITIDE, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7913  if (test == 2)
7914  htmlFile << "<h1> WIDTH, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7915  if (test == 3)
7916  htmlFile << "<h1> RATIO, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7917  if (test == 4)
7918  htmlFile << "<h1> TIMING MEAN, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7919  if (test == 5)
7920  htmlFile << "<h1> TIMING MAX, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7921  htmlFile << "<br>" << std::endl;
7922  htmlFile << "<h2> 1. Map of suspicious channels with this criterion for whole HCAL </h2>" << std::endl;
7923  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
7924  htmlFile << "<br>" << std::endl;
7925  if (test == 0)
7926  htmlFile << " <img src=\"MapCapIdError.png\" />" << std::endl;
7927  if (test == 1)
7928  htmlFile << " <img src=\"MapADCAmpl.png\" />" << std::endl;
7929  if (test == 2)
7930  htmlFile << " <img src=\"MapWidth.png\" />" << std::endl;
7931  if (test == 3)
7932  htmlFile << " <img src=\"MapRatio.png\" />" << std::endl;
7933  if (test == 4)
7934  htmlFile << " <img src=\"MapTmean.png\" />" << std::endl;
7935  if (test == 5)
7936  htmlFile << " <img src=\"MapTmax.png\" />" << std::endl;
7937  htmlFile << "<br>" << std::endl;
7938  htmlFile << "<h2> 2. For whole HCAL: </h2>" << std::endl;
7939  htmlFile << "<br>" << std::endl;
7940  if (test == 0)
7941  htmlFile << " <img src=\"HistCapID.png\" />" << std::endl;
7942  if (test == 1)
7943  htmlFile << " <img src=\"HistADCAmpl.png\" />" << std::endl;
7944  if (test == 2)
7945  htmlFile << " <img src=\"HistWidth.png\" />" << std::endl;
7946  if (test == 3)
7947  htmlFile << " <img src=\"HistRatio.png\" />" << std::endl;
7948  if (test == 4)
7949  htmlFile << " <img src=\"HistTmean.png\" />" << std::endl;
7950  if (test == 5)
7951  htmlFile << " <img src=\"HistTmax.png\" />" << std::endl;
7952  htmlFile << "<br>" << std::endl;
7953  htmlFile << "<h2> 3. Status of subdetectors </h2>" << std::endl;
7954  htmlFile << "<table width=\"400\">" << std::endl;
7955  htmlFile << "<tr>" << std::endl;
7956  if (test == 0) {
7957  htmlFile << " <td><a "
7958  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7959  "HcalRemoteMonitoring/CMT/GLOBAL_"
7960  << runnumber << "/HB_CapID.html\">HB</a></td>" << std::endl;
7961  htmlFile << " <td><a "
7962  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7963  "HcalRemoteMonitoring/CMT/GLOBAL_"
7964  << runnumber << "/HE_CapID.html\">HE</a></td>" << std::endl;
7965  htmlFile << " <td><a "
7966  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7967  "HcalRemoteMonitoring/CMT/GLOBAL_"
7968  << runnumber << "/HO_CapID.html\">HO</a></td>" << std::endl;
7969  htmlFile << " <td><a "
7970  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7971  "HcalRemoteMonitoring/CMT/GLOBAL_"
7972  << runnumber << "/HF_CapID.html\">HF</a></td>" << std::endl;
7973  }
7974  if (test == 1) {
7975  // AZ 07.11.2018
7976  /*
7977  htmlFile << " <td><a href=\"HB_ADCampl.html\">HB</a></td>"<< std::endl;
7978  htmlFile << " <td><a href=\"HE_ADCampl.html\">HE</a></td>"<< std::endl;
7979  htmlFile << " <td><a href=\"HO_ADCampl.html\">HO</a></td>"<< std::endl;
7980  htmlFile << " <td><a href=\"HF_ADCampl.html\">HF</a></td>"<< std::endl;
7981 */
7982  htmlFile << " <td><a "
7983  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7984  "HcalRemoteMonitoring/CMT/GLOBAL_"
7985  << runnumber << "/HB_ADCampl.html\">HB</a></td>" << std::endl;
7986  htmlFile << " <td><a "
7987  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7988  "HcalRemoteMonitoring/CMT/GLOBAL_"
7989  << runnumber << "/HE_ADCampl.html\">HE</a></td>" << std::endl;
7990  htmlFile << " <td><a "
7991  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7992  "HcalRemoteMonitoring/CMT/GLOBAL_"
7993  << runnumber << "/HO_ADCampl.html\">HO</a></td>" << std::endl;
7994  htmlFile << " <td><a "
7995  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
7996  "HcalRemoteMonitoring/CMT/GLOBAL_"
7997  << runnumber << "/HF_ADCampl.html\">HF</a></td>" << std::endl;
7998  }
7999  if (test == 2) {
8000  htmlFile << " <td><a "
8001  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8002  "HcalRemoteMonitoring/CMT/GLOBAL_"
8003  << runnumber << "/HB_Width.html\">HB</a></td>" << std::endl;
8004  htmlFile << " <td><a "
8005  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8006  "HcalRemoteMonitoring/CMT/GLOBAL_"
8007  << runnumber << "/HE_Width.html\">HE</a></td>" << std::endl;
8008  htmlFile << " <td><a "
8009  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8010  "HcalRemoteMonitoring/CMT/GLOBAL_"
8011  << runnumber << "/HO_Width.html\">HO</a></td>" << std::endl;
8012  htmlFile << " <td><a "
8013  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8014  "HcalRemoteMonitoring/CMT/GLOBAL_"
8015  << runnumber << "/HF_Width.html\">HF</a></td>" << std::endl;
8016  }
8017  if (test == 3) {
8018  htmlFile << " <td><a "
8019  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8020  "HcalRemoteMonitoring/CMT/GLOBAL_"
8021  << runnumber << "/HB_Ratio.html\">HB</a></td>" << std::endl;
8022  htmlFile << " <td><a "
8023  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8024  "HcalRemoteMonitoring/CMT/GLOBAL_"
8025  << runnumber << "/HE_Ratio.html\">HE</a></td>" << std::endl;
8026  htmlFile << " <td><a "
8027  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8028  "HcalRemoteMonitoring/CMT/GLOBAL_"
8029  << runnumber << "/HO_Ratio.html\">HO</a></td>" << std::endl;
8030  htmlFile << " <td><a "
8031  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8032  "HcalRemoteMonitoring/CMT/GLOBAL_"
8033  << runnumber << "/HF_Ratio.html\">HF</a></td>" << std::endl;
8034  }
8035  if (test == 4) {
8036  htmlFile << " <td><a "
8037  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8038  "HcalRemoteMonitoring/CMT/GLOBAL_"
8039  << runnumber << "/HB_Tmean.html\">HB</a></td>" << std::endl;
8040  htmlFile << " <td><a "
8041  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8042  "HcalRemoteMonitoring/CMT/GLOBAL_"
8043  << runnumber << "/HE_Tmean.html\">HE</a></td>" << std::endl;
8044  htmlFile << " <td><a "
8045  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8046  "HcalRemoteMonitoring/CMT/GLOBAL_"
8047  << runnumber << "/HO_Tmean.html\">HO</a></td>" << std::endl;
8048  htmlFile << " <td><a "
8049  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8050  "HcalRemoteMonitoring/CMT/GLOBAL_"
8051  << runnumber << "/HF_Tmean.html\">HF</a></td>" << std::endl;
8052  }
8053  if (test == 5) {
8054  htmlFile << " <td><a "
8055  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8056  "HcalRemoteMonitoring/CMT/GLOBAL_"
8057  << runnumber << "/HB_Tmax.html\">HB</a></td>" << std::endl;
8058  htmlFile << " <td><a "
8059  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8060  "HcalRemoteMonitoring/CMT/GLOBAL_"
8061  << runnumber << "/HE_Tmax.html\">HE</a></td>" << std::endl;
8062  htmlFile << " <td><a "
8063  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8064  "HcalRemoteMonitoring/CMT/GLOBAL_"
8065  << runnumber << "/HO_Tmax.html\">HO</a></td>" << std::endl;
8066  htmlFile << " <td><a "
8067  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8068  "HcalRemoteMonitoring/CMT/GLOBAL_"
8069  << runnumber << "/HF_Tmax.html\">HF</a></td>" << std::endl;
8070  }
8071 
8072  htmlFile << "</tr>" << std::endl;
8073  htmlFile << "</table>" << std::endl;
8074  htmlFile << "<br>" << std::endl;
8075  // cout<<"Creating tests html pages: 111111" << endl;
8076 
8077  if (test != 0)
8078  htmlFile << "<h2> 4. Table of estimator-values in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8079  if (test == 0)
8080  htmlFile << "<h2> 4. Table of average Nbcs in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8081  htmlFile << "<table>" << std::endl;
8082  htmlFile << "<tr>";
8083  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8084  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8085  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
8087  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
8088 
8089  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
8090  int kkkkkkmax = k_max[sub];
8091  if ((sub == 4 || sub == 2) && test == 1)
8092  kkkkkkmax = k_maxHFupgrade[sub];
8093  // if (test==1 && sub==4) kkkkkkmax = k_maxHFupgrade[sub];
8094  if (sub == 1) {
8095  if (test == 0)
8096  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8097  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HBdep " << k << " </td>" << std::endl;
8098  if (test == 1)
8099  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8100  htmlFile << "<td class=\"s1\" align=\"center\">< A > HBdepth " << k << " </td>" << std::endl;
8101  if (test == 2)
8102  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8103  htmlFile << "<td class=\"s1\" align=\"center\">< W > HBdepth " << k << " </td>" << std::endl;
8104  if (test == 3)
8105  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8106  htmlFile << "<td class=\"s1\" align=\"center\">< R > HBdepth " << k << " </td>" << std::endl;
8107  if (test == 4)
8108  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8109  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HBdep " << k << " </td>" << std::endl;
8110  if (test == 5)
8111  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8112  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HBdep " << k << " </td>" << std::endl;
8113  } //
8114  if (sub == 2) {
8115  if (test == 0)
8116  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8117  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HEdep " << k << " </td>" << std::endl;
8118  if (test == 1)
8119  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8120  htmlFile << "<td class=\"s1\" align=\"center\">< A > HEdepth " << k << " </td>" << std::endl;
8121  if (test == 2)
8122  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8123  htmlFile << "<td class=\"s1\" align=\"center\">< W > HEdepth " << k << " </td>" << std::endl;
8124  if (test == 3)
8125  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8126  htmlFile << "<td class=\"s1\" align=\"center\">< R > HEdepth " << k << " </td>" << std::endl;
8127  if (test == 4)
8128  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8129  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HEdep " << k << " </td>" << std::endl;
8130  if (test == 5)
8131  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8132  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HEdep " << k << " </td>" << std::endl;
8133  } //
8134  if (sub == 3) {
8135  if (test == 0)
8136  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8137  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HOdep " << k << " </td>" << std::endl;
8138  if (test == 1)
8139  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8140  htmlFile << "<td class=\"s1\" align=\"center\">< A > HOdepth " << k << " </td>" << std::endl;
8141  if (test == 2)
8142  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8143  htmlFile << "<td class=\"s1\" align=\"center\">< W > HOdepth " << k << " </td>" << std::endl;
8144  if (test == 3)
8145  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8146  htmlFile << "<td class=\"s1\" align=\"center\">< R > HOdepth " << k << " </td>" << std::endl;
8147  if (test == 4)
8148  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8149  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HOdep " << k << " </td>" << std::endl;
8150  if (test == 5)
8151  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8152  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HOdep " << k << " </td>" << std::endl;
8153  } //
8154  if (sub == 4) {
8155  if (test == 0)
8156  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8157  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HFdep " << k << " </td>" << std::endl;
8158  if (test == 1)
8159  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8160  htmlFile << "<td class=\"s1\" align=\"center\">< A > HFdepth " << k << " </td>" << std::endl;
8161  if (test == 2)
8162  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8163  htmlFile << "<td class=\"s1\" align=\"center\">< W > HFdepth " << k << " </td>" << std::endl;
8164  if (test == 3)
8165  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8166  htmlFile << "<td class=\"s1\" align=\"center\">< R > HFdepth " << k << " </td>" << std::endl;
8167  if (test == 4)
8168  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8169  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HFdep " << k << " </td>" << std::endl;
8170  if (test == 5)
8171  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8172  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HFdep " << k << " </td>" << std::endl;
8173  } //
8174  } // sub
8175  htmlFile << "</tr>" << std::endl;
8176 
8177  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 1</td>"<< std::endl;
8178  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 2</td>" << std::endl;
8179  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 1</td>" << std::endl;
8180  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 2</td>" << std::endl;
8181  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 3</td>" << std::endl;
8182  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 4</td>" << std::endl;
8183  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 5</td>" << std::endl;
8184  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 6</td>" << std::endl;
8185  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 7</td>" << std::endl;
8186  // htmlFile << "<td class=\"s1\" align=\"center\">HO Depth 4</td>" << std::endl;
8187  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 1</td>" << std::endl;
8188  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 2</td>" << std::endl;
8189  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 3</td>" << std::endl;
8190  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 4</td>" << std::endl;
8191  // htmlFile << "</tr>" << std::endl;
8192 
8193  ind = 0;
8194  // cout<<"Creating tests html pages: 222222" << endl;
8195  for (int i = 1; i <= MaxLum; i++) {
8196  // define al least one exceed in any sub-detector
8197  int met = 0;
8198  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8199  int kkkkkkmax = k_max[sub];
8200  if ((sub == 4 || sub == 2) && test == 1)
8201  kkkkkkmax = k_maxHFupgrade[sub];
8202  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8203  // line below is temporary, just to avoid contribution of HEP(M)17 in depthes 4,5,6,7 but keep in depthes 1,2,3
8204  if (sub == 2 && k > 3) {
8205  } else {
8206  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8207  met = 1;
8208  }
8209  } //depth
8210  } //sub
8211  // if exceed then plot the line for all sub-detectors
8212  if (met == 1) {
8213  if ((ind % 2) == 1)
8214  raw_class = "<td class=\"s2\" align=\"center\">";
8215  else
8216  raw_class = "<td class=\"s3\" align=\"center\">";
8217  htmlFile << "<tr>" << std::endl;
8218  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8219  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8220  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8221  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8222  int kkkkkkmax = k_max[sub];
8223  if ((sub == 4 || sub == 2) && test == 1)
8224  kkkkkkmax = k_maxHFupgrade[sub];
8225  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8226  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8227  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8228  << "</td>" << std::endl;
8229  else
8230  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8231  // htmlFile << "</tr>" << std::endl;
8232  /*
8233  if (HistNumBadChanDepth[test][1][1]->GetBinContent(i) > Cut0[test][1][1]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][1][1]->GetBinContent(i)<<"</td>"<< std::endl;
8234  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][1]->GetBinContent(i)<<"</td>"<< std::endl;
8235  if (HistNumBadChanDepth[test][1][2]->GetBinContent(i) > Cut0[test][1][2]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][1][2]->GetBinContent(i)<<"</td>"<< std::endl;
8236  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][2]->GetBinContent(i)<<"</td>"<< std::endl;
8237  if (HistNumBadChanDepth[test][2][1]->GetBinContent(i) > Cut0[test][2][1]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][1]->GetBinContent(i)<<"</td>"<< std::endl;
8238  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][1]->GetBinContent(i)<<"</td>"<< std::endl;
8239  if (HistNumBadChanDepth[test][2][2]->GetBinContent(i) > Cut0[test][2][2]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][2]->GetBinContent(i)<<"</td>"<< std::endl;
8240  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][2]->GetBinContent(i)<<"</td>"<< std::endl;
8241  if (HistNumBadChanDepth[test][2][3]->GetBinContent(i) > Cut0[test][2][3]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][3]->GetBinContent(i)<<"</td>"<< std::endl;
8242  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][3]->GetBinContent(i)<<"</td>"<< std::endl;
8243  if (HistNumBadChanDepth[test][2][4]->GetBinContent(i) > Cut0[test][2][4]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][4]->GetBinContent(i)<<"</td>"<< std::endl;
8244  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][4]->GetBinContent(i)<<"</td>"<< std::endl;
8245  if (HistNumBadChanDepth[test][2][5]->GetBinContent(i) > Cut0[test][2][5]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][5]->GetBinContent(i)<<"</td>"<< std::endl;
8246  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][5]->GetBinContent(i)<<"</td>"<< std::endl;
8247  if (HistNumBadChanDepth[test][2][6]->GetBinContent(i) > Cut0[test][2][6]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][6]->GetBinContent(i)<<"</td>"<< std::endl;
8248  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][6]->GetBinContent(i)<<"</td>"<< std::endl;
8249  if (HistNumBadChanDepth[test][2][7]->GetBinContent(i) > Cut0[test][2][7]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][2][7]->GetBinContent(i)<<"</td>"<< std::endl;
8250  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][7]->GetBinContent(i)<<"</td>"<< std::endl;
8251  if (HistNumBadChanDepth[test][3][4]->GetBinContent(i) > Cut0[test][3][4]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][3][4]->GetBinContent(i)<<"</td>"<< std::endl;
8252  else htmlFile <<raw_class<<HistNumBadChanDepth[test][3][4]->GetBinContent(i)<<"</td>"<< std::endl;
8253  if (HistNumBadChanDepth[test][4][1]->GetBinContent(i) > Cut0[test][4][1]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][4][1]->GetBinContent(i)<<"</td>"<< std::endl;
8254  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][1]->GetBinContent(i)<<"</td>"<< std::endl;
8255  if (HistNumBadChanDepth[test][4][2]->GetBinContent(i) > Cut0[test][4][2]) htmlFile << "<td class=\"s6\" align=\"center\">"<<HistNumBadChanDepth[test][4][2]->GetBinContent(i)<<"</td>"<< std::endl;
8256  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][2]->GetBinContent(i)<<"</td>"<< std::endl;
8257  */
8258  } //k depthes
8259  } //sub
8260  htmlFile << "</tr>" << std::endl;
8261  ind += 1;
8262  } // met=1
8263  } //i bin lines
8264  // cout<<"Creating tests html pages: 333333" << endl;
8265  htmlFile << "</table>" << std::endl;
8266  htmlFile << "<br>" << std::endl;
8267  htmlFile << "</body> " << std::endl;
8268  htmlFile << "</html> " << std::endl;
8269  htmlFile.close();
8270  } //test
8271  //======================================================================
8272  // cout<<"for summed Amplitudes of each sub-detector" << endl;
8273 
8274  // for summed Amplitudes of each sub-detector
8275  htmlFile.open("SummedAmplitudes_GL.html");
8276  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8277  htmlFile << "<head>" << std::endl;
8278  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8279  htmlFile << "<title> for summed Amplitudes of each sub-detector </title>" << std::endl;
8280  htmlFile << "<style type=\"text/css\">" << std::endl;
8281  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8282  << std::endl;
8283  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8284  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8285  "text-align: center;}"
8286  << std::endl;
8287  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8288  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8289  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8290  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8291  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8292 
8293  htmlFile << "</style>" << std::endl;
8294  htmlFile << "<body>" << std::endl;
8295  htmlFile << "<h1> Averaged Summed Amplitudes & corresponding occupancy of each sub-detector in Global Run = "
8296  << runnumber << " </h1>" << std::endl;
8297  htmlFile << "<a name=\"Top\"></a>\n";
8298  htmlFile << "<b>Contents:<br>\n";
8299  htmlFile << "1. <a href=\"#SAhigh\">average SA&Occupancy for Signal </a><br>\n";
8300  htmlFile << "2. <a href=\"#SAlow\">average SA&Occupancy for NoSignal </a><br>\n";
8301  htmlFile << "3. <a href=\"#SAmax\"> maxSA & maxOccupancy; SA & Occupancy; </a><br>\n";
8302  htmlFile << "4. <a href=\"#FullTable\">Table(avA; avSA; avOccupancy; maxSA; maxOccupancy;) </a><br>\n";
8303 
8304  htmlFile << "<h2> Clarifying on averaged Summed Amplitude (avSA) : </h2>" << std::endl;
8305  htmlFile << "<h3> Summed Amplitudes (SA) are averaged over all events of each LS: avSA_LS = SUM (SA_eventsInLS) / "
8306  "N_eventsInLS ,</h3>"
8307  << std::endl;
8308  htmlFile << "<h3> where SA = SUM(A_i) ,and means that Amplitude is summed over all sub-detector channels, </h3>"
8309  << std::endl;
8310  htmlFile << "<h3> where A_i = SUM(A_depth) denotes channel amplitude summed over depths; </h3>" << std::endl;
8311  // htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
8312  htmlFile << " <td><a "
8313  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8314  "HcalRemoteMonitoring/CMT/SAwriteup.html\"> see more details for SummedAmplitudes</a></td>"
8315  << std::endl;
8316  htmlFile << "<h2> Apply cuts on A_i to take into account channels with or/and without a'la Signal: </h2>"
8317  << std::endl;
8318  htmlFile << " <img src=\"ChannelDepthsummedAmplitudes.png\" />" << std::endl;
8319  htmlFile << "<br>" << std::endl;
8320  htmlFile << "<br>" << std::endl;
8321  htmlFile << "<a name=\"SAhigh\"></a>\n";
8322  htmlFile << "<h1> 1. for channels with signal </h1>" << std::endl;
8323  htmlFile << "<br>" << std::endl;
8324  htmlFile << "<h2> for HB: A_i> 80; </h2>" << std::endl;
8325  htmlFile << " <img src=\"SummedAmplitudesSignal_HB.png\" />" << std::endl;
8326  htmlFile << "<br>" << std::endl;
8327  htmlFile << "<h2> for HE: A_i> 200;</h2>" << std::endl;
8328  htmlFile << " <img src=\"SummedAmplitudesSignal_HE.png\" />" << std::endl;
8329  htmlFile << "<br>" << std::endl;
8330  htmlFile << "<h2> for HO: A_i> 1200;</h2>" << std::endl;
8331  htmlFile << " <img src=\"SummedAmplitudesSignal_HO.png\" />" << std::endl;
8332  htmlFile << "<br>" << std::endl;
8333  htmlFile << "<h2> for HF: A_i> 600;</h2>" << std::endl;
8334  htmlFile << " <img src=\"SummedAmplitudesSignal_HF.png\" />" << std::endl;
8335  htmlFile << "<br>" << std::endl;
8336  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8337 
8338  htmlFile << "<a name=\"SAlow\"></a>\n";
8339  htmlFile << "<h1> 2. for channels w/o signal </h1>" << std::endl;
8340  htmlFile << "<br>" << std::endl;
8341  htmlFile << "<h2> for HB: A_i< 80;</h2>" << std::endl;
8342  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HB.png\" />" << std::endl;
8343  htmlFile << "<br>" << std::endl;
8344  htmlFile << "<h2> for HE: A_i< 200;</h2>" << std::endl;
8345  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HE.png\" />" << std::endl;
8346  htmlFile << "<br>" << std::endl;
8347  htmlFile << "<h2> for HO: A_i< 1200;</h2>" << std::endl;
8348  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HO.png\" />" << std::endl;
8349  htmlFile << "<br>" << std::endl;
8350  htmlFile << "<h2> for HF: A_i< 600;</h2>" << std::endl;
8351  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HF.png\" />" << std::endl;
8352  htmlFile << "<br>" << std::endl;
8353  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8354 
8355  htmlFile << "<br>" << std::endl;
8356  htmlFile << "<br>" << std::endl;
8357  htmlFile << "<a name=\"SAmax\"></a>\n";
8358  htmlFile << "<h1> 3. four plots: ---1---> max SA ---2---> max Occupancy ---3---> SA ---4---> Occupancy over all "
8359  "events of LS </h1>"
8360  << std::endl;
8361  htmlFile << "<br>" << std::endl;
8362 
8363  htmlFile << "<h2> for HB: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8364  htmlFile << " <img src=\"MaxxSummedAmplitudes_HB.png\" />" << std::endl;
8365  htmlFile << "<h2>"
8366  " ......(forCut:SAmax>60000) N= "
8367  << countamplmaxHB << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHB << " </h2>" << std::endl;
8368  htmlFile << "<h2>"
8369  " ......(forCut:SA>60000) N= "
8370  << countamplHB << " ...... (forCut:OCCUP>2000) N= " << countoccuHB << " </h2>" << std::endl;
8371  htmlFile << "<br>" << std::endl;
8372  htmlFile << "<h3> ONLY for HB (cross-check): channel Amplitudes for events in the Tail (averaged): </h3>"
8373  << std::endl;
8374  htmlFile << " <img src=\"AtaildepthHB.png\" />" << std::endl;
8375  htmlFile << "<br>" << std::endl;
8376 
8377  htmlFile << "<h2> for HE: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8378  htmlFile << " <img src=\"MaxxSummedAmplitudes_HE.png\" />" << std::endl;
8379  htmlFile << "<h2>"
8380  " ......(forCut:SAmax>60000) N= "
8381  << countamplmaxHE << " ...... (forCut:OCCUPmax>1200) N= " << countoccumaxHE << " </h2>" << std::endl;
8382  htmlFile << "<h2>"
8383  " ......(forCut:SA>60000) N= "
8384  << countamplHE << " ...... (forCut:OCCUP>1200) N= " << countoccuHE << " </h2>" << std::endl;
8385  htmlFile << "<br>" << std::endl;
8386 
8387  htmlFile << "<h2> for HO: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8388  htmlFile << " <img src=\"MaxxSummedAmplitudes_HO.png\" />" << std::endl;
8389  htmlFile << "<h2>"
8390  " ......(forCut:SAmax>150000) N= "
8391  << countamplmaxHO << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHO << " </h2>" << std::endl;
8392  htmlFile << "<h2>"
8393  " ......(forCut:SA>150000) N= "
8394  << countamplHO << " ...... (forCut:OCCUP>2000) N= " << countoccuHO << " </h2>" << std::endl;
8395  htmlFile << "<br>" << std::endl;
8396 
8397  htmlFile << "<h2> for HF: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8398  htmlFile << " <img src=\"MaxxSummedAmplitudes_HF.png\" />" << std::endl;
8399  htmlFile << "<h2>"
8400  " ......(forCut:SAmax>22000) N= "
8401  << countamplmaxHF << " ...... (forCut:OCCUPmax>860) N= " << countoccumaxHF << " </h2>" << std::endl;
8402  htmlFile << "<h2>"
8403  " ......(forCut:SA>22000) N= "
8404  << countamplHF << " ...... (forCut:OCCUP>860) N= " << countoccuHF << " </h2>" << std::endl;
8405  htmlFile << "<br>" << std::endl;
8406  htmlFile << "<h2> Occupancy HF (ONLY) vs LS </h2>" << std::endl;
8407  htmlFile << " <img src=\"sumOccupancyHF.png\" />" << std::endl;
8408  htmlFile << "<br>" << std::endl;
8409  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8410 
8411  htmlFile << "<a name=\"FullTable\"></a>\n";
8412  htmlFile << "<h2> 4.Lumisection Status: </h2>" << std::endl;
8413  htmlFile << "<h3> Legends: HBdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8414  << Cut0[1][1][1] << std::endl;
8415  htmlFile << "<h3> Legends: HEdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8416  << Cut0[1][2][1] << std::endl;
8417  htmlFile << "<h3> Legends: HOdepth4 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8418  << Cut0[1][3][4] << std::endl;
8419  htmlFile << "<h3> Legends: HFdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8420  << Cut0[1][4][1] << std::endl;
8421  htmlFile << "<br>" << std::endl;
8422  // SummedAmplitudeHisto[i] SummedAmplitudeOccupancyHisto[i] NoSignalSummedAmplitudeHisto[i] NoSignalSummedAmplitudeOccupancyHisto[i]; i=0-3;(HF:i=3)
8423  htmlFile << "<br>" << std::endl;
8424  htmlFile << "<table>" << std::endl;
8425  htmlFile << "<tr>";
8426  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8427  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8428  htmlFile << "<td class=\"s1\" align=\"center\"> Num.of ev.</td>" << std::endl;
8429 
8430  // for (int k=k_min[sub];k<=k_max[sub]; k++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth "<< k <<" </td>" << std::endl;
8431  // for (int sub=1;sub<=4;sub++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth1, sub "<< sub <<" </td>" << std::endl;
8432 
8433  htmlFile << "<td class=\"s1\" align=\"center\">< A >HB Depth1</td>" << std::endl;
8434  htmlFile << "<td class=\"s1\" align=\"center\">< A >HE Depth1</td>" << std::endl;
8435  htmlFile << "<td class=\"s1\" align=\"center\">< A >HO Depth4</td>" << std::endl;
8436  htmlFile << "<td class=\"s1\" align=\"center\">< A >HF Depth1</td>" << std::endl;
8437 
8438  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (Signal) </td>" << std::endl;
8439  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (Signal) </td>" << std::endl;
8440  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (Signal) </td>" << std::endl;
8441  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (Signal) </td>" << std::endl;
8442 
8443  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (NoSignal) </td>" << std::endl;
8444  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (NoSignal) </td>" << std::endl;
8445  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (NoSignal) </td>" << std::endl;
8446  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (NoSignal) </td>" << std::endl;
8447 
8448  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HB </td>" << std::endl;
8449  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HB </td>" << std::endl;
8450  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HF </td>" << std::endl;
8451  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HF </td>" << std::endl;
8452 
8453  htmlFile << "</tr>" << std::endl;
8454 
8455  ind = 0;
8456  for (int i = 1; i <= MaxLum; i++) {
8457  if ((ind % 2) == 1)
8458  raw_class = "<td class=\"s2\" align=\"center\">";
8459  else
8460  raw_class = "<td class=\"s3\" align=\"center\">";
8461  htmlFile << "<tr>" << std::endl;
8462 
8463  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8464 
8465  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8466  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8467 
8468  // (test==1) <Amplitude>
8469  int test = 1;
8470  // for (int k=k_min[sub];k<=k_max[sub]; k++) {
8471  for (int sub = 1; sub <= 4; sub++) {
8472  for (int k = k_min[sub]; k <= k_min[sub]; k++) {
8473  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8474  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8475  << "</td>" << std::endl;
8476 
8477  else
8478  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8479  }
8480  }
8481  if (SummedAmplitudeHisto[0]) {
8482  htmlFile << raw_class << SummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8483  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8484  htmlFile << raw_class << SummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8485  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8486 
8487  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8488  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8489  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8490  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8491 
8492  htmlFile << raw_class << MaxxSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8493  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8494  htmlFile << raw_class << MaxxSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8495  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8496  }
8497  htmlFile << "</tr>" << std::endl;
8498  ind += 1;
8499  }
8500  htmlFile << "</table>" << std::endl;
8501  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8502 
8503  htmlFile << "<br>" << std::endl;
8504  htmlFile << "</body> " << std::endl;
8505  htmlFile << "</html> " << std::endl;
8506  htmlFile.close();
8507 
8508  //====================================================================== // Creating description of html-files
8509 
8510  /*
8511  //======================================================================
8512  // Creating description HELP.html file:
8513  htmlFile.open("HELP.html");
8514  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">"<< std::endl;
8515  htmlFile << "<head>"<< std::endl;
8516  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>"<< std::endl;
8517  htmlFile << "<title> Certification Monitoring Tool </title>"<< std::endl;
8518  htmlFile << "<style type=\"text/css\">"<< std::endl;
8519  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"<< std::endl;
8520  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }"<< std::endl;
8521  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; text-align: center;}"<< std::endl;
8522  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }"<< std::endl;
8523  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }"<< std::endl;
8524  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }"<< std::endl;
8525  htmlFile << "</style>"<< std::endl;
8526  htmlFile << "<body>"<< std::endl;
8527  htmlFile << "<h1> Description of Remote Monitoring Tool criteria for bad channel selection</h1>"<< std::endl;
8528  htmlFile << "<br>"<< std::endl;
8529  htmlFile << "<h3> - CAPID Errors assuming we inspect CAPID non-rotation,error & validation bits, and for this criterion - no need to apply any cuts to select bcs.</h3> "<< std::endl;
8530  htmlFile << "<br>"<< std::endl;
8531  htmlFile << "<h3> - Amplitude is full amplitude collected over all time slices </h3> "<< std::endl;
8532  htmlFile << "<h3> - Ratio criterion is where we define as a bad, the channels, for which the signal portion in 4 middle TSs(plus one, minus two around TS with maximal amplitude) is out of some range of reasonable values </h3> "<< std::endl;
8533  htmlFile << "<br>"<< std::endl;
8534  htmlFile << "<h3> - Width of shape distribution. Width is defined as square root from dispersion. </h3> "<< std::endl;
8535  htmlFile << "<br>"<< std::endl;
8536  htmlFile << "<h3> - Mean TS time slice position of adc signal. </h3> "<< std::endl;
8537  htmlFile << "<br>"<< std::endl;
8538  htmlFile << "<h3> - TS number of maximum signal </h3> "<< std::endl;
8539  htmlFile << "<br>"<< std::endl;
8540  htmlFile << "<h3> For more details see https://twiki.cern.ch/twiki/bin/viewauth/CMS/HcalRemoteCertificationMonitoring </h3> "<< std::endl;
8541  htmlFile << "</body> " << std::endl;
8542  htmlFile << "</html> " << std::endl;
8543  htmlFile.close();
8544 */
8545  //======================================================================
8546  // Creating description CMTresults.html file:
8547  htmlFile.open("CMTresults.html");
8548  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8549  htmlFile << "<head>" << std::endl;
8550  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8551  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8552  htmlFile << "<style type=\"text/css\">" << std::endl;
8553  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8554  << std::endl;
8555  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8556  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8557  "text-align: center;}"
8558  << std::endl;
8559  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8560  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8561  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8562  htmlFile << "</style>" << std::endl;
8563  htmlFile << "<body>" << std::endl;
8564  htmlFile << "<h1> LS-certification (recommendation) from analysis of CMT-dependencies of THIS run </h1>"
8565  << std::endl;
8566  htmlFile << "<br>" << std::endl;
8567  htmlFile << "<br>" << std::endl;
8568  htmlFile << "<h2> - List of suspicious LSs: </h2> " << std::endl;
8569  htmlFile << "<br>" << std::endl;
8570  htmlFile << "<h3> to be added </h3> " << std::endl;
8571  htmlFile << "<br>" << std::endl;
8572  htmlFile << "<br>" << std::endl;
8573  htmlFile << "<br>" << std::endl;
8574  htmlFile << "<h2> - Comments: </h2> " << std::endl;
8575  htmlFile << "<br>" << std::endl;
8576  htmlFile << "<h3> to be added </h3> " << std::endl;
8577  htmlFile << "<br>" << std::endl;
8578  htmlFile << "<br>" << std::endl;
8579  htmlFile << "<br>" << std::endl;
8580  htmlFile << "</body> " << std::endl;
8581  htmlFile << "</html> " << std::endl;
8582  htmlFile.close();
8583 
8584  //======================================================================
8585  // Creating main html file:
8586 
8587  htmlFile.open("LumiList.html");
8588  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8589  htmlFile << "<head>" << std::endl;
8590  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8591  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8592  htmlFile << "<style type=\"text/css\">" << std::endl;
8593  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8594  << std::endl;
8595  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8596  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8597  "text-align: center;}"
8598  << std::endl;
8599  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8600  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8601  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8602  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8603  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8604 
8605  htmlFile << "</style>" << std::endl;
8606  htmlFile << "<body>" << std::endl;
8607 
8608  htmlFile << "<h1> Certification Monitoring Tool, GLOBAL RUN = " << runnumber << ". </h1>" << std::endl;
8609  htmlFile << "<br>" << std::endl;
8610  htmlFile << " <td><a "
8611  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8612  "HcalRemoteMonitoring/CMT/GLOBAL_"
8613  << runnumber << "/CMTresults.html\"> CMT-analysis RESULTS (for this run) </a></td>" << std::endl;
8614  htmlFile << "<br>" << std::endl;
8615  htmlFile << "<br>" << std::endl;
8616 
8617  // htmlFile << "<h2> 1. General information </h2>"<< std::endl;
8618  htmlFile << "<h2> 1. General information (Full number of LS = " << MaxLum << " ). </h2>" << std::endl;
8619  htmlFile << " <img src=\"LumiEvent.png\" />" << std::endl;
8620  htmlFile << "<br>" << std::endl;
8621 
8622  htmlFile << "<h2> 2. HCAL status for different criteria </h2>" << std::endl;
8623  // htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
8624  htmlFile << " <td><a "
8625  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8626  "HcalRemoteMonitoring/CMT/HELP.html\"> Description of criteria for bad channel selection</a></td>"
8627  << std::endl;
8628  htmlFile << "<br>" << std::endl;
8629  htmlFile << "<table width=\"600\">" << std::endl;
8630  htmlFile << "<tr>" << std::endl;
8631  htmlFile << " <td><a "
8632  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8633  "HcalRemoteMonitoring/CMT/GLOBAL_"
8634  << runnumber << "/CapID_GL.html\">Cap ID errors</a></td>" << std::endl;
8635  // AZ 18.03.2018 zhokin 22.02.2019
8636  htmlFile << " <td><a "
8637  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8638  "HcalRemoteMonitoring/CMT/GLOBAL_"
8639  << runnumber << "/ADCampl_GL.html\">Amplitude</a></td>" << std::endl;
8640  //htmlFile << " <td><a href=\"ADCampl_GL.html\">Amplitude</a></td>"<< std::endl;
8641  htmlFile << " <td><a "
8642  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8643  "HcalRemoteMonitoring/CMT/GLOBAL_"
8644  << runnumber << "/Width_GL.html\">Width</a></td>" << std::endl;
8645  htmlFile << " <td><a "
8646  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8647  "HcalRemoteMonitoring/CMT/GLOBAL_"
8648  << runnumber << "/Ratio_GL.html\">Ratio</a></td>" << std::endl;
8649  htmlFile << " <td><a "
8650  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8651  "HcalRemoteMonitoring/CMT/GLOBAL_"
8652  << runnumber << "/Tmean_GL.html\">TS mean</a></td>" << std::endl;
8653  htmlFile << " <td><a "
8654  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8655  "HcalRemoteMonitoring/CMT/GLOBAL_"
8656  << runnumber << "/Tmax_GL.html\">TS max</a></td>" << std::endl;
8657 
8658  htmlFile << " <td><a "
8659  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8660  "HcalRemoteMonitoring/CMT/GLOBAL_"
8661  << runnumber << "/SummedAmplitudes_GL.html\">SummedAmplitudes</a></td>" << std::endl;
8662 
8663  htmlFile << "</tr>" << std::endl;
8664  htmlFile << "</table>" << std::endl;
8665  htmlFile << "<br>" << std::endl;
8666  htmlFile << "</body> " << std::endl;
8667  htmlFile << "</html> " << std::endl;
8668  htmlFile.close();
8669  //======================================================================
8670 
8671  //======================================================================
8672  // Close and delete all possible things:
8673  hfile->Close();
8674  // hfile->Delete();
8675  // Exit Root
8676  gSystem->Exit(0);
8677  //======================================================================
8678 }
8679 
8680 // ------------------------------------------------------------
8681 
8682 int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin) {
8683  if (lastBin > hSrc->GetNbinsX()) {
8684  std::cout << "copyContents from " << hSrc->GetName() << ": histo has " << hSrc->GetNbinsX()
8685  << " bins, when lastBin=" << lastBin << " was requested\n";
8686  return 0;
8687  }
8688 
8689  (*hDest) = new TH1F(hname, htitle, lastBin, 0, lastBin);
8690  (*hDest)->SetDirectory(0);
8691  (*hDest)->SetStats(0);
8692 
8693  for (int ibin = 1; ibin <= lastBin; ibin++) {
8694  (*hDest)->SetBinContent(ibin, hSrc->GetBinContent(ibin));
8695  (*hDest)->SetBinError(ibin, hSrc->GetBinError(ibin));
8696  }
8697  return 1;
8698 }
8699 
8700 // ------------------------------------------------------------
mps_fire.i
i
Definition: mps_fire.py:429
remoteMonitoring_LASER_era2018_cfg.lsmax
lsmax
Definition: remoteMonitoring_LASER_era2018_cfg.py:277
NULL
#define NULL
Definition: scimark2.h:8
isum
double isum
Definition: MuScleFitUtils.cc:77
METSignificanceParams_cfi.jeta
jeta
Definition: METSignificanceParams_cfi.py:12
main
int main(int argc, char *argv[])
Definition: RemoteMonitoringGLOBALRBX.cc:32
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
copyContents
int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin)
Definition: RemoteMonitoringGLOBALRBX.cc:8682
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
hi
Definition: EPCuts.h:4
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
ctpps_dqm_sourceclient-live_cfg.test
test
Definition: ctpps_dqm_sourceclient-live_cfg.py:7
change_name.diff
diff
Definition: change_name.py:13
alignmentValidation.fname
string fname
main script
Definition: alignmentValidation.py:959
BTaggingMonitor_cfi.met
met
Definition: BTaggingMonitor_cfi.py:74
hcalRecHitTable_cff.depth
depth
Definition: hcalRecHitTable_cff.py:17
x
float x
Definition: beamSpotDipStandalone.cc:55
gather_cfg.cout
cout
Definition: gather_cfg.py:144
Generated for CMSSW Reference Manual by doxygen 1.8.14