CMS 3D CMS Logo
RemoteMonitoringGLOBALTest.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  std::string dirnm = "Analyzer";
34  gROOT->Reset();
35  gROOT->SetStyle("Plain");
36  gStyle->SetOptStat(0);
37  gStyle->SetOptTitle(1);
38 
39  if (argc < 1)
40  return 1;
41  char fname[300];
42  sprintf(fname, "%s", argv[1]);
43  std::cout << fname << std::endl;
44 
45  //======================================================================
46  // Connect the input files, parameters and get the 2-d histogram in memory
47  // TFile *hfile= new TFile("GlobalHist.root", "READ");
48  string promt = (string)fname;
49  string runnumber = "";
50  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
51  runnumber += fname[i];
52 
53  TFile *hfile = new TFile(fname, "READ");
54  hfile->ls();
55  TDirectory *dir = (TDirectory *)hfile->FindObjectAny(dirnm.c_str());
56 
57  // Cut [test][sub][depth]
58  // Empty HB HE HO HF
59  double Cut0[7][5][8] = {
60  {{0., 0., 0., 0., 0., 0., 0., 0.},
61  {0., 1.0, 1.0, 0., 0., 0., 0., 0.},
62  {0., 1., 1., 1., 0., 0., 0., 0.},
63  {0., 0., 0., 0., 1., 0., 0., 0.},
64  {0., 1., 1., 0., 0., 0., 0., 0.}}, //CapID 0,HB,HE,HO,HF
65  // {{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
66  {{0., 0., 0., 0., 0., 0., 0., 0.},
67  {0., 3500., 3500., 3500., 3500., 0., 0., 0.},
68  {0., 12000., 4500., 3500., 3500., 4000., 4500., 5500.},
69  {0., 0., 0., 0., 200., 0., 0., 0.},
70  {0., 4500., 4500., 4500., 4500., 0., 0., 0.}}, //Amplitude 0,HB,HE,HO,HF
71  {{0., 0., 0., 0., 0., 0., 0., 0.},
72  {0., 3., 3., 0., 0., 0., 0., 0.},
73  {0., 3., 3., 3., 0., 0., 0., 0.},
74  {0., 0., 0., 0., 3., 0., 0., 0.},
75  {0., 2., 2., 0., 0., 0., 0., 0.}}, //Width 0,HB,HE,HO,HF
76  {{0., 0., 0., 0., 0., 0., 0., 0.},
77  {0., 0.4, 0.4, 0., 0., 0., 0., 0.},
78  {0., 0.4, 0.4, 0.4, 0., 0., 0., 0.},
79  {0., 0., 0., 0., 0.4, 0., 0., 0.},
80  {0., 0.8, 0.8, 0., 0., 0., 0., 0.}}, //Ratio 0,HB,HE,HO,HF
81  {{0., 0., 0., 0., 0., 0., 0., 0.},
82  {0., 4.7, 4.7, 0., 0., 0., 0., 0.},
83  {0., 4.8, 4.8, 5.0, 0., 0., 0., 0.},
84  {0., 0., 0., 0., 4.8, 0., 0., 0.},
85  {0., 4.0, 4.0, 0., 0., 0., 0., 0.}}, //TSn 0,HB,HE,HO,HF
86  {{0., 0., 0., 0., 0., 0., 0., 0.},
87  {0., 3.5, 3.5, 0., 0., 0., 0., 0.},
88  {0., 4.0, 4.0, 4.0, 0., 0., 0., 0.},
89  {0., 0., 0., 0., 3., 0., 0., 0.},
90  {0., 3.5, 3.5, 0., 0., 0., 0., 0.}}, //TSx 0,HB,HE,HO,HF
91  {{0., 0., 0., 0., 0., 0., 0., 0.},
92  {0., 0., 0., 0., 0., 0., 0., 0.},
93  {0., 0., 0., 0., 0., 0., 0., 0.},
94  {0., 0., 0., 0., 0., 0., 0., 0.},
95  {0., 0., 0., 0., 0., 0., 0., 0.}}}; //Empty
96 
97  double CutAb[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
98  {0., 20., 7., 0., 0., 0., 0., 0.},
99  {0., 16., 13., 4., 0., 0., 0., 0.},
100  {0., 0., 0., 0., 45., 0., 0., 0.},
101  {0., 10., 5., 0., 0., 0., 0., 0.}}; // cut 1 for CapIdErrors 0,HB,HE,HO,HF
102 
103  double CutPo[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
104  {0., 9., 3., 0., 0., 0., 0., 0.},
105  {0., 8., 6., 2., 0., 0., 0., 0.},
106  {0., 0., 0., 0., 20., 0., 0., 0.},
107  {0., 5., 3., 0., 0., 0., 0., 0.}}; //cut 3 for CapIdErrors (portions) 0,HB,HE,HO,HF
108 
109  //======================================================================
110 
111  // CUTs FOR IPHI RBX:
112  int cutA_HB = 100;
113  int cutA_HE = 6000;
114  int cutA_HO = 150;
115  int cutA_HF = 500;
116  // CUTs FOR IETA RBX:
117  int cutB_HB = 100;
118  int cutB_HE = 10000;
119  int cutB_HO = 150;
120  int cutB_HF = 500;
121 
122  //======================================================================
123  // Prepare histograms and plot them to .png files
124  TCanvas *c1 = new TCanvas("c1", "Hcal4test", 200, 10, 700, 900);
125 
126  TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 500);
127  TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 500);
128  TCanvas *cONE = new TCanvas("cONE", "cONE", 500, 500);
129  TCanvas *cFour = new TCanvas("cFour", "cFour", 1500, 1000);
130  TCanvas *cFour1 = new TCanvas("cFour1", "cFour1", 1200, 800);
131  TCanvas *cNine = new TCanvas("cNine", "cNine", 1500, 1500);
132 
133  // RBX:
134  // TCanvas *c4x6 = new TCanvas("c4x6","c4x6",1500,3000);
135  TCanvas *c4x6 = new TCanvas("c4x6", "c4x6", 1200, 2400);
136  //TCanvas *c5x6 = new TCanvas("c5x6","c5x6",2000,3000);
137  TCanvas *c5x6 = new TCanvas("c5x6", "c5x6", 1500, 2400);
138  // TCanvas *cRBX1 = new TCanvas("cRBX1","cRBX1",200,10,1300,1110);
139  TCanvas *cRBX1 = new TCanvas("cRBX1", "cRBX1", 1200, 1000);
140  //
141  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",1800,600);
142  TCanvas *cRBX31 = new TCanvas("cRBX31", "cRBX31", 1860, 600);
143  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",200,10,,1800,600);
144 
145  // char *str = (char*)alloca(10000);
146 
147  int k_min[5] = {0, 1, 1, 4, 1}; // minimum depth for each subdet HB HE HO HF
148 
149  int k_max[5] = {0, 2, 3, 4, 2}; // maximum depth for each subdet HB HE HO HF
150  // int k_maxupgrade[5]={0,2,3,4,4}; // maximum depth for each subdet HB HE HO HF
151  int k_maxupgrade[5] = {0, 4, 7, 4, 4}; // maximum depth for each subdet HB HE HO HF
152 
153  // with TfileService implementation, change everywhere below: hfile->Get to dir->FindObjectAny
154  //+++++++++++++++++++++++++++++
155  // Lumi iLumi and number of events
156  //+++++++++++++++++++++++++++++
157  cHB->Divide(2, 1);
158  cHB->cd(1);
159  TH1F *LumLum = (TH1F *)dir->FindObjectAny("h_lsnumber_per_eachLS");
160  int MaxLumDanila = LumLum->GetBinContent(LumLum->GetMaximumBin()); // old variant of Danila
161  cout << " MaxLumDanila= " << MaxLumDanila << endl;
162  gPad->SetGridy();
163  gPad->SetGridx();
164  LumLum->SetMarkerStyle(10);
165  LumLum->SetMarkerSize(0.8);
166  LumLum->GetYaxis()->SetLabelSize(0.04);
167  LumLum->SetTitle("Cont. number per LS \b");
168  LumLum->SetXTitle("Cont.number \b");
169  LumLum->SetYTitle("Ls \b");
170  LumLum->SetMarkerColor(4);
171  LumLum->SetLineColor(0);
172  LumLum->SetMinimum(0.8);
173  LumLum->GetXaxis()->SetRangeUser(0, MaxLumDanila);
174  LumLum->Draw("Error");
175 
176  cHB->cd(2);
177  TH1F *LumiEv = (TH1F *)dir->FindObjectAny("h_nevents_per_eachRealLS");
178  int MaxLum0 = LumiEv->GetBinContent(LumiEv->GetMaximumBin());
179  int MaxLum = 0;
180  for (int i = 1; i <= LumiEv->GetXaxis()->GetNbins(); i++) {
181  if (LumiEv->GetBinContent(i)) {
182  MaxLum = i;
183  }
184  }
185  cout << " MaxLum0= " << MaxLum0 << " MaxLum= " << MaxLum << endl;
186 
187  gPad->SetGridy();
188  gPad->SetGridx();
189  gPad->SetLogy();
190  // gPad->SetLogx();
191  LumiEv->GetYaxis()->SetLabelSize(0.04);
192  LumiEv->SetTitle("Number of events per LS");
193  LumiEv->SetXTitle("LS");
194  LumiEv->SetYTitle("Number of events ");
195  LumiEv->SetMarkerStyle(10);
196  LumiEv->SetMarkerSize(0.8);
197  LumiEv->SetMarkerColor(4);
198  LumiEv->SetLineColor(0);
199  // LumiEv->SetMinimum(0.8);
200  LumiEv->GetXaxis()->SetRangeUser(0, MaxLum);
201  LumiEv->Draw("Error");
202 
203  cHB->Print("LumiEvent.png");
204  cHB->Clear();
205 
206  //=======================================================================================================
207  // Shape criteria: 1d histogram first definition
208  //=======================================================================================================
209  TH1F *H_NumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
210 
211  //+++++++++++++++++++++++++++++
212  // ADC Amplitude
213  //+++++++++++++++++++++++++++++
214 
215  H_NumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS1");
216  H_NumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS2");
217 
218  H_NumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS3");
219  H_NumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS4");
220  H_NumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS5");
221 
222  H_NumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS8");
223 
224  H_NumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS6");
225  H_NumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS7");
226 
227  //+++++++++++++++++++++++++++++
228  // Width
229  //+++++++++++++++++++++++++++++
230 
231  H_NumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS1");
232  H_NumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS2");
233 
234  H_NumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS3");
235  H_NumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS4");
236  H_NumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS5");
237 
238  H_NumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS8");
239 
240  H_NumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS6");
241  H_NumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS7");
242 
243  //+++++++++++++++++++++++++++++
244  // Ratio
245  //+++++++++++++++++++++++++++++
246 
247  H_NumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS1");
248  H_NumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS2");
249 
250  H_NumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS3");
251  H_NumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS4");
252  H_NumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplLS5");
253 
254  H_NumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplLS8");
255 
256  H_NumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS6");
257  H_NumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS7");
258 
259  //+++++++++++++++++++++++++++++
260  // Tmean
261  //+++++++++++++++++++++++++++++
262 
263  H_NumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS1");
264  H_NumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS2");
265 
266  H_NumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS3");
267  H_NumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS4");
268  H_NumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS5");
269 
270  H_NumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS8");
271 
272  H_NumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS6");
273  H_NumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS7");
274 
275  //+++++++++++++++++++++++++++++
276  // Tmax
277  //+++++++++++++++++++++++++++++
278 
279  H_NumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS1");
280  H_NumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS2");
281 
282  H_NumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS3");
283  H_NumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS4");
284  H_NumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS5");
285 
286  H_NumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS8");
287 
288  H_NumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS6");
289  H_NumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS7");
290 
291  gStyle->SetOptStat(110000);
292 
293  for (int test = 1; test <= 5; test++) { //Test: 0,
294  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
295  if (sub == 1)
296  cHB->Divide(2, 1);
297  if (sub == 2)
298  cHE->Divide(3, 1);
299  if (sub == 3)
300  cONE->Divide(1, 1);
301  if (sub == 4)
302  cHB->Divide(2, 1);
303  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
304  if (sub == 1)
305  cHB->cd(k);
306  if (sub == 2)
307  cHE->cd(k);
308  if (sub == 3)
309  cONE->cd(k - 3);
310  if (sub == 4)
311  cHB->cd(k);
312  gPad->SetGridy();
313  gPad->SetGridx();
314  gPad->SetLogy();
315  H_NumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
316  H_NumBadChanDepth[test][sub][k]->SetMarkerSize(0.8);
317  if (k == 1)
318  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
319  if (k == 2)
320  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
321  if (k == 3)
322  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
323  if (k == 4)
324  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
325  if (test == 1)
326  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Amplitude> \b");
327  if (test == 2)
328  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Width> \b");
329  if (test == 3)
330  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Ratio> \b");
331  if (test == 4)
332  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS mean> \b");
333  if (test == 5)
334  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS max> \b");
335  H_NumBadChanDepth[test][sub][k]->SetYTitle("Number of channel-LSs\b");
336  H_NumBadChanDepth[test][sub][k]->SetMarkerColor(4);
337  H_NumBadChanDepth[test][sub][k]->SetLineColor(0);
338  // H_NumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
339  H_NumBadChanDepth[test][sub][k]->SetMinimum(0.8);
340  H_NumBadChanDepth[test][sub][k]->Draw("Error");
341  }
342  if (test == 0) {
343  if (sub == 1) {
344  cHB->Print("H_NBCMNHB.png");
345  cHB->Clear();
346  }
347  if (sub == 2) {
348  cHE->Print("H_NBCMNHE.png");
349  cHE->Clear();
350  }
351  if (sub == 3) {
352  cONE->Print("H_NBCMNHO.png");
353  cONE->Clear();
354  }
355  if (sub == 4) {
356  cHB->Print("H_NBCMNHF.png");
357  cHB->Clear();
358  }
359  }
360 
361  if (test == 1) {
362  if (sub == 1) {
363  cHB->Print("H_ADCamplHB.png");
364  cHB->Clear();
365  }
366  if (sub == 2) {
367  cHE->Print("H_ADCamplHE.png");
368  cHE->Clear();
369  }
370  if (sub == 3) {
371  cONE->Print("H_ADCamplHO.png");
372  cONE->Clear();
373  }
374  if (sub == 4) {
375  cHB->Print("H_ADCamplHF.png");
376  cHB->Clear();
377  }
378  }
379  if (test == 2) {
380  if (sub == 1) {
381  cHB->Print("H_WidthHB.png");
382  cHB->Clear();
383  }
384  if (sub == 2) {
385  cHE->Print("H_WidthHE.png");
386  cHE->Clear();
387  }
388  if (sub == 3) {
389  cONE->Print("H_WidthHO.png");
390  cONE->Clear();
391  }
392  if (sub == 4) {
393  cHB->Print("H_WidthHF.png");
394  cHB->Clear();
395  }
396  }
397  if (test == 3) {
398  if (sub == 1) {
399  cHB->Print("H_RatioHB.png");
400  cHB->Clear();
401  }
402  if (sub == 2) {
403  cHE->Print("H_RatioHE.png");
404  cHE->Clear();
405  }
406  if (sub == 3) {
407  cONE->Print("H_RatioHO.png");
408  cONE->Clear();
409  }
410  if (sub == 4) {
411  cHB->Print("H_RatioHF.png");
412  cHB->Clear();
413  }
414  }
415  if (test == 4) {
416  if (sub == 1) {
417  cHB->Print("H_TmeanHB.png");
418  cHB->Clear();
419  }
420  if (sub == 2) {
421  cHE->Print("H_TmeanHE.png");
422  cHE->Clear();
423  }
424  if (sub == 3) {
425  cONE->Print("H_TmeanHO.png");
426  cONE->Clear();
427  }
428  if (sub == 4) {
429  cHB->Print("H_TmeanHF.png");
430  cHB->Clear();
431  }
432  }
433  if (test == 5) {
434  if (sub == 1) {
435  cHB->Print("H_TmaxHB.png");
436  cHB->Clear();
437  }
438  if (sub == 2) {
439  cHE->Print("H_TmaxHE.png");
440  cHE->Clear();
441  }
442  if (sub == 3) {
443  cONE->Print("H_TmaxHO.png");
444  cONE->Clear();
445  }
446  if (sub == 4) {
447  cHB->Print("H_TmaxHF.png");
448  cHB->Clear();
449  }
450  }
451  } // end sub
452  } //end test
453 
454  gStyle->SetOptStat(0);
455  //================================================================================================================================
456 
457  //=======================================================================================================
458  // 2-d histograms second definition
459  //=========================================================
460  TH2F *MapNumBadChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
461  TH2F *MapNumChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
462  TH2F *MapNumBadChanFull[7]; // 1d Mapogramm for test
463  TH2F *MapNumChanFull[7]; // 1d Mapogramm for test
464 
465  //+++++++++++++++++++++++++++++
466  // CapID
467  //+++++++++++++++++++++++++++++
468 
469  MapNumBadChanDepth[0][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HB");
470  MapNumBadChanDepth[0][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HB");
471 
472  MapNumBadChanDepth[0][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HE");
473  MapNumBadChanDepth[0][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HE");
474  MapNumBadChanDepth[0][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HE");
475 
476  MapNumBadChanDepth[0][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HO");
477 
478  MapNumBadChanDepth[0][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HF");
479  MapNumBadChanDepth[0][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HF");
480 
481  MapNumBadChanFull[0] = (TH2F *)MapNumBadChanDepth[0][1][1]->Clone();
482 
483  MapNumChanDepth[0][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HB");
484  MapNumChanDepth[0][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HB");
485 
486  MapNumChanDepth[0][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HE");
487  MapNumChanDepth[0][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HE");
488  MapNumChanDepth[0][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HE");
489 
490  MapNumChanDepth[0][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HO");
491 
492  MapNumChanDepth[0][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HF");
493  MapNumChanDepth[0][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HF");
494 
495  MapNumChanFull[0] = (TH2F *)MapNumChanDepth[0][1][1]->Clone();
496 
497  //+++++++++++++++++++++++++++++
498  // ADC Amplitude
499  //+++++++++++++++++++++++++++++
500 
501  MapNumBadChanDepth[1][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS1");
502  MapNumBadChanDepth[1][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS2");
503 
504  MapNumBadChanDepth[1][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS3");
505  MapNumBadChanDepth[1][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS4");
506  MapNumBadChanDepth[1][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS5");
507 
508  MapNumBadChanDepth[1][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS8");
509 
510  MapNumBadChanDepth[1][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS6");
511  MapNumBadChanDepth[1][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS7");
512 
513  MapNumBadChanFull[1] = (TH2F *)MapNumBadChanDepth[1][1][1]->Clone();
514 
515  MapNumChanDepth[1][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS1");
516  MapNumChanDepth[1][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS2");
517 
518  MapNumChanDepth[1][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS3");
519  MapNumChanDepth[1][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS4");
520  MapNumChanDepth[1][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS5");
521 
522  MapNumChanDepth[1][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS8");
523 
524  MapNumChanDepth[1][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS6");
525  MapNumChanDepth[1][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS7");
526 
527  MapNumChanFull[1] = (TH2F *)MapNumChanDepth[1][1][1]->Clone();
528 
529  //+++++++++++++++++++++++++++++
530  // Width
531  //+++++++++++++++++++++++++++++
532 
533  MapNumBadChanDepth[2][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS1");
534  MapNumBadChanDepth[2][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS2");
535 
536  MapNumBadChanDepth[2][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS3");
537  MapNumBadChanDepth[2][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS4");
538  MapNumBadChanDepth[2][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS5");
539 
540  MapNumBadChanDepth[2][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS8");
541 
542  MapNumBadChanDepth[2][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS6");
543  MapNumBadChanDepth[2][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS7");
544 
545  MapNumBadChanFull[2] = (TH2F *)MapNumBadChanDepth[2][1][1]->Clone();
546 
547  MapNumChanDepth[2][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS1");
548  MapNumChanDepth[2][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS2");
549 
550  MapNumChanDepth[2][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS3");
551  MapNumChanDepth[2][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS4");
552  MapNumChanDepth[2][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS5");
553 
554  MapNumChanDepth[2][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS8");
555 
556  MapNumChanDepth[2][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS6");
557  MapNumChanDepth[2][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS7");
558 
559  MapNumChanFull[2] = (TH2F *)MapNumChanDepth[2][1][1]->Clone();
560 
561  //+++++++++++++++++++++++++++++
562  // Ratio
563  //+++++++++++++++++++++++++++++
564 
565  MapNumBadChanDepth[3][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS1");
566  MapNumBadChanDepth[3][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS2");
567 
568  MapNumBadChanDepth[3][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS3");
569  MapNumBadChanDepth[3][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS4");
570  MapNumBadChanDepth[3][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS5");
571 
572  MapNumBadChanDepth[3][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS8");
573 
574  MapNumBadChanDepth[3][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS6");
575  MapNumBadChanDepth[3][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS7");
576 
577  MapNumBadChanFull[3] = (TH2F *)MapNumBadChanDepth[3][1][1]->Clone();
578 
579  MapNumChanDepth[3][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS1");
580  MapNumChanDepth[3][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS2");
581 
582  MapNumChanDepth[3][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS3");
583  MapNumChanDepth[3][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS4");
584  MapNumChanDepth[3][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS5");
585 
586  MapNumChanDepth[3][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS8");
587 
588  MapNumChanDepth[3][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS6");
589  MapNumChanDepth[3][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS7");
590 
591  MapNumChanFull[3] = (TH2F *)MapNumChanDepth[3][1][1]->Clone();
592 
593  //+++++++++++++++++++++++++++++
594  // Tmean
595  //+++++++++++++++++++++++++++++
596 
597  MapNumBadChanDepth[4][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS1");
598  MapNumBadChanDepth[4][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS2");
599 
600  MapNumBadChanDepth[4][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS3");
601  MapNumBadChanDepth[4][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS4");
602  MapNumBadChanDepth[4][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS5");
603 
604  MapNumBadChanDepth[4][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS8");
605 
606  MapNumBadChanDepth[4][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS6");
607  MapNumBadChanDepth[4][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS7");
608 
609  MapNumBadChanFull[4] = (TH2F *)MapNumBadChanDepth[4][1][1]->Clone();
610 
611  MapNumChanDepth[4][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS1");
612  MapNumChanDepth[4][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS2");
613 
614  MapNumChanDepth[4][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS3");
615  MapNumChanDepth[4][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS4");
616  MapNumChanDepth[4][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS5");
617 
618  MapNumChanDepth[4][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS8");
619 
620  MapNumChanDepth[4][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS6");
621  MapNumChanDepth[4][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS7");
622 
623  MapNumChanFull[4] = (TH2F *)MapNumChanDepth[4][1][1]->Clone();
624 
625  //+++++++++++++++++++++++++++++
626  // Tmax
627  //+++++++++++++++++++++++++++++
628 
629  MapNumBadChanDepth[5][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS1");
630  MapNumBadChanDepth[5][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS2");
631 
632  MapNumBadChanDepth[5][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS3");
633  MapNumBadChanDepth[5][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS4");
634  MapNumBadChanDepth[5][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS5");
635 
636  MapNumBadChanDepth[5][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS8");
637 
638  MapNumBadChanDepth[5][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS6");
639  MapNumBadChanDepth[5][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS7");
640 
641  MapNumBadChanFull[5] = (TH2F *)MapNumBadChanDepth[5][1][1]->Clone();
642 
643  MapNumChanDepth[5][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS1");
644  MapNumChanDepth[5][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS2");
645 
646  MapNumChanDepth[5][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS3");
647  MapNumChanDepth[5][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS4");
648  MapNumChanDepth[5][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS5");
649 
650  MapNumChanDepth[5][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS8");
651 
652  MapNumChanDepth[5][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS6");
653  MapNumChanDepth[5][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS7");
654 
655  MapNumChanFull[5] = (TH2F *)MapNumChanDepth[5][1][1]->Clone();
656 
657  for (int test = 0; test <= 5; test++) { //Test: 0,
658  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
659  if (sub == 1)
660  cHB->Divide(2, 1);
661  if (sub == 2)
662  cHE->Divide(3, 1);
663  if (sub == 3)
664  cONE->Divide(1, 1);
665  if (sub == 4)
666  cHB->Divide(2, 1);
667  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
668  if (sub == 1)
669  cHB->cd(k);
670  if (sub == 2)
671  cHE->cd(k);
672  if (sub == 3)
673  cONE->cd(k - 3);
674  if (sub == 4)
675  cHB->cd(k);
676  MapNumBadChanDepth[test][sub][k]->Divide(
677  MapNumBadChanDepth[test][sub][k], MapNumChanDepth[test][sub][k], 1, 1, "B");
678 
679  for (int x = 1; x <= MapNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
680  for (int y = 1; y <= MapNumBadChanFull[test]->GetYaxis()->GetNbins(); y++) {
681  double ccc1 = MapNumBadChanDepth[test][sub][k]->GetBinContent(x, y);
682  MapNumBadChanFull[test]->SetBinContent(x, y, MapNumBadChanFull[test]->GetBinContent(x, y) + ccc1);
683  } //end y
684  } //end x
685 
686  if (k == 1)
687  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
688  if (k == 2)
689  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
690  if (k == 3)
691  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
692  if (k == 4)
693  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
694  gPad->SetGridy();
695  gPad->SetGridx();
696  gPad->SetLogz();
697  MapNumBadChanDepth[test][sub][k]->SetXTitle("#eta \b");
698  MapNumBadChanDepth[test][sub][k]->SetYTitle("#phi \b");
699  MapNumBadChanDepth[test][sub][k]->SetZTitle("Average estimator \b");
700  MapNumBadChanDepth[test][sub][k]->SetTitleOffset(0.75, "Z");
701  MapNumBadChanDepth[test][sub][k]->Draw("COLZ");
702  MapNumBadChanDepth[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
703  // MapNumBadChanDepth[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
704  }
705  if (test == 0) {
706  if (sub == 1) {
707  cHB->Print("MapCapIdErrorHB.png");
708  cHB->Clear();
709  }
710  if (sub == 2) {
711  cHE->Print("MapCapIdErrorHE.png");
712  cHE->Clear();
713  }
714  if (sub == 3) {
715  cONE->Print("MapCapIdErrorHO.png");
716  cONE->Clear();
717  }
718  if (sub == 4) {
719  cHB->Print("MapCapIdErrorHF.png");
720  cHB->Clear();
721  }
722  }
723  if (test == 1) {
724  if (sub == 1) {
725  cHB->Print("MapADCamplHB.png");
726  cHB->Clear();
727  }
728  if (sub == 2) {
729  cHE->Print("MapADCamplHE.png");
730  cHE->Clear();
731  }
732  if (sub == 3) {
733  cONE->Print("MapADCamplHO.png");
734  cONE->Clear();
735  }
736  if (sub == 4) {
737  cHB->Print("MapADCamplHF.png");
738  cHB->Clear();
739  }
740  }
741  if (test == 2) {
742  if (sub == 1) {
743  cHB->Print("MapWidthHB.png");
744  cHB->Clear();
745  }
746  if (sub == 2) {
747  cHE->Print("MapWidthHE.png");
748  cHE->Clear();
749  }
750  if (sub == 3) {
751  cONE->Print("MapWidthHO.png");
752  cONE->Clear();
753  }
754  if (sub == 4) {
755  cHB->Print("MapWidthHF.png");
756  cHB->Clear();
757  }
758  }
759  if (test == 3) {
760  if (sub == 1) {
761  cHB->Print("MapRatioHB.png");
762  cHB->Clear();
763  }
764  if (sub == 2) {
765  cHE->Print("MapRatioHE.png");
766  cHE->Clear();
767  }
768  if (sub == 3) {
769  cONE->Print("MapRatioHO.png");
770  cONE->Clear();
771  }
772  if (sub == 4) {
773  cHB->Print("MapRatioHF.png");
774  cHB->Clear();
775  }
776  }
777  if (test == 4) {
778  if (sub == 1) {
779  cHB->Print("MapTmeanHB.png");
780  cHB->Clear();
781  }
782  if (sub == 2) {
783  cHE->Print("MapTmeanHE.png");
784  cHE->Clear();
785  }
786  if (sub == 3) {
787  cONE->Print("MapTmeanHO.png");
788  cONE->Clear();
789  }
790  if (sub == 4) {
791  cHB->Print("MapTmeanHF.png");
792  cHB->Clear();
793  }
794  }
795  if (test == 5) {
796  if (sub == 1) {
797  cHB->Print("MapTmaxHB.png");
798  cHB->Clear();
799  }
800  if (sub == 2) {
801  cHE->Print("MapTmaxHE.png");
802  cHE->Clear();
803  }
804  if (sub == 3) {
805  cONE->Print("MapTmaxHO.png");
806  cONE->Clear();
807  }
808  if (sub == 4) {
809  cHB->Print("MapTmaxHF.png");
810  cHB->Clear();
811  }
812  }
813  } // end sub
814  cONE->Divide(1, 1);
815  cONE->cd(1);
816  gPad->SetGridy();
817  gPad->SetGridx();
818  gPad->SetLogz();
819  MapNumBadChanFull[test]->SetTitle("All subdetectors\b");
820  MapNumBadChanFull[test]->SetXTitle("#eta \b");
821  MapNumBadChanFull[test]->SetYTitle("#phi \b");
822  if (test == 0)
823  MapNumBadChanFull[test]->SetZTitle("Average Nbcs \b");
824  if (test != 0)
825  MapNumBadChanFull[test]->SetZTitle("Average estimator \b");
826  // MapNumBadChanFull[test]->GetZaxis()->SetLabelSize(0.008);
827  MapNumBadChanFull[test]->SetTitleOffset(0.75, "Z");
828  MapNumBadChanFull[test]->Draw("COLZ");
829  MapNumBadChanFull[test]->GetYaxis()->SetRangeUser(0, 72.);
830  // MapNumBadChanFull[test]->GetZaxis()->SetRangeUser(0.0001, 1.);
831  if (test == 0) {
832  cONE->Print("MapCapIdError.png");
833  cONE->Clear();
834  }
835  if (test == 1) {
836  cONE->Print("MapADCAmpl.png");
837  cONE->Clear();
838  }
839  if (test == 2) {
840  cONE->Print("MapWidth.png");
841  cONE->Clear();
842  }
843  if (test == 3) {
844  cONE->Print("MapRatio.png");
845  cONE->Clear();
846  }
847  if (test == 4) {
848  cONE->Print("MapTmean.png");
849  cONE->Clear();
850  }
851  if (test == 5) {
852  cONE->Print("MapTmax.png");
853  cONE->Clear();
854  }
855  } //end test
856 
857  //================================================================================================================================
858 
859  //=======================================================================================================
860  // 1-d histograms third definition
861 
862  TH1F *HistNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
863  TH1F *HistCutNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
864  TH1F *HistNumChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
865 
866  // TH1F *HistNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
867  // TH1F *HistCutNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
868  // TH1F *HistNumChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
869 
870  TH1F *HistNumBadChanFull[7]; // 1d histogramm for test
871  TH1F *HistNumChanFull[7]; // 1d histogramm for test
872 
873  //+++++++++++++++++++++++++++++
874  // Rate of Cap ID errors
875  //+++++++++++++++++++++++++++++
876 
877  HistNumBadChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HB");
878  HistNumBadChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HB");
879 
880  HistNumBadChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HE");
881  HistNumBadChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HE");
882  HistNumBadChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth3_HE");
883 
884  HistNumBadChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth4_HO");
885 
886  HistNumBadChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HF");
887  HistNumBadChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HF");
888 
889  HistNumBadChanFull[0] = (TH1F *)HistNumBadChanDepth[0][1][1]->Clone();
890 
891  HistCutNumBadChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HB");
892  HistCutNumBadChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HB");
893 
894  HistCutNumBadChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HE");
895  HistCutNumBadChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HE");
896  HistCutNumBadChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth3_HE");
897 
898  HistCutNumBadChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth4_HO");
899 
900  HistCutNumBadChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HF");
901  HistCutNumBadChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HF");
902 
903  HistNumChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HB");
904  HistNumChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HB");
905 
906  HistNumChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HE");
907  HistNumChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HE");
908  HistNumChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth3_HE");
909 
910  HistNumChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth4_HO");
911 
912  HistNumChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HF");
913  HistNumChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HF");
914 
915  HistNumChanFull[0] = (TH1F *)HistNumChanDepth[0][1][1]->Clone();
916 
917  //+++++++++++++++++++++++++++++
918  // ADC Amplitude
919  //+++++++++++++++++++++++++++++
920 
922  // HB:
923  HistNumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS1");
924  HistNumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS2");
925  // HB upgrade:
926  HistNumBadChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth3HBu");
927  HistNumBadChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth4HBu");
928 
929  // HE:
930  HistNumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS3");
931  HistNumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS4");
932  HistNumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS5");
933  // HE upgrade:
934  HistNumBadChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth4HEu");
935  HistNumBadChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth5HEu");
936  HistNumBadChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth6HEu");
937  HistNumBadChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth7HEu");
938 
939  // HO:
940  HistNumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS8");
941 
942  // HF:
943  HistNumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS6");
944  HistNumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS7");
945  // HF upgrade:
946  HistNumBadChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS6u");
947  HistNumBadChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS7u");
948 
949  // other cases:
950  HistNumBadChanFull[1] = (TH1F *)HistNumBadChanDepth[1][1][1]->Clone();
951 
953  // HB:
954  HistCutNumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS1");
955  HistCutNumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS2");
956  // HB upgrade:
957  HistCutNumBadChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth3HBu");
958  HistCutNumBadChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth4HBu");
959 
960  // HE:
961  HistCutNumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS3");
962  HistCutNumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS4");
963  HistCutNumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS5");
964  // HE upgrade:
965  HistCutNumBadChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth4HEu");
966  HistCutNumBadChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth5HEu");
967  HistCutNumBadChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth6HEu");
968  HistCutNumBadChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth7HEu");
969 
970  // HO:
971  HistCutNumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS8");
972 
973  // HF:
974  HistCutNumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS6");
975  HistCutNumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS7");
976  // HF upgrade:
977  HistCutNumBadChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS6u");
978  HistCutNumBadChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS7u");
979 
981  // HB:
982  HistNumChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS1");
983  HistNumChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS2");
984  // HB upgrade:
985  HistNumChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth3HBu");
986  HistNumChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth4HBu");
987 
988  // HE:
989  HistNumChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS3");
990  HistNumChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS4");
991  HistNumChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS5");
992  // HE upgrade:
993  HistNumChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth4HEu");
994  HistNumChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth5HEu");
995  HistNumChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth6HEu");
996  HistNumChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth7HEu");
997 
998  // HO:
999  HistNumChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS8");
1000 
1001  // HF:
1002  HistNumChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS6");
1003  HistNumChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS7");
1004  // HF upgrade:
1005  HistNumChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS6u");
1006  HistNumChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS7u");
1007 
1008  // other cases:
1009  HistNumChanFull[1] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
1010  // just initialization of [6] massive for alternative <A> calculation
1011  HistNumChanFull[6] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
1012 
1013  //+++++++++++++++++++++++++++++
1014  // Width
1015  //+++++++++++++++++++++++++++++
1016 
1017  HistNumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS1");
1018  HistNumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS2");
1019 
1020  HistNumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS3");
1021  HistNumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS4");
1022  HistNumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS5");
1023 
1024  HistNumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS8");
1025 
1026  HistNumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS6");
1027  HistNumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS7");
1028 
1029  HistNumBadChanFull[2] = (TH1F *)HistNumBadChanDepth[2][1][1]->Clone();
1030 
1031  HistCutNumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS1");
1032  HistCutNumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS2");
1033 
1034  HistCutNumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS3");
1035  HistCutNumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS4");
1036  HistCutNumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS5");
1037 
1038  HistCutNumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS8");
1039 
1040  HistCutNumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS6");
1041  HistCutNumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS7");
1042 
1043  HistNumChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS1");
1044  HistNumChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS2");
1045 
1046  HistNumChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS3");
1047  HistNumChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS4");
1048  HistNumChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS5");
1049 
1050  HistNumChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS8");
1051 
1052  HistNumChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS6");
1053  HistNumChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS7");
1054 
1055  HistNumChanFull[2] = (TH1F *)HistNumChanDepth[2][1][1]->Clone();
1056  //+++++++++++++++++++++++++++++
1057  // Ratio
1058  //+++++++++++++++++++++++++++++
1059 
1060  HistNumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS1");
1061  HistNumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS2");
1062 
1063  HistNumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS3");
1064  HistNumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS4");
1065  HistNumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS5");
1066 
1067  HistNumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS8");
1068 
1069  HistNumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS6");
1070  HistNumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS7");
1071 
1072  HistNumBadChanFull[3] = (TH1F *)HistNumBadChanDepth[3][1][1]->Clone();
1073 
1074  HistCutNumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS1");
1075  HistCutNumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS2");
1076 
1077  HistCutNumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS3");
1078  HistCutNumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS4");
1079  HistCutNumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS5");
1080 
1081  HistCutNumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS8");
1082 
1083  HistCutNumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS6");
1084  HistCutNumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS7");
1085 
1086  HistNumChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS1");
1087  HistNumChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS2");
1088 
1089  HistNumChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS3");
1090  HistNumChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS4");
1091  HistNumChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS5");
1092 
1093  HistNumChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS8");
1094 
1095  HistNumChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS6");
1096  HistNumChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS7");
1097 
1098  HistNumChanFull[3] = (TH1F *)HistNumChanDepth[3][1][1]->Clone();
1099  //+++++++++++++++++++++++++++++
1100  // Tmean
1101  //+++++++++++++++++++++++++++++
1102 
1103  HistNumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS1");
1104  HistNumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS2");
1105 
1106  HistNumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS3");
1107  HistNumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS4");
1108  HistNumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS5");
1109 
1110  HistNumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS8");
1111 
1112  HistNumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS6");
1113  HistNumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS7");
1114 
1115  HistNumBadChanFull[4] = (TH1F *)HistNumBadChanDepth[4][1][1]->Clone();
1116 
1117  HistCutNumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS1");
1118  HistCutNumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS2");
1119 
1120  HistCutNumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS3");
1121  HistCutNumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS4");
1122  HistCutNumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS5");
1123 
1124  HistCutNumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS8");
1125 
1126  HistCutNumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS6");
1127  HistCutNumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS7");
1128 
1129  HistNumChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS1");
1130  HistNumChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS2");
1131 
1132  HistNumChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS3");
1133  HistNumChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS4");
1134  HistNumChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS5");
1135 
1136  HistNumChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS8");
1137 
1138  HistNumChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS6");
1139  HistNumChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS7");
1140 
1141  HistNumChanFull[4] = (TH1F *)HistNumChanDepth[4][1][1]->Clone();
1142  //+++++++++++++++++++++++++++++
1143  // Tmax
1144  //+++++++++++++++++++++++++++++
1145 
1146  HistNumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS1");
1147  HistNumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS2");
1148 
1149  HistNumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS3");
1150  HistNumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS4");
1151  HistNumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS5");
1152 
1153  HistNumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS8");
1154 
1155  HistNumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS6");
1156  HistNumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS7");
1157 
1158  HistNumBadChanFull[5] = (TH1F *)HistNumBadChanDepth[5][1][1]->Clone();
1159 
1160  HistCutNumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS1");
1161  HistCutNumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS2");
1162 
1163  HistCutNumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS3");
1164  HistCutNumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS4");
1165  HistCutNumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS5");
1166 
1167  HistCutNumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS8");
1168 
1169  HistCutNumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS6");
1170  HistCutNumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS7");
1171 
1172  HistNumChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS1");
1173  HistNumChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS2");
1174 
1175  HistNumChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS3");
1176  HistNumChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS4");
1177  HistNumChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS5");
1178 
1179  HistNumChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS8");
1180 
1181  HistNumChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS6");
1182  HistNumChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS7");
1183 
1184  HistNumChanFull[5] = (TH1F *)HistNumChanDepth[5][1][1]->Clone();
1185 
1186  for (int test = 0; test <= 5; test++) { //Test: =0(CapIdErrors), =1(Amplitude), =2...
1187  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1188  if (sub == 1 && test != 1)
1189  cHE->Divide(2, 1); //HB
1190  if (sub == 1 && test == 1) {
1191  cFour1->Clear();
1192  cFour1->Divide(2, 2);
1193  } //HB upgrade with new depthes 3,4 for Amplitude test only
1194  if (sub == 2 && test != 1)
1195  cHE->Divide(3, 1); //HE
1196  if (sub == 2 && test == 1) {
1197  cNine->Clear();
1198  cNine->Divide(3, 3);
1199  } //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1200  if (sub == 3)
1201  cHB->Divide(1, 1); //HO
1202  if (sub == 4 && test != 1)
1203  cHE->Divide(2, 1); //HF
1204  if (sub == 4 && test == 1) {
1205  cFour1->Clear();
1206  cFour1->Divide(2, 2);
1207  } // HF upgrade with new depthes 3 and 4 for Amplitude test only
1208 
1209  int kkkkkkmax = k_max[sub];
1210  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
1211  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
1212  kkkkkkmax = k_maxupgrade[sub];
1213  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1214  if (sub == 1 && test != 1)
1215  cHE->cd(k); //HB
1216  if (sub == 1 && test == 1)
1217  cFour1->cd(k); //HB
1218  if (sub == 2 && test != 1)
1219  cHE->cd(k); //HE
1220  if (sub == 2 && test == 1)
1221  cNine->cd(k); //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1222  if (sub == 3)
1223  cHB->cd(k - 3); //HO
1224  if (sub == 4 && test != 1)
1225  cHE->cd(k); //HF
1226  if (sub == 4 && test == 1)
1227  cFour1->cd(k); // HF upgrade with new depthes 3 and 4 for Amplitude test only
1228  gPad->SetGridy();
1229  gPad->SetGridx();
1230  // gPad->SetLogy();
1231 
1232  if (sub == 1 && k == 1) {
1233  } else {
1234  // use "else" because ...Full[test] are filled by estimastor for sub==1 && k== 1 at initialization of ...Full[test] variables
1235  for (int x = 1; x <= HistNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
1236  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1237  HistNumBadChanFull[test]->SetBinContent(x, HistNumBadChanFull[test]->GetBinContent(x) + ccc1);
1238  double ccc2 = HistNumChanDepth[test][sub][k]->GetBinContent(x);
1239  HistNumChanFull[test]->SetBinContent(x, HistNumChanFull[test]->GetBinContent(x) + ccc2);
1240  }
1241  } //end x
1242 
1243  // !!!!!! change the sense of HistNumBadChanDepth: now it's averaged values(estimators)
1244  HistNumBadChanDepth[test][sub][k]->Divide(
1245  HistNumBadChanDepth[test][sub][k], HistNumChanDepth[test][sub][k], 1, 1, "B");
1246  // errors abnulling:
1247  for (int x = 1; x <= HistNumBadChanDepth[test][sub][k]->GetXaxis()->GetNbins(); x++) {
1248  HistNumBadChanDepth[test][sub][k]->SetBinError(float(x), 0.01);
1249  }
1250 
1251  // int myMaxLum= HistNumBadChanDepth[test][sub][k]->GetBinContent(HistNumBadChanDepth[test][sub][k]->GetMaximumBin());
1252  // cout<<"********************>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> myMaxLum = "<<myMaxLum<<" MaxLum = "<<MaxLum<<endl;
1253  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1254 
1255  // // // // // // // // // // // // // // // // // //
1256  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1257  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.4);
1258  HistNumBadChanDepth[test][sub][k]->GetYaxis()->SetLabelSize(0.04);
1259  if (k == 1)
1260  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1261  if (k == 2)
1262  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1263  if (k == 3)
1264  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1265  if (k == 4)
1266  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1267  if (k == 5)
1268  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 5\b");
1269  if (k == 6)
1270  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 6\b");
1271  if (k == 7)
1272  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 7\b");
1273  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1274  if (test == 0)
1275  HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1276  if (test != 0)
1277  HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1278  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1279  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1280  // gPad->SetGridx();
1281  gPad->SetLogy();
1282  gPad->SetGridy();
1283  gPad->SetGridx();
1284  // if (test == 1) HistNumBadChanDepth[test][sub][k]->SetMinimum(0.1);
1285  HistNumBadChanDepth[test][sub][k]->Draw("Error");
1286  /*
1287  if (k == 1) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1288  if (k == 2) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1289  if (k == 3) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1290  if (k == 4) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1291  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1292  if (test == 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1293  if (test != 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1294 
1295  if (MaxLum<=1000){
1296  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1297  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.5);
1298  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1299  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1300  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1301  HistNumBadChanDepth[test][sub][k]->Draw("P");
1302  }
1303  else{
1304  HistNumBadChanDepth[test][sub][k]->SetLineColor(2);
1305  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1306  HistNumBadChanDepth[test][sub][k]->Draw("L");
1307  }
1308  */
1309  /*
1310  float min_x[] = {0,10000};
1311  float min_y[] = {(float)(Cut0[test][sub][k]),(float)(Cut0[test][sub][k])};
1312  TGraph* MIN = new TGraph(2, min_x, min_y);
1313  MIN->SetLineStyle(2);
1314  MIN->SetLineColor(5);
1315  MIN->SetLineWidth(2 + 100*100);
1316  MIN->SetFillStyle(3005);
1317  MIN->SetFillColor(5);
1318  gPad->SetGridy();
1319  gPad->SetGridx();
1320  MIN->Draw("L");
1321 */
1322 
1323  if (sub == 1 && test != 1) {
1324  cHE->Modified();
1325  }
1326  if (sub == 1 && test == 1) {
1327  cFour1->Modified();
1328  } // HB upgrade
1329  if (sub == 2 && test != 1) {
1330  cHE->Modified();
1331  }
1332  if (sub == 2 && test == 1) {
1333  cNine->Modified();
1334  } // HE upgrade
1335  if (sub == 3) {
1336  cHB->Modified();
1337  }
1338  if (sub == 4 && test != 1) {
1339  cHE->Modified();
1340  }
1341  if (sub == 4 && test == 1) {
1342  cFour1->Modified();
1343  } // HF upgrade
1344 
1345  } // k loop
1346 
1347  if (test == 0) {
1348  if (sub == 1) {
1349  cHE->Print("HistNBCMNHB.png");
1350  cHE->Clear();
1351  }
1352  if (sub == 2) {
1353  cHE->Print("HistNBCMNHE.png");
1354  cHE->Clear();
1355  }
1356  if (sub == 3) {
1357  cHB->Print("HistNBCMNHO.png");
1358  cHB->Clear();
1359  }
1360  if (sub == 4) {
1361  cHE->Print("HistNBCMNHF.png");
1362  cHE->Clear();
1363  }
1364  }
1365  // Amplitude:
1366  if (test == 1) {
1367  if (sub == 1) {
1368  cFour1->Print("HistADCamplHB.png");
1369  cFour1->Clear();
1370  } // HB upgrade
1371  if (sub == 2) {
1372  cNine->Print("HistADCamplHE.png");
1373  cNine->Clear();
1374  } // HE upgrade
1375  if (sub == 3) {
1376  cHB->Print("HistADCamplHO.png");
1377  cHB->Clear();
1378  }
1379  if (sub == 4) {
1380  cFour1->Print("HistADCamplHF.png");
1381  cFour1->Clear();
1382  } // HF upgrade
1383  }
1384  if (test == 2) {
1385  if (sub == 1) {
1386  cHE->Print("HistWidthHB.png");
1387  cHE->Clear();
1388  }
1389  if (sub == 2) {
1390  cHE->Print("HistWidthHE.png");
1391  cHE->Clear();
1392  }
1393  if (sub == 3) {
1394  cHB->Print("HistWidthHO.png");
1395  cHB->Clear();
1396  }
1397  if (sub == 4) {
1398  cHE->Print("HistWidthHF.png");
1399  cHE->Clear();
1400  }
1401  }
1402  if (test == 3) {
1403  if (sub == 1) {
1404  cHE->Print("HistRatioHB.png");
1405  cHE->Clear();
1406  }
1407  if (sub == 2) {
1408  cHE->Print("HistRatioHE.png");
1409  cHE->Clear();
1410  }
1411  if (sub == 3) {
1412  cHB->Print("HistRatioHO.png");
1413  cHB->Clear();
1414  }
1415  if (sub == 4) {
1416  cHE->Print("HistRatioHF.png");
1417  cHE->Clear();
1418  }
1419  }
1420  if (test == 4) {
1421  if (sub == 1) {
1422  cHE->Print("HistTmeanHB.png");
1423  cHE->Clear();
1424  }
1425  if (sub == 2) {
1426  cHE->Print("HistTmeanHE.png");
1427  cHE->Clear();
1428  }
1429  if (sub == 3) {
1430  cHB->Print("HistTmeanHO.png");
1431  cHB->Clear();
1432  }
1433  if (sub == 4) {
1434  cHE->Print("HistTmeanHF.png");
1435  cHE->Clear();
1436  }
1437  }
1438  if (test == 5) {
1439  if (sub == 1) {
1440  cHE->Print("HistTmaxHB.png");
1441  cHE->Clear();
1442  }
1443  if (sub == 2) {
1444  cHE->Print("HistTmaxHE.png");
1445  cHE->Clear();
1446  }
1447  if (sub == 3) {
1448  cHB->Print("HistTmaxHO.png");
1449  cHB->Clear();
1450  }
1451  if (sub == 4) {
1452  cHE->Print("HistTmaxHF.png");
1453  cHE->Clear();
1454  }
1455  }
1456  } // end sub
1458  if (test == 1) {
1459  for (int x = 1; x <= HistNumChanFull[6]->GetXaxis()->GetNbins(); x++) {
1460  HistNumChanFull[6]->SetBinContent(x, 0.0);
1461  int depthsubcount = 0.;
1462  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1463  int kkkkkkmax = k_max[sub];
1464  if (sub == 4 || sub == 2 || sub == 1)
1465  kkkkkkmax = k_maxupgrade[sub];
1466  // if ( sub==4 || sub==2) kkkkkkmax = k_maxupgrade[sub];
1467  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1468  // 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
1469  // if(sub==2 && k>3 ) break;
1470  depthsubcount++;
1471  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1472  HistNumChanFull[6]->SetBinContent(x, HistNumChanFull[6]->GetBinContent(x) + ccc1);
1473  } //depth
1474  } //sub
1475  if (depthsubcount > 0.) {
1476  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / depthsubcount);
1477  } else {
1478  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / 8.);
1479  }
1480  } //x
1481  } //test=1
1483  if (test != 1) {
1484  cHB->Divide(1, 1);
1485  cHB->cd(1);
1486  } else {
1487  cHE->Divide(2, 1);
1488  cHE->cd(1);
1489  }
1490  HistNumBadChanFull[test]->Divide(HistNumBadChanFull[test], HistNumChanFull[test], 1, 1, "B");
1491  TH1F *kfitq = new TH1F("kfitq", "", MaxLum, 1., MaxLum + 1.);
1492  int nx = kfitq->GetXaxis()->GetNbins();
1493  for (int i = 1; i <= nx; i++) {
1494  double ccc1 = HistNumBadChanFull[test]->GetBinContent(i);
1495  if (ccc1 > 0.) {
1496  kfitq->Fill(float(i), ccc1);
1497  kfitq->SetBinError(float(i), 0.01);
1498  }
1499  }
1500  kfitq->SetMarkerStyle(20);
1501  kfitq->SetMarkerSize(0.4);
1502  kfitq->GetYaxis()->SetLabelSize(0.04);
1503  if (test == 0)
1504  kfitq->SetTitle("Average Nbch for whole Hcal \b");
1505  if (test != 0)
1506  kfitq->SetTitle("Averaged estimator for whole Hcal \b");
1507  kfitq->SetXTitle("LS \b");
1508  if (test == 0)
1509  kfitq->SetYTitle("<Number of bad channels> \b");
1510  if (test != 0)
1511  kfitq->SetYTitle("Averaged estimator \b");
1512  kfitq->SetMarkerColor(2);
1513  kfitq->SetLineColor(0);
1514  gPad->SetGridx();
1515  kfitq->Draw("Error");
1516  /*
1517  HistNumBadChanFull[test]->SetMarkerStyle(20);
1518  HistNumBadChanFull[test]->SetMarkerSize(0.8);
1519  HistNumBadChanFull[test]->SetTitle("Averaged estimator for whole Hcal \b");
1520  HistNumBadChanFull[test]->SetXTitle("LS \b");
1521  if (test == 0) HistNumBadChanFull[test]->SetYTitle("<Number of bad channels> \b");
1522  if (test != 0) HistNumBadChanFull[test]->SetYTitle("Averaged estimator \b");
1523  if (MaxLum<=1000){
1524  HistNumBadChanFull[test]->SetMarkerColor(1);
1525  HistNumBadChanFull[test]->SetLineColor(0);
1526  HistNumBadChanFull[test]->Draw("P");
1527  }
1528  else {
1529  HistNumBadChanFull[test]->SetLineColor(1);
1530  HistNumBadChanFull[test]->Draw("L");
1531  }
1532  */
1533  if (test == 1) {
1534  cHE->cd(2);
1535  TH1F *lpuio = new TH1F("lpuio", "", MaxLum, 1., MaxLum + 1.);
1536  int nx = lpuio->GetXaxis()->GetNbins();
1537  for (int i = 1; i <= nx; i++) {
1538  double ccc1 = HistNumChanFull[6]->GetBinContent(i);
1539  if (ccc1 > 0.) {
1540  lpuio->Fill(float(i), ccc1);
1541  lpuio->SetBinError(float(i), 0.01);
1542  }
1543  }
1544  lpuio->SetMarkerStyle(20);
1545  lpuio->SetMarkerSize(0.4);
1546  lpuio->GetYaxis()->SetLabelSize(0.04);
1547  lpuio->SetTitle("Mean of Averaged Amplitudes over all Hcal sub-detectors \b");
1548  lpuio->SetXTitle("LS \b");
1549  lpuio->SetYTitle("Mean of Averaged estimator \b");
1550  lpuio->SetMarkerColor(2);
1551  lpuio->SetLineColor(0);
1552  gPad->SetGridx();
1553  lpuio->Draw("Error");
1554  }
1555  if (test == 0) {
1556  cHB->Print("HistCapID.png");
1557  cHB->Clear();
1558  }
1559  if (test == 1) {
1560  cHE->Print("HistADCAmpl.png");
1561  cHE->Clear();
1562  }
1563  if (test == 2) {
1564  cHB->Print("HistWidth.png");
1565  cHB->Clear();
1566  }
1567  if (test == 3) {
1568  cHB->Print("HistRatio.png");
1569  cHB->Clear();
1570  }
1571  if (test == 4) {
1572  cHB->Print("HistTmean.png");
1573  cHB->Clear();
1574  }
1575  if (test == 5) {
1576  cHB->Print("HistTmax.png");
1577  cHB->Clear();
1578  }
1579 
1580  // clean-up
1581  if (kfitq)
1582  delete kfitq;
1583  } //end test
1584 
1585  //================================================================================================================================
1586 
1587  //=======================================================================================================333
1588  //CapID 1-d histograms
1589 
1590  TH1F *HistAbnormNumBadChanDepth[5][5]; // 1d histogramm for subdet, depth
1591 
1592  //+++++++++++++++++++++++++++++
1593  // Abnormal Bad Channels Rate of Cap ID errors first set of histograms
1594  //+++++++++++++++++++++++++++++
1595 
1596  HistAbnormNumBadChanDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HB");
1597  HistAbnormNumBadChanDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HB");
1598  HistAbnormNumBadChanDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HE");
1599  HistAbnormNumBadChanDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HE");
1600  HistAbnormNumBadChanDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth3_HE");
1601  HistAbnormNumBadChanDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth4_HO");
1602  HistAbnormNumBadChanDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HF");
1603  HistAbnormNumBadChanDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HF");
1604 
1605  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1606  if (sub == 1)
1607  cHB->Divide(2, 1);
1608  if (sub == 2)
1609  cHE->Divide(3, 1);
1610  if (sub == 3)
1611  cONE->Divide(1, 1);
1612  if (sub == 4)
1613  cHB->Divide(2, 1);
1614  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1615  if (sub == 1)
1616  cHB->cd(k);
1617  if (sub == 2)
1618  cHE->cd(k);
1619  if (sub == 3)
1620  cONE->cd(k - 3);
1621  if (sub == 4)
1622  cHB->cd(k);
1623  gPad->SetGridy();
1624  gPad->SetGridx();
1625  // gPad->SetLogy();
1626  HistAbnormNumBadChanDepth[sub][k]->Divide(
1627  HistAbnormNumBadChanDepth[sub][k], HistNumChanDepth[0][sub][k], 1, 1, "B");
1628  if (k == 1)
1629  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 1\b");
1630  if (k == 2)
1631  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 2\b");
1632  if (k == 3)
1633  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 3\b");
1634  if (k == 4)
1635  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 4\b");
1636  HistAbnormNumBadChanDepth[sub][k]->SetXTitle("LS \b");
1637  HistAbnormNumBadChanDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1638  if (MaxLum <= 1000) {
1639  HistAbnormNumBadChanDepth[sub][k]->SetMarkerStyle(20);
1640  HistAbnormNumBadChanDepth[sub][k]->SetMarkerSize(0.5);
1641  HistAbnormNumBadChanDepth[sub][k]->SetMarkerColor(1);
1642  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(0);
1643  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1644  HistAbnormNumBadChanDepth[sub][k]->Draw("P");
1645  } else {
1646  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(1);
1647  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1648  HistAbnormNumBadChanDepth[sub][k]->Draw("L");
1649  }
1650  }
1651  if (sub == 1) {
1652  cHB->Print("Hist_CAPID_Abnorm_HB.png");
1653  cHB->Clear();
1654  }
1655  if (sub == 2) {
1656  cHE->Print("Hist_CAPID_Abnorm_HE.png");
1657  cHE->Clear();
1658  }
1659  if (sub == 3) {
1660  cONE->Print("Hist_CAPID_Abnorm_HO.png");
1661  cONE->Clear();
1662  }
1663  if (sub == 4) {
1664  cHB->Print("Hist_CAPID_Abnorm_HF.png");
1665  cHB->Clear();
1666  }
1667  } // end sub
1668 
1669  //+++++++++++++++++++++++++++++
1670  // Portions of bad channels events identified by Cap ID errors third set of histograms
1671  //+++++++++++++++++++++++++++++
1672 
1673  TH1F *HistPortBadEventsDepth[5][5]; // 1d histogramm for subdet, depth
1674 
1675  HistPortBadEventsDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HB");
1676  HistPortBadEventsDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HB");
1677  HistPortBadEventsDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HE");
1678  HistPortBadEventsDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HE");
1679  HistPortBadEventsDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth3_HE");
1680  HistPortBadEventsDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth4_HO");
1681  HistPortBadEventsDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HF");
1682  HistPortBadEventsDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HF");
1683 
1684  TH1F *HistNumRateDepth[5][5];
1685  HistNumRateDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HB");
1686  HistNumRateDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HB");
1687  HistNumRateDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HE");
1688  HistNumRateDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HE");
1689  HistNumRateDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth3_HE");
1690  HistNumRateDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth4_HO");
1691  HistNumRateDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HF");
1692  HistNumRateDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HF");
1693 
1694  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1695  if (sub == 1)
1696  cHB->Divide(2, 1);
1697  if (sub == 2)
1698  cHE->Divide(3, 1);
1699  if (sub == 3)
1700  cONE->Divide(1, 1);
1701  if (sub == 4)
1702  cHB->Divide(2, 1);
1703  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1704  if (sub == 1)
1705  cHB->cd(k);
1706  if (sub == 2)
1707  cHE->cd(k);
1708  if (sub == 3)
1709  cONE->cd(k - 3);
1710  if (sub == 4)
1711  cHB->cd(k);
1712  gPad->SetGridy();
1713  gPad->SetGridx();
1714  // gPad->SetLogy();
1715  HistPortBadEventsDepth[sub][k]->Divide(HistPortBadEventsDepth[sub][k], HistNumRateDepth[sub][k], 1, 1, "B");
1716 
1717  if (k == 1)
1718  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 1\b");
1719  if (k == 2)
1720  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 2\b");
1721  if (k == 3)
1722  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 3\b");
1723  if (k == 4)
1724  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 4\b");
1725  HistPortBadEventsDepth[sub][k]->SetXTitle("LS \b");
1726  HistPortBadEventsDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1727  if (MaxLum <= 1000) {
1728  HistPortBadEventsDepth[sub][k]->SetMarkerStyle(20);
1729  HistPortBadEventsDepth[sub][k]->SetMarkerSize(0.5);
1730  HistPortBadEventsDepth[sub][k]->SetMarkerColor(1);
1731  HistPortBadEventsDepth[sub][k]->SetLineColor(0);
1732  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1733  HistPortBadEventsDepth[sub][k]->Draw("P");
1734  } else {
1735  HistPortBadEventsDepth[sub][k]->SetLineColor(1);
1736  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1737  HistPortBadEventsDepth[sub][k]->Draw("L");
1738  }
1739  }
1740  if (sub == 1) {
1741  cHB->Print("HistPortHB.png");
1742  cHB->Clear();
1743  }
1744  if (sub == 2) {
1745  cHE->Print("HistPortHE.png");
1746  cHE->Clear();
1747  }
1748  if (sub == 3) {
1749  cONE->Print("HistPortHO.png");
1750  cONE->Clear();
1751  }
1752  if (sub == 4) {
1753  cHB->Print("HistPortHF.png");
1754  cHB->Clear();
1755  }
1756  } // end sub
1757 
1758  //================================================================================================================================
1759 
1760  //+++++++++++++++++++++++++++++
1761  // Number of bad channels events identified by Cap ID errors third set of histograms
1762  //+++++++++++++++++++++++++++++
1763 
1764  TH1F *HistNBadChsDepth[5][5]; // 1d histogramm for subdet, depth
1765 
1766  HistNBadChsDepth[1][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HB");
1767  HistNBadChsDepth[1][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HB");
1768  HistNBadChsDepth[2][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HE");
1769  HistNBadChsDepth[2][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HE");
1770  HistNBadChsDepth[2][3] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth3_HE");
1771  HistNBadChsDepth[3][4] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth4_HO");
1772  HistNBadChsDepth[4][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HF");
1773  HistNBadChsDepth[4][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HF");
1774 
1775  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1776  if (sub == 1)
1777  cHB->Divide(2, 1);
1778  if (sub == 2)
1779  cHE->Divide(3, 1);
1780  if (sub == 3)
1781  cONE->Divide(1, 1);
1782  if (sub == 4)
1783  cHB->Divide(2, 1);
1784  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1785  if (sub == 1)
1786  cHB->cd(k);
1787  if (sub == 2)
1788  cHE->cd(k);
1789  if (sub == 3)
1790  cONE->cd(k - 3);
1791  if (sub == 4)
1792  cHB->cd(k);
1793  gPad->SetGridy();
1794  gPad->SetGridx();
1795  gPad->SetLogy();
1796 
1797  if (k == 1)
1798  HistNBadChsDepth[sub][k]->SetTitle("Depth 1\b");
1799  if (k == 2)
1800  HistNBadChsDepth[sub][k]->SetTitle("Depth 2\b");
1801  if (k == 3)
1802  HistNBadChsDepth[sub][k]->SetTitle("Depth 3\b");
1803  if (k == 4)
1804  HistNBadChsDepth[sub][k]->SetTitle("Depth 4\b");
1805  HistNBadChsDepth[sub][k]->SetXTitle("Number of bad channels\b");
1806  HistNBadChsDepth[sub][k]->SetYTitle("Number of events\b");
1807  // HistNBadChsDepth[sub][k]->SetMarkerStyle(20);
1808  // HistNBadChsDepth[sub][k]->SetMarkerSize(0.5);
1809  // HistNBadChsDepth[sub][k]->SetMarkerColor(1);
1810  // HistNBadChsDepth[sub][k]->SetLineColor(0);
1811  HistNBadChsDepth[sub][k]->Draw("");
1812  }
1813  if (sub == 1) {
1814  cHB->Print("HistNBadChsHB.png");
1815  cHB->Clear();
1816  }
1817  if (sub == 2) {
1818  cHE->Print("HistNBadChsHE.png");
1819  cHE->Clear();
1820  }
1821  if (sub == 3) {
1822  cONE->Print("HistNBadChsHO.png");
1823  cONE->Clear();
1824  }
1825  if (sub == 4) {
1826  cHB->Print("HistNBadChsHF.png");
1827  cHB->Clear();
1828  }
1829  } // end sub
1830 
1831  //====================================================================== HB :
1832  //====================================================================== HB :
1833  //====================================================================== HB :
1834  // Special test of errors type A and B in HB
1835  // AZ 08.02.2016
1836 
1837  int flagErrAB_HB[2];
1838  flagErrAB_HB[0] = -1;
1839  flagErrAB_HB[1] = -1;
1840  double avedelta_HB = 0.;
1841  int lastLumiBin_HB = -1;
1842  int LSofFirstErrB_HB = -1;
1843  {
1844  const int specCountA = 4;
1845  const int specColors[specCountA] = {1, 2, 3, 4};
1846  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS1_P1", "h_sum0ADCAmplperLS1_P1"},
1847  {"h_sumADCAmplperLS1_P2", "h_sum0ADCAmplperLS1_P2"},
1848  {"h_sumADCAmplperLS1_M1", "h_sum0ADCAmplperLS1_M1"},
1849  {"h_sumADCAmplperLS1_M2", "h_sum0ADCAmplperLS1_M2"}};
1850 
1851  std::vector<TH1F *> hV;
1852  THStack *hs = new THStack("hs", "ADCAmplerLS1");
1853  cHB->Clear();
1854  // cHB->cd();
1855  cHB->Divide(2, 1);
1856  cHB->cd(1);
1857 
1859  for (int i = 0; i < specCountA; i++) {
1860  if (1)
1861  std::cout << "debugger: errA_HB : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
1862  << "\n";
1863  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
1864  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
1865  if (!h1 || !h0) {
1866  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
1867  ptext->AddText("Missing histo");
1868  if (!h1) {
1869  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
1870  ptext->AddText(hnames[i][0]);
1871  }
1872  if (!h0) {
1873  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
1874  ptext->AddText(hnames[i][1]);
1875  }
1876  ptext->Draw();
1877  continue;
1878  }
1879  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
1880  hERT1orig->Divide(h1, h0, 1, 1, "B");
1881 
1882  if ((lastLumiBin_HB < 0) && (i == 0)) {
1883  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
1884  if (hERT1orig->GetBinContent(ibin) == 0)
1885  lastLumiBin_HB = ibin;
1886  else
1887  break;
1888  }
1889  lastLumiBin_HB += 3; // show more bins
1890  if (lastLumiBin_HB >= hERT1orig->GetNbinsX())
1891  lastLumiBin_HB = -1;
1892  }
1893  TH1F *hERT1 = NULL;
1894  if (lastLumiBin_HB > 1) {
1895  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HB)) {
1896  std::cout << "code failed" << std::endl;
1897  gSystem->Exit(1);
1898  }
1899  } else
1900  hERT1 = hERT1orig;
1901 
1902  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HB: black-P1, red-P2,green-M1,blue-M2");
1903  hV.push_back(hERT1);
1904  hERT1->SetMarkerStyle(20);
1905  hERT1->SetMarkerSize(0.4);
1906  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HB P1 - iLS \b");
1907  hERT1->SetMarkerColor(specColors[i]);
1908  hERT1->SetLineColor(0);
1909  hs->Add(hERT1);
1910  delete h1;
1911  delete h0;
1912  if (hERT1 != hERT1orig)
1913  delete hERT1orig;
1914  }
1915  hs->Draw("LPE1 nostack");
1916  cHB->Update(); // activate the axes
1917  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
1918  hs->Draw("LPE1 nostack");
1919  gPad->SetGridy();
1921 
1922  // AZ corrections 08.02.2016
1923  cHB->cd(2);
1924  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
1925 
1926  if (int(hV.size()) == specCountA) {
1927  flagErrAB_HB[0] = 0; // If we have the expected number of histograms, set the flag
1928  double sumdelta = 0.;
1929  int nnndelta = 0;
1930  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
1931  double delta = 0.;
1932  double maxdelta = 0.;
1933  for (unsigned int i = 0; i < hV.size(); i++) {
1934  const TH1F *hi = hV[i];
1935  for (unsigned int j = 1; j < hV.size(); j++) {
1936  const TH1F *hj = hV[j];
1937  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
1938  if (delta > maxdelta)
1939  maxdelta = delta;
1940  } //for
1941  } //for
1942  if (maxdelta > 0.) {
1943  diff->Fill(maxdelta);
1944  sumdelta += maxdelta;
1945  nnndelta++;
1946  }
1947  } //for ibin
1948  // avedelta_HB = sumdelta/hV[0]->GetNbinsX();
1949  avedelta_HB = sumdelta / nnndelta;
1950  std::cout << "******************>>>>>> ErrA_HB: avedelta_HB = " << avedelta_HB << std::endl;
1951  if (avedelta_HB > 0.24 || (avedelta_HB < 0.14 && avedelta_HB > 0.)) {
1952  flagErrAB_HB[0] = 1;
1953  } //if
1954  } //hV.size
1955  diff->SetMarkerStyle(20);
1956  diff->SetMarkerSize(0.8);
1957  diff->SetXTitle("max difference \b");
1958  diff->SetMarkerColor(2);
1959  diff->SetLineColor(0);
1960  gPad->SetGridx();
1961  gPad->SetLogy();
1962  diff->Draw("Error");
1964  cHB->Update();
1965  cHB->Print("HistErrA_HB.png");
1966  cHB->Clear();
1968 
1969  // clean-up
1970  if (diff)
1971  delete diff;
1972  for (unsigned int i = 0; i < hV.size(); i++)
1973  delete hV[i];
1974  } // ErrorA in HB
1975 
1977 
1978  { // errors type B
1979  const int specCountB = 4;
1980  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS1", "h_2D0sumErrorBLS1"},
1981  {"h_sumErrorBperLS1", "h_sum0ErrorBperLS1"},
1982  {"h_2DsumErrorBLS2", "h_2D0sumErrorBLS2"},
1983  {"h_sumErrorBperLS2", "h_sum0ErrorBperLS2"}};
1984 
1985  for (int depth = 1; depth <= 2; depth++) {
1986  cHB->Clear();
1987  cHB->Divide(2, 1);
1988  cHB->cd(1);
1989 
1990  TH1F *hRate2orig = NULL;
1991  TH2F *h2Cefz6 = NULL;
1992  TString hname1 = hnames[2 * depth - 2][0];
1993  TString hname0 = hnames[2 * depth - 2][1];
1994  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
1995  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
1996  if (1)
1997  std::cout << "debugger: errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
1998  if (!twod1 || !twod0) {
1999  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2000  ptext->AddText("Missing histos");
2001  if (!twod1) {
2002  std::cout << "\tfailed to get " << hname1 << "\n";
2003  ptext->AddText(hname1);
2004  }
2005  if (!twod0) {
2006  std::cout << "\tfailed to get " << hname0 << "\n";
2007  ptext->AddText(hname0);
2008  }
2009  ptext->Draw();
2010  } else {
2011  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2012  h2Cefz6->SetTitle(Form("HB Depth %d \b", depth));
2013  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2014 
2015  gPad->SetGridy();
2016  gPad->SetGridx();
2017  gPad->SetLogz();
2018  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2019  h2Cefz6->SetMarkerStyle(20);
2020  h2Cefz6->SetMarkerSize(0.4);
2021  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2022  h2Cefz6->SetXTitle("#eta \b");
2023  h2Cefz6->SetYTitle("#phi \b");
2024  h2Cefz6->SetZTitle(Form("<ErrorB> - HB Depth%d \b", depth));
2025  h2Cefz6->SetMarkerColor(2);
2026  h2Cefz6->SetLineColor(2);
2027  h2Cefz6->Draw("COLZ");
2028 
2029  delete twod1;
2030  delete twod0;
2031  } // histos ok
2032 
2033  cHB->cd(2);
2034  hname1 = hnames[2 * depth - 1][0];
2035  hname0 = hnames[2 * depth - 1][1];
2036  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2037  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2038  if (1)
2039  std::cout << "errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2040  if (!h1 || !h0) {
2041  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2042  ptext->AddText("Missing histo");
2043  if (!h1) {
2044  std::cout << "\tfailed to get " << hname1 << "\n";
2045  ptext->AddText(hname1);
2046  }
2047  if (!h0) {
2048  std::cout << "\tfailed to get " << hname0 << "\n";
2049  ptext->AddText(hname0);
2050  }
2051  ptext->Draw();
2052  } else {
2053  gPad->SetGridx();
2054  gPad->SetGridy();
2055  // gPad->SetLogy();
2056  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2057  hRate2orig->Divide(h1, h0, 1, 1, "B");
2058 
2059  TH1F *hRate2 = NULL;
2060  if (lastLumiBin_HB > 1) {
2061  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HB)) {
2062  std::cout << "code failed" << std::endl;
2063  gSystem->Exit(1);
2064  }
2065  } else
2066  hRate2 = hRate2orig;
2067 
2068  hRate2->SetTitle(Form("Depth %d \b", depth));
2069  hRate2->SetMarkerStyle(20);
2070  hRate2->SetMarkerSize(0.8);
2071  // hRate2->GetZaxis()->SetLabelSize(0.04);
2072  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HB depth%d - iLS \b", depth));
2073  hRate2->SetMarkerColor(2);
2074  hRate2->SetLineColor(0);
2075  hRate2->Draw("Error");
2076 
2077  if (LSofFirstErrB_HB == -1) {
2078  int nx = hRate2->GetXaxis()->GetNbins();
2079  for (int i = 1; i <= nx; i++) {
2080  double ccc1 = hRate2->GetBinContent(i);
2081  if (ccc1 > 0.) {
2082  cout << "****************>>>>>>>>>>> ErrB_HB bad LS start at iLS = " << i << " with rate = " << ccc1
2083  << endl;
2084  LSofFirstErrB_HB = i;
2085  break;
2086  }
2087  }
2088  }
2089 
2090  delete h1;
2091  delete h0;
2092  if (hRate2 != hRate2orig) {
2093  delete hRate2orig;
2094  hRate2orig = hRate2;
2095  }
2096  }
2097 
2098  cHB->Update();
2099  cHB->Print(Form("HistErrB_HB_%d.png", depth));
2100  cHB->Clear();
2101  if (h2Cefz6)
2102  delete h2Cefz6;
2103  if (hRate2orig)
2104  delete hRate2orig;
2105  }
2106  } // ErrorsB in HB
2107 
2108  //====================================================================== HE :
2109  //====================================================================== HE :
2110  //====================================================================== HE :
2111  // Special test of errors type A and B in HE
2112  // AZ 08.02.2016
2113 
2114  int flagErrAB_HE[2];
2115  flagErrAB_HE[0] = -1;
2116  flagErrAB_HE[1] = -1;
2117  double avedelta_HE = 0.;
2118  int lastLumiBin_HE = -1;
2119  int LSofFirstErrB_HE = -1;
2120  {
2121  const int specCountA = 4;
2122  const int specColors[specCountA] = {1, 2, 3, 4};
2123  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS3_P1", "h_sum0ADCAmplperLS3_P1"},
2124  {"h_sumADCAmplperLS3_P2", "h_sum0ADCAmplperLS3_P2"},
2125  {"h_sumADCAmplperLS3_M1", "h_sum0ADCAmplperLS3_M1"},
2126  {"h_sumADCAmplperLS3_M2", "h_sum0ADCAmplperLS3_M2"}};
2127 
2128  std::vector<TH1F *> hV;
2129  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2130  cHB->Clear();
2131  // cHB->cd();
2132  cHB->Divide(2, 1);
2133  cHB->cd(1);
2134 
2136  for (int i = 0; i < specCountA; i++) {
2137  if (1)
2138  std::cout << "debugger: errA_HE : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2139  << "\n";
2140  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2141  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2142  if (!h1 || !h0) {
2143  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2144  ptext->AddText("Missing histo");
2145  if (!h1) {
2146  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2147  ptext->AddText(hnames[i][0]);
2148  }
2149  if (!h0) {
2150  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2151  ptext->AddText(hnames[i][1]);
2152  }
2153  ptext->Draw();
2154  continue;
2155  }
2156  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2157  hERT1orig->Divide(h1, h0, 1, 1, "B");
2158 
2159  if ((lastLumiBin_HE < 0) && (i == 0)) {
2160  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2161  if (hERT1orig->GetBinContent(ibin) == 0)
2162  lastLumiBin_HE = ibin;
2163  else
2164  break;
2165  }
2166  lastLumiBin_HE += 3; // show more bins
2167  if (lastLumiBin_HE >= hERT1orig->GetNbinsX())
2168  lastLumiBin_HE = -1;
2169  }
2170  TH1F *hERT1 = NULL;
2171  if (lastLumiBin_HE > 1) {
2172  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HE)) {
2173  std::cout << "code failed" << std::endl;
2174  gSystem->Exit(1);
2175  }
2176  } else
2177  hERT1 = hERT1orig;
2178 
2179  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HE: black-P1, red-P2,green-M1,blue-M2");
2180  hV.push_back(hERT1);
2181  hERT1->SetMarkerStyle(20);
2182  hERT1->SetMarkerSize(0.4);
2183  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HE P1 - iLS \b");
2184  hERT1->SetMarkerColor(specColors[i]);
2185  hERT1->SetLineColor(0);
2186  hs->Add(hERT1);
2187  delete h1;
2188  delete h0;
2189  if (hERT1 != hERT1orig)
2190  delete hERT1orig;
2191  }
2192  hs->Draw("LPE1 nostack");
2193  cHB->Update(); // activate the axes
2194  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2195  hs->Draw("LPE1 nostack");
2196  gPad->SetGridy();
2198 
2199  // AZ corrections 08.02.2016
2200  cHB->cd(2);
2201  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2202 
2203  if (int(hV.size()) == specCountA) {
2204  flagErrAB_HE[0] = 0; // If we have the expected number of histograms, set the flag
2205  double sumdelta = 0.;
2206  int nnndelta = 0;
2207  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2208  double delta = 0.;
2209  double maxdelta = 0.;
2210  for (unsigned int i = 0; i < hV.size(); i++) {
2211  const TH1F *hi = hV[i];
2212  for (unsigned int j = 1; j < hV.size(); j++) {
2213  const TH1F *hj = hV[j];
2214  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2215  if (delta > maxdelta)
2216  maxdelta = delta;
2217  } //for
2218  } //for
2219  if (maxdelta > 0.) {
2220  diff->Fill(maxdelta);
2221  sumdelta += maxdelta;
2222  nnndelta++;
2223  }
2224  } //for ibin
2225  // avedelta_HE = sumdelta/hV[0]->GetNbinsX();
2226  avedelta_HE = sumdelta / nnndelta;
2227  std::cout << "******************>>>>>> ErrA_HE: avedelta_HE = " << avedelta_HE << std::endl;
2228  if (avedelta_HE > 1.1 || (avedelta_HE < 0.5 && avedelta_HE > 0.)) {
2229  flagErrAB_HE[0] = 1;
2230  } //if
2231  } //hV.size
2232  diff->SetMarkerStyle(20);
2233  diff->SetMarkerSize(0.8);
2234  diff->SetXTitle("max difference \b");
2235  diff->SetMarkerColor(2);
2236  diff->SetLineColor(0);
2237  gPad->SetGridx();
2238  gPad->SetLogy();
2239  diff->Draw("Error");
2241  cHB->Update();
2242  cHB->Print("HistErrA_HE.png");
2243  cHB->Clear();
2245 
2246  // clean-up
2247  if (diff)
2248  delete diff;
2249  for (unsigned int i = 0; i < hV.size(); i++)
2250  delete hV[i];
2251  } // ErrorA in HE
2252 
2254 
2255  { // errors type B
2256  const int specCountB = 6;
2257  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS3", "h_2D0sumErrorBLS3"},
2258  {"h_sumErrorBperLS3", "h_sum0ErrorBperLS3"},
2259  {"h_2DsumErrorBLS4", "h_2D0sumErrorBLS4"},
2260  {"h_sumErrorBperLS4", "h_sum0ErrorBperLS4"},
2261  {"h_2DsumErrorBLS5", "h_2D0sumErrorBLS5"},
2262  {"h_sumErrorBperLS5", "h_sum0ErrorBperLS5"}};
2263 
2264  for (int depth = 1; depth <= 3; depth++) {
2265  cHB->Clear();
2266  cHB->Divide(2, 1);
2267  cHB->cd(1);
2268 
2269  TH1F *hRate2orig = NULL;
2270  TH2F *h2Cefz6 = NULL;
2271  TString hname1 = hnames[2 * depth - 2][0];
2272  TString hname0 = hnames[2 * depth - 2][1];
2273  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2274  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2275  if (1)
2276  std::cout << "debugger: errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2277  if (!twod1 || !twod0) {
2278  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2279  ptext->AddText("Missing histos");
2280  if (!twod1) {
2281  std::cout << "\tfailed to get " << hname1 << "\n";
2282  ptext->AddText(hname1);
2283  }
2284  if (!twod0) {
2285  std::cout << "\tfailed to get " << hname0 << "\n";
2286  ptext->AddText(hname0);
2287  }
2288  ptext->Draw();
2289  } else {
2290  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2291  h2Cefz6->SetTitle(Form("HE Depth %d \b", depth));
2292  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2293 
2294  gPad->SetGridy();
2295  gPad->SetGridx();
2296  gPad->SetLogz();
2297  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2298  h2Cefz6->SetMarkerStyle(20);
2299  h2Cefz6->SetMarkerSize(0.4);
2300  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2301  h2Cefz6->SetXTitle("#eta \b");
2302  h2Cefz6->SetYTitle("#phi \b");
2303  h2Cefz6->SetZTitle(Form("<ErrorB> - HE Depth%d \b", depth));
2304  h2Cefz6->SetMarkerColor(2);
2305  h2Cefz6->SetLineColor(2);
2306  h2Cefz6->Draw("COLZ");
2307 
2308  delete twod1;
2309  delete twod0;
2310  } // histos ok
2311 
2312  cHB->cd(2);
2313  hname1 = hnames[2 * depth - 1][0];
2314  hname0 = hnames[2 * depth - 1][1];
2315  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2316  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2317  if (1)
2318  std::cout << "errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2319  if (!h1 || !h0) {
2320  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2321  ptext->AddText("Missing histo");
2322  if (!h1) {
2323  std::cout << "\tfailed to get " << hname1 << "\n";
2324  ptext->AddText(hname1);
2325  }
2326  if (!h0) {
2327  std::cout << "\tfailed to get " << hname0 << "\n";
2328  ptext->AddText(hname0);
2329  }
2330  ptext->Draw();
2331  } else {
2332  gPad->SetGridx();
2333  gPad->SetGridy();
2334  // gPad->SetLogy();
2335  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2336  hRate2orig->Divide(h1, h0, 1, 1, "B");
2337 
2338  TH1F *hRate2 = NULL;
2339  if (lastLumiBin_HE > 1) {
2340  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HE)) {
2341  std::cout << "code failed" << std::endl;
2342  gSystem->Exit(1);
2343  }
2344  } else
2345  hRate2 = hRate2orig;
2346 
2347  hRate2->SetTitle(Form("Depth %d \b", depth));
2348  hRate2->SetMarkerStyle(20);
2349  hRate2->SetMarkerSize(0.8);
2350  // hRate2->GetZaxis()->SetLabelSize(0.04);
2351  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HE depth%d - iLS \b", depth));
2352  hRate2->SetMarkerColor(2);
2353  hRate2->SetLineColor(0);
2354  hRate2->Draw("Error");
2355 
2356  if (LSofFirstErrB_HE == -1) {
2357  int nx = hRate2->GetXaxis()->GetNbins();
2358  for (int i = 1; i <= nx; i++) {
2359  double ccc1 = hRate2->GetBinContent(i);
2360  if (ccc1 > 0.) {
2361  cout << "****************>>>>>>>>>>> ErrB_HE bad LS start at iLS = " << i << " with rate = " << ccc1
2362  << endl;
2363  LSofFirstErrB_HE = i;
2364  break;
2365  }
2366  }
2367  }
2368 
2369  delete h1;
2370  delete h0;
2371  if (hRate2 != hRate2orig) {
2372  delete hRate2orig;
2373  hRate2orig = hRate2;
2374  }
2375  }
2376 
2377  cHB->Update();
2378  cHB->Print(Form("HistErrB_HE_%d.png", depth));
2379  cHB->Clear();
2380  if (h2Cefz6)
2381  delete h2Cefz6;
2382  if (hRate2orig)
2383  delete hRate2orig;
2384  }
2385  } // ErrorsB in HE
2386 
2387  //====================================================================== HO :
2388  //====================================================================== HO :
2389  //====================================================================== HO :
2390  // Special test of errors type A and B in HO
2391  // AZ 08.02.2016
2392 
2393  int flagErrAB_HO[2];
2394  flagErrAB_HO[0] = -1;
2395  flagErrAB_HO[1] = -1;
2396  double avedelta_HO = 0.;
2397  int lastLumiBin_HO = -1;
2398  int LSofFirstErrB_HO = -1;
2399  {
2400  const int specCountA = 4;
2401  const int specColors[specCountA] = {1, 2, 3, 4};
2402  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS8_P1", "h_sum0ADCAmplperLS8_P1"},
2403  {"h_sumADCAmplperLS8_P2", "h_sum0ADCAmplperLS8_P2"},
2404  {"h_sumADCAmplperLS8_M1", "h_sum0ADCAmplperLS8_M1"},
2405  {"h_sumADCAmplperLS8_M2", "h_sum0ADCAmplperLS8_M2"}};
2406 
2407  std::vector<TH1F *> hV;
2408  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2409  cHB->Clear();
2410  // cHB->cd();
2411  cHB->Divide(2, 1);
2412  cHB->cd(1);
2413 
2415  for (int i = 0; i < specCountA; i++) {
2416  if (1)
2417  std::cout << "debugger: errA_HO : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2418  << "\n";
2419  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2420  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2421  if (!h1 || !h0) {
2422  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2423  ptext->AddText("Missing histo");
2424  if (!h1) {
2425  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2426  ptext->AddText(hnames[i][0]);
2427  }
2428  if (!h0) {
2429  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2430  ptext->AddText(hnames[i][1]);
2431  }
2432  ptext->Draw();
2433  continue;
2434  }
2435  TH1F *hoRT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2436  hoRT1orig->Divide(h1, h0, 1, 1, "B");
2437 
2438  if ((lastLumiBin_HO < 0) && (i == 0)) {
2439  for (int ibin = hoRT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2440  if (hoRT1orig->GetBinContent(ibin) == 0)
2441  lastLumiBin_HO = ibin;
2442  else
2443  break;
2444  }
2445  lastLumiBin_HO += 3; // show more bins
2446  if (lastLumiBin_HO >= hoRT1orig->GetNbinsX())
2447  lastLumiBin_HO = -1;
2448  }
2449  TH1F *hoRT1 = NULL;
2450  if (lastLumiBin_HO > 1) {
2451  if (!copyContents(&hoRT1, Form("ERT1_%d", i), "", hoRT1orig, lastLumiBin_HO)) {
2452  std::cout << "code failed" << std::endl;
2453  gSystem->Exit(1);
2454  }
2455  } else
2456  hoRT1 = hoRT1orig;
2457 
2458  hoRT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HO: black-P1, red-P2,green-M1,blue-M2");
2459  hV.push_back(hoRT1);
2460  hoRT1->SetMarkerStyle(20);
2461  hoRT1->SetMarkerSize(0.4);
2462  hoRT1->SetXTitle("<A>(ev.in LS & ch.) - HO P1 - iLS \b");
2463  hoRT1->SetMarkerColor(specColors[i]);
2464  hoRT1->SetLineColor(0);
2465  hs->Add(hoRT1);
2466  delete h1;
2467  delete h0;
2468  if (hoRT1 != hoRT1orig)
2469  delete hoRT1orig;
2470  }
2471  hs->Draw("LPE1 nostack");
2472  cHB->Update(); // activate tho axes
2473  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2474  hs->Draw("LPE1 nostack");
2475  gPad->SetGridy();
2477 
2478  // AZ corrections 08.02.2016
2479  cHB->cd(2);
2480  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2481 
2482  if (int(hV.size()) == specCountA) {
2483  flagErrAB_HO[0] = 0; // If we have tho expected number of histograms, set tho flag
2484  double sumdelta = 0.;
2485  int nnndelta = 0;
2486  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2487  double delta = 0.;
2488  double maxdelta = 0.;
2489  for (unsigned int i = 0; i < hV.size(); i++) {
2490  const TH1F *hi = hV[i];
2491  for (unsigned int j = 1; j < hV.size(); j++) {
2492  const TH1F *hj = hV[j];
2493  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2494  if (delta > maxdelta)
2495  maxdelta = delta;
2496  } //for
2497  } //for
2498  if (maxdelta > 0.) {
2499  diff->Fill(maxdelta);
2500  sumdelta += maxdelta;
2501  nnndelta++;
2502  }
2503  } //for ibin
2504  // avedelta_HO = sumdelta/hV[0]->GetNbinsX();
2505  avedelta_HO = sumdelta / nnndelta;
2506  std::cout << "******************>>>>>> ErrA_HO: avedelta_HO = " << avedelta_HO << std::endl;
2507  if (avedelta_HO > 0.8 || (avedelta_HO < 0.2 && avedelta_HO > 0.)) {
2508  flagErrAB_HO[0] = 1;
2509  } //if
2510  } //hV.size
2511  diff->SetMarkerStyle(20);
2512  diff->SetMarkerSize(0.8);
2513  diff->SetXTitle("max difference \b");
2514  diff->SetMarkerColor(2);
2515  diff->SetLineColor(0);
2516  gPad->SetGridx();
2517  gPad->SetLogy();
2518  diff->Draw("Error");
2520  cHB->Update();
2521  cHB->Print("HistErrA_HO.png");
2522  cHB->Clear();
2524 
2525  // clean-up
2526  if (diff)
2527  delete diff;
2528  for (unsigned int i = 0; i < hV.size(); i++)
2529  delete hV[i];
2530  } // ErrorA in HO
2531 
2533 
2534  { // errors type B
2535  const int specCountB = 2;
2536  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS8", "h_2D0sumErrorBLS8"},
2537  {"h_sumErrorBperLS8", "h_sum0ErrorBperLS8"}};
2538 
2539  for (int depth = 4; depth <= 4; depth++) {
2540  cHB->Clear();
2541  cHB->Divide(2, 1);
2542  cHB->cd(1);
2543 
2544  TH1F *hRate2orig = NULL;
2545  TH2F *h2Cefz6 = NULL;
2546  TString hname1 = hnames[2 * depth - 8][0];
2547  TString hname0 = hnames[2 * depth - 8][1];
2548  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2549  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2550  if (1)
2551  std::cout << "debugger: errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2552  if (!twod1 || !twod0) {
2553  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2554  ptext->AddText("Missing histos");
2555  if (!twod1) {
2556  std::cout << "\tfailed to get " << hname1 << "\n";
2557  ptext->AddText(hname1);
2558  }
2559  if (!twod0) {
2560  std::cout << "\tfailed to get " << hname0 << "\n";
2561  ptext->AddText(hname0);
2562  }
2563  ptext->Draw();
2564  } else {
2565  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2566  h2Cefz6->SetTitle(Form("HO Depth %d \b", depth));
2567  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2568 
2569  gPad->SetGridy();
2570  gPad->SetGridx();
2571  gPad->SetLogz();
2572  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2573  h2Cefz6->SetMarkerStyle(20);
2574  h2Cefz6->SetMarkerSize(0.4);
2575  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2576  h2Cefz6->SetXTitle("#eta \b");
2577  h2Cefz6->SetYTitle("#phi \b");
2578  h2Cefz6->SetZTitle(Form("<ErrorB> - HO Depth%d \b", depth));
2579  h2Cefz6->SetMarkerColor(2);
2580  h2Cefz6->SetLineColor(2);
2581  h2Cefz6->Draw("COLZ");
2582 
2583  delete twod1;
2584  delete twod0;
2585  } // histos ok
2586 
2587  cHB->cd(2);
2588  hname1 = hnames[2 * depth - 7][0];
2589  hname0 = hnames[2 * depth - 7][1];
2590  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2591  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2592  if (1)
2593  std::cout << "errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2594  if (!h1 || !h0) {
2595  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2596  ptext->AddText("Missing histo");
2597  if (!h1) {
2598  std::cout << "\tfailed to get " << hname1 << "\n";
2599  ptext->AddText(hname1);
2600  }
2601  if (!h0) {
2602  std::cout << "\tfailed to get " << hname0 << "\n";
2603  ptext->AddText(hname0);
2604  }
2605  ptext->Draw();
2606  } else {
2607  gPad->SetGridx();
2608  gPad->SetGridy();
2609  // gPad->SetLogy();
2610  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2611  hRate2orig->Divide(h1, h0, 1, 1, "B");
2612 
2613  TH1F *hRate2 = NULL;
2614  if (lastLumiBin_HO > 1) {
2615  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HO)) {
2616  std::cout << "code failed" << std::endl;
2617  gSystem->Exit(1);
2618  }
2619  } else
2620  hRate2 = hRate2orig;
2621 
2622  hRate2->SetTitle(Form("Depth %d \b", depth));
2623  hRate2->SetMarkerStyle(20);
2624  hRate2->SetMarkerSize(0.8);
2625  // hRate2->GetZaxis()->SetLabelSize(0.04);
2626  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HO depth%d - iLS \b", depth));
2627  hRate2->SetMarkerColor(2);
2628  hRate2->SetLineColor(0);
2629  hRate2->Draw("Error");
2630 
2631  if (LSofFirstErrB_HO == -1) {
2632  int nx = hRate2->GetXaxis()->GetNbins();
2633  for (int i = 1; i <= nx; i++) {
2634  double ccc1 = hRate2->GetBinContent(i);
2635  if (ccc1 > 0.) {
2636  cout << "****************>>>>>>>>>>> ErrB_HO bad LS start at iLS = " << i << " with rate = " << ccc1
2637  << endl;
2638  LSofFirstErrB_HO = i;
2639  break;
2640  }
2641  }
2642  }
2643 
2644  delete h1;
2645  delete h0;
2646  if (hRate2 != hRate2orig) {
2647  delete hRate2orig;
2648  hRate2orig = hRate2;
2649  }
2650  }
2651 
2652  cHB->Update();
2653  cHB->Print(Form("HistErrB_HO_%d.png", depth));
2654  cHB->Clear();
2655  if (h2Cefz6)
2656  delete h2Cefz6;
2657  if (hRate2orig)
2658  delete hRate2orig;
2659  }
2660  } // ErrorsB in HO
2661 
2662  //====================================================================== done by Andrius for HF:
2663  //====================================================================== done by Andrius for HF:
2664  //====================================================================== done by Andrius for HF:
2665  // Special test of errors type A and B in HF
2666 
2667  int flagErrAB_HF[2];
2668  flagErrAB_HF[0] = -1;
2669  flagErrAB_HF[1] = -1;
2670  double avedelta_HF = 0.;
2671  int lastLumiBin_HF = -1;
2672  int LSofFirstErrB_HF = -1;
2673  {
2674  const int specCountA = 4;
2675  const int specColors[specCountA] = {1, 2, 3, 4};
2676  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS6_P1", "h_sum0ADCAmplperLS6_P1"},
2677  {"h_sumADCAmplperLS6_P2", "h_sum0ADCAmplperLS6_P2"},
2678  {"h_sumADCAmplperLS6_M1", "h_sum0ADCAmplperLS6_M1"},
2679  {"h_sumADCAmplperLS6_M2", "h_sum0ADCAmplperLS6_M2"}};
2680 
2681  std::vector<TH1F *> hV;
2682  THStack *hs = new THStack("hs", "ADCAmplerLS6");
2683  cHB->Clear();
2684  // cHB->cd();
2685  cHB->Divide(2, 1);
2686  cHB->cd(1);
2687 
2689  for (int i = 0; i < specCountA; i++) {
2690  if (1)
2691  std::cout << "debugger: errA_HF : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2692  << "\n";
2693  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2694  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2695  if (!h1 || !h0) {
2696  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2697  ptext->AddText("Missing histo");
2698  if (!h1) {
2699  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2700  ptext->AddText(hnames[i][0]);
2701  }
2702  if (!h0) {
2703  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2704  ptext->AddText(hnames[i][1]);
2705  }
2706  ptext->Draw();
2707  continue;
2708  }
2709  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2710  hERT1orig->Divide(h1, h0, 1, 1, "B");
2711 
2712  if ((lastLumiBin_HF < 0) && (i == 0)) {
2713  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2714  if (hERT1orig->GetBinContent(ibin) == 0)
2715  lastLumiBin_HF = ibin;
2716  else
2717  break;
2718  }
2719  lastLumiBin_HF += 3; // show more bins
2720  if (lastLumiBin_HF >= hERT1orig->GetNbinsX())
2721  lastLumiBin_HF = -1;
2722  }
2723  TH1F *hERT1 = NULL;
2724  if (lastLumiBin_HF > 1) {
2725  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HF)) {
2726  std::cout << "code failed" << std::endl;
2727  gSystem->Exit(1);
2728  }
2729  } else
2730  hERT1 = hERT1orig;
2731 
2732  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HF: black-P1, red-P2,green-M1,blue-M2");
2733  hV.push_back(hERT1);
2734  hERT1->SetMarkerStyle(20);
2735  hERT1->SetMarkerSize(0.4);
2736  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HF P1 - iLS \b");
2737  hERT1->SetMarkerColor(specColors[i]);
2738  hERT1->SetLineColor(0);
2739  hs->Add(hERT1);
2740  delete h1;
2741  delete h0;
2742  if (hERT1 != hERT1orig)
2743  delete hERT1orig;
2744  }
2745  hs->Draw("LPE1 nostack");
2746  cHB->Update(); // activate the axes
2747  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2748  hs->Draw("LPE1 nostack");
2749  gPad->SetGridy();
2751 
2752  // AZ corrections 04.02.2016
2753  cHB->cd(2);
2754  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2755 
2756  if (int(hV.size()) == specCountA) {
2757  flagErrAB_HF[0] = 0; // If we have the expected number of histograms, set the flag
2758  double sumdelta = 0.;
2759  int nnndelta = 0;
2760  std::cout << "******** GetNbinsX = " << hV[0]->GetNbinsX() << std::endl;
2761  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2762  double delta = 0.;
2763  double maxdelta = 0.;
2764  for (unsigned int i = 0; i < hV.size(); i++) {
2765  const TH1F *hi = hV[i];
2766  for (unsigned int j = 1; j < hV.size(); j++) {
2767  const TH1F *hj = hV[j];
2768  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2769  if (delta > maxdelta)
2770  maxdelta = delta;
2771  } //for
2772  } //for
2773  // std::cout << "***** ibin = " << ibin << " nnndelta= " << nnndelta << " maxdelta= " << maxdelta <<std::endl;
2774  if (maxdelta > 0.) {
2775  diff->Fill(maxdelta);
2776  sumdelta += maxdelta;
2777  nnndelta++;
2778  }
2779  } //for ibin
2780  // avedelta_HF = sumdelta/hV[0]->GetNbinsX();
2781  avedelta_HF = sumdelta / nnndelta;
2782  // std::cout << "******************>>>>>> ErrA_HF: avedelta_HF = " << avedelta_HF << " Npoints for comparison= " << nnndelta <<std::endl;
2783  if (avedelta_HF > 2.4 || (avedelta_HF < 0.8 && avedelta_HF > 0.)) {
2784  flagErrAB_HF[0] = 1;
2785  } //if
2786  } //hV.size
2787  diff->SetMarkerStyle(20);
2788  diff->SetMarkerSize(0.8);
2789  diff->SetXTitle("max difference \b");
2790  diff->SetMarkerColor(2);
2791  diff->SetLineColor(0);
2792  gPad->SetGridx();
2793  gPad->SetLogy();
2794  diff->Draw("Error");
2796  cHB->Update();
2797  cHB->Print("HistErrA_HF.png");
2798  cHB->Clear();
2800  // clean-up
2801  if (diff)
2802  delete diff;
2803  for (unsigned int i = 0; i < hV.size(); i++)
2804  delete hV[i];
2805  } // ErrorA in HF
2808  { // errors type B
2809  const int specCountB = 4;
2810  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS6", "h_2D0sumErrorBLS6"},
2811  {"h_sumErrorBperLS6", "h_sum0ErrorBperLS6"},
2812  {"h_2DsumErrorBLS7", "h_2D0sumErrorBLS7"},
2813  {"h_sumErrorBperLS7", "h_sum0ErrorBperLS7"}};
2814 
2815  for (int depth = 1; depth <= 2; depth++) {
2816  cHB->Clear();
2817  cHB->Divide(2, 1);
2818  cHB->cd(1);
2819  TH1F *hRate2orig = NULL;
2820  TH2F *h2Cefz6 = NULL;
2821  TString hname1 = hnames[2 * depth - 2][0];
2822  TString hname0 = hnames[2 * depth - 2][1];
2823  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2824  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2825  if (1)
2826  std::cout << "debugger: errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2827  if (!twod1 || !twod0) {
2828  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2829  ptext->AddText("Missing histos");
2830  if (!twod1) {
2831  std::cout << "\tfailed to get " << hname1 << "\n";
2832  ptext->AddText(hname1);
2833  }
2834  if (!twod0) {
2835  std::cout << "\tfailed to get " << hname0 << "\n";
2836  ptext->AddText(hname0);
2837  }
2838  ptext->Draw();
2839  } else {
2840  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2841  h2Cefz6->SetTitle(Form("HF Depth %d \b", depth));
2842  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2843 
2844  gPad->SetGridy();
2845  gPad->SetGridx();
2846  gPad->SetLogz();
2847  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2848  h2Cefz6->SetMarkerStyle(20);
2849  h2Cefz6->SetMarkerSize(0.4);
2850  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2851  h2Cefz6->SetXTitle("#eta \b");
2852  h2Cefz6->SetYTitle("#phi \b");
2853  h2Cefz6->SetZTitle(Form("<ErrorB> - HF Depth%d \b", depth));
2854  h2Cefz6->SetMarkerColor(2);
2855  h2Cefz6->SetLineColor(2);
2856  h2Cefz6->Draw("COLZ");
2857  delete twod1;
2858  delete twod0;
2859  } // histos ok
2860  cHB->cd(2);
2861  hname1 = hnames[2 * depth - 1][0];
2862  hname0 = hnames[2 * depth - 1][1];
2863  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2864  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2865  if (1)
2866  std::cout << "errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2867  if (!h1 || !h0) {
2868  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2869  ptext->AddText("Missing histo");
2870  if (!h1) {
2871  std::cout << "\tfailed to get " << hname1 << "\n";
2872  ptext->AddText(hname1);
2873  }
2874  if (!h0) {
2875  std::cout << "\tfailed to get " << hname0 << "\n";
2876  ptext->AddText(hname0);
2877  }
2878  ptext->Draw();
2879  } else {
2880  gPad->SetGridx();
2881  gPad->SetGridy();
2882  // gPad->SetLogy();
2883  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2884  hRate2orig->Divide(h1, h0, 1, 1, "B");
2885 
2886  TH1F *hRate2 = NULL;
2887  if (lastLumiBin_HF > 1) {
2888  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HF)) {
2889  std::cout << "code failed" << std::endl;
2890  gSystem->Exit(1);
2891  }
2892  } else
2893  hRate2 = hRate2orig;
2894  hRate2->SetTitle(Form("Depth %d \b", depth));
2895  hRate2->SetMarkerStyle(20);
2896  hRate2->SetMarkerSize(0.8);
2897  // hRate2->GetZaxis()->SetLabelSize(0.04);
2898  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HF depth%d - iLS \b", depth));
2899  hRate2->SetMarkerColor(2);
2900  hRate2->SetLineColor(0);
2901  hRate2->Draw("Error");
2902  if (LSofFirstErrB_HF == -1) {
2903  int nx = hRate2->GetXaxis()->GetNbins();
2904  for (int i = 1; i <= nx; i++) {
2905  double ccc1 = hRate2->GetBinContent(i);
2906  if (ccc1 > 0.) {
2907  cout << "****************>>>>>>>>>>> ErrB_HF bad LS start at iLS = " << i << " with rate = " << ccc1
2908  << endl;
2909  LSofFirstErrB_HF = i;
2910  break;
2911  }
2912  }
2913  }
2914  delete h1;
2915  delete h0;
2916  if (hRate2 != hRate2orig) {
2917  delete hRate2orig;
2918  hRate2orig = hRate2;
2919  }
2920  }
2921  cHB->Update();
2922  cHB->Print(Form("HistErrB_HF_%d.png", depth));
2923  cHB->Clear();
2924  if (h2Cefz6)
2925  delete h2Cefz6;
2926  if (hRate2orig)
2927  delete hRate2orig;
2928  }
2929  } // ErrorsB in HF
2930 
2932 
2933  //=============================================================================== err A HB
2935  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HBx.png
2936 
2937  for (int depth = 1; depth <= 2; depth++) {
2938  TH2F *h2Ceff = NULL;
2939  TH2F *h2Diffe = NULL;
2940  // TH1F* h1diffADCAmpl= NULL;
2941  TH2F *h3Ceff = NULL;
2942 
2943  cHE->Clear();
2944  cHE->Divide(3, 1);
2945 
2946  cHE->cd(1);
2947  // h_mapDepth1ADCAmpl_HB div h_mapDepth1_HB
2948  TString hname1 = Form("h_mapDepth%dADCAmpl_HB", depth);
2949  TString hname0 = Form("h_mapDepth%d_HB", depth);
2950  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2951  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2952  if (!twod1 || !twod0) {
2953  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2954  ptext->AddText("Missing histo");
2955  std::cout << "specHB test: failed to load " << hname1 << " and/or " << hname0 << "\n";
2956  if (!twod1)
2957  ptext->AddText(hname1);
2958  if (!twod0)
2959  ptext->AddText(hname0);
2960  ptext->Draw();
2961  continue;
2962  } else {
2963  // To IDENTIFY: see color different bins in eta-phi space
2964  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HB%d", depth));
2965  h2Ceff->SetTitle(Form("HB Depth %d. (No cut) \b", depth));
2966  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
2967 
2968  gPad->SetGridy();
2969  gPad->SetGridx();
2970  gPad->SetLogz();
2971  h2Ceff->SetMarkerStyle(20);
2972  h2Ceff->SetMarkerSize(0.4);
2973  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
2974  h2Ceff->SetXTitle("#eta \b");
2975  h2Ceff->SetYTitle("#phi \b");
2976  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HB \b");
2977  h2Ceff->SetMarkerColor(2);
2978  h2Ceff->SetLineColor(2);
2979  h2Ceff->Draw("COLZ");
2980  }
2981 
2982  cHE->cd(2);
2984  if (h2Ceff) {
2985  // TO IDENTIFY: see red bins in eta-phi space
2986  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HB", depth));
2987  h2Diffe->SetTitle(Form("HB Depth %d. Cut avg(ADCAmpl) > 25 \b", depth));
2988  int nx = h2Ceff->GetXaxis()->GetNbins();
2989  int ny = h2Ceff->GetYaxis()->GetNbins();
2990  for (int i = 1; i <= nx; i++) {
2991  for (int j = 1; j <= ny; j++) {
2992  double ccc1 = h2Ceff->GetBinContent(i, j);
2993  h2Diffe->SetBinContent(i, j, 0.);
2994  if (ccc1 > 25.)
2995  h2Diffe->SetBinContent(i, j, ccc1);
2996  }
2997  }
2998  gPad->SetGridy();
2999  gPad->SetGridx();
3000  gPad->SetLogz();
3001  h2Diffe->SetMarkerStyle(20);
3002  h2Diffe->SetMarkerSize(0.4);
3003  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3004  h2Diffe->SetXTitle("#eta \b");
3005  h2Diffe->SetYTitle("#phi \b");
3006  h2Diffe->SetZTitle("<ADCAmpl> bigger 25.- HB Depth1 \b");
3007  h2Diffe->SetMarkerColor(2);
3008  h2Diffe->SetLineColor(2);
3009  h2Diffe->Draw("COLZ");
3010  }
3011 
3012  cHE->cd(3);
3013  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HB", depth);
3014  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3015  if (!twod3 || !twod0) {
3016  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3017  ptext->AddText("Missing histo");
3018  std::cout << "specHB test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3019  if (!twod3)
3020  ptext->AddText(hname3);
3021  if (!twod0)
3022  ptext->AddText(hname0);
3023  ptext->Draw();
3024  continue;
3025  } else {
3026  // To IDENTIFY: see color different bins in eta-phi space
3027  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HB%d", depth));
3028  h3Ceff->SetTitle(Form("HB Depth %d. \b", depth));
3029  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3030  gPad->SetGridy();
3031  gPad->SetGridx();
3032  gPad->SetLogz();
3033  h3Ceff->SetMarkerStyle(20);
3034  h3Ceff->SetMarkerSize(0.4);
3035  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3036  h3Ceff->SetXTitle("#eta \b");
3037  h3Ceff->SetYTitle("#phi \b");
3038  h3Ceff->SetZTitle("rate for channels of HB \b");
3039  h3Ceff->SetMarkerColor(2);
3040  h3Ceff->SetLineColor(2);
3041  h3Ceff->Draw("COLZ");
3042  }
3043 
3044  cHE->Update();
3045  cHE->Print(Form("ChkErrA_HB%d.png", depth));
3046  cHE->Clear();
3047 
3048  if (h2Ceff)
3049  delete h2Ceff;
3050  if (h2Diffe)
3051  delete h2Diffe;
3052  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3053  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3054  if (twod1)
3055  delete twod1;
3056  if (twod3)
3057  delete twod3;
3058  if (h3Ceff)
3059  delete h3Ceff;
3060  } // depth
3061 
3062  //=============================================================================== err A HE
3064  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HEx.png
3065 
3066  for (int depth = 1; depth <= 3; depth++) {
3067  TH2F *h2Ceff = NULL;
3068  TH2F *h2Diffe = NULL;
3069  // TH1F* h1diffADCAmpl= NULL;
3070  TH2F *h3Ceff = NULL;
3071 
3072  cHE->Clear();
3073  cHE->Divide(3, 1);
3074 
3075  cHE->cd(1);
3076  // h_mapDepth1ADCAmpl_HE div h_mapDepth1_HE
3077  TString hname1 = Form("h_mapDepth%dADCAmpl_HE", depth);
3078  TString hname0 = Form("h_mapDepth%d_HE", depth);
3079  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3080  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3081  if (!twod1 || !twod0) {
3082  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3083  ptext->AddText("Missing histo");
3084  std::cout << "specHE test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3085  if (!twod1)
3086  ptext->AddText(hname1);
3087  if (!twod0)
3088  ptext->AddText(hname0);
3089  ptext->Draw();
3090  continue;
3091  } else {
3092  // To IDENTIFY: see color different bins in eta-phi space
3093  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HE%d", depth));
3094  h2Ceff->SetTitle(Form("HE Depth %d. (No cut) \b", depth));
3095  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3096 
3097  gPad->SetGridy();
3098  gPad->SetGridx();
3099  gPad->SetLogz();
3100  h2Ceff->SetMarkerStyle(20);
3101  h2Ceff->SetMarkerSize(0.4);
3102  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3103  h2Ceff->SetXTitle("#eta \b");
3104  h2Ceff->SetYTitle("#phi \b");
3105  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HE \b");
3106  h2Ceff->SetMarkerColor(2);
3107  h2Ceff->SetLineColor(2);
3108  h2Ceff->Draw("COLZ");
3109  }
3110 
3111  cHE->cd(2);
3113  if (h2Ceff) {
3114  // TO IDENTIFY: see red bins in eta-phi space
3115  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HE", depth));
3116  h2Diffe->SetTitle(Form("HE Depth %d. Cut avg(ADCAmpl) > 1000 fC \b", depth));
3117  int nx = h2Ceff->GetXaxis()->GetNbins();
3118  int ny = h2Ceff->GetYaxis()->GetNbins();
3119  for (int i = 1; i <= nx; i++) {
3120  for (int j = 1; j <= ny; j++) {
3121  double ccc1 = h2Ceff->GetBinContent(i, j);
3122  h2Diffe->SetBinContent(i, j, 0.);
3123  if (ccc1 > 1000.)
3124  h2Diffe->SetBinContent(i, j, ccc1);
3125  }
3126  }
3127  gPad->SetGridy();
3128  gPad->SetGridx();
3129  gPad->SetLogz();
3130  h2Diffe->SetMarkerStyle(20);
3131  h2Diffe->SetMarkerSize(0.4);
3132  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3133  h2Diffe->SetXTitle("#eta \b");
3134  h2Diffe->SetYTitle("#phi \b");
3135  h2Diffe->SetZTitle("<ADCAmpl> bigger 1000.fC - HE Depth1 \b");
3136  h2Diffe->SetMarkerColor(2);
3137  h2Diffe->SetLineColor(2);
3138  h2Diffe->Draw("COLZ");
3139  }
3140 
3141  cHE->cd(3);
3142  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HE", depth);
3143  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3144  if (!twod3 || !twod0) {
3145  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3146  ptext->AddText("Missing histo");
3147  std::cout << "specHE test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3148  if (!twod3)
3149  ptext->AddText(hname3);
3150  if (!twod0)
3151  ptext->AddText(hname0);
3152  ptext->Draw();
3153  continue;
3154  } else {
3155  // To IDENTIFY: see color different bins in eta-phi space
3156  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HE%d", depth));
3157  h3Ceff->SetTitle(Form("HE Depth %d. \b", depth));
3158  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3159  gPad->SetGridy();
3160  gPad->SetGridx();
3161  gPad->SetLogz();
3162  h3Ceff->SetMarkerStyle(20);
3163  h3Ceff->SetMarkerSize(0.4);
3164  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3165  h3Ceff->SetXTitle("#eta \b");
3166  h3Ceff->SetYTitle("#phi \b");
3167  h3Ceff->SetZTitle("rate for channels of HE \b");
3168  h3Ceff->SetMarkerColor(2);
3169  h3Ceff->SetLineColor(2);
3170  h3Ceff->Draw("COLZ");
3171  }
3172 
3173  cHE->Update();
3174  cHE->Print(Form("ChkErrA_HE%d.png", depth));
3175  cHE->Clear();
3176 
3177  if (h2Ceff)
3178  delete h2Ceff;
3179  if (h2Diffe)
3180  delete h2Diffe;
3181  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3182  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3183  if (twod1)
3184  delete twod1;
3185  if (twod3)
3186  delete twod3;
3187  if (h3Ceff)
3188  delete h3Ceff;
3189  } // depth
3190 
3191  //=============================================================================== err A HO
3193  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HOx.png
3194 
3195  for (int depth = 4; depth <= 4; depth++) {
3196  TH2F *h2Ceff = NULL;
3197  TH2F *h2Diffe = NULL;
3198  // TH1F* h1diffADCAmpl= NULL;
3199  TH2F *h3Ceff = NULL;
3200 
3201  cHE->Clear();
3202  cHE->Divide(3, 1);
3203 
3204  cHE->cd(1);
3205  // h_mapDepth1ADCAmpl_HO div h_mapDepth1_HO
3206  TString hname1 = Form("h_mapDepth%dADCAmpl_HO", depth);
3207  TString hname0 = Form("h_mapDepth%d_HO", depth);
3208  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3209  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3210  if (!twod1 || !twod0) {
3211  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3212  ptext->AddText("Missing histo");
3213  std::cout << "specHO test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3214  if (!twod1)
3215  ptext->AddText(hname1);
3216  if (!twod0)
3217  ptext->AddText(hname0);
3218  ptext->Draw();
3219  continue;
3220  } else {
3221  // To IDENTIFY: see color different bins in eta-phi space
3222  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HO%d", depth));
3223  h2Ceff->SetTitle(Form("HO Depth %d. (No cut) \b", depth));
3224  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3225 
3226  gPad->SetGridy();
3227  gPad->SetGridx();
3228  gPad->SetLogz();
3229  h2Ceff->SetMarkerStyle(20);
3230  h2Ceff->SetMarkerSize(0.4);
3231  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3232  h2Ceff->SetXTitle("#eta \b");
3233  h2Ceff->SetYTitle("#phi \b");
3234  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HO \b");
3235  h2Ceff->SetMarkerColor(2);
3236  h2Ceff->SetLineColor(2);
3237  h2Ceff->Draw("COLZ");
3238  }
3239 
3240  cHE->cd(2);
3242  if (h2Ceff) {
3243  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3244  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HO", depth));
3245  h2Diffe->SetTitle(Form("HO Depth %d. Cut avg(ADCAmpl) > 80 \b", depth));
3246  int nx = h2Ceff->GetXaxis()->GetNbins();
3247  int ny = h2Ceff->GetYaxis()->GetNbins();
3248  for (int i = 1; i <= nx; i++) {
3249  for (int j = 1; j <= ny; j++) {
3250  double ccc1 = h2Ceff->GetBinContent(i, j);
3251  h2Diffe->SetBinContent(i, j, 0.);
3252  if (ccc1 > 20.)
3253  h2Diffe->SetBinContent(i, j, ccc1);
3254  }
3255  }
3256  gPad->SetGridy();
3257  gPad->SetGridx();
3258  gPad->SetLogz();
3259  h2Diffe->SetMarkerStyle(20);
3260  h2Diffe->SetMarkerSize(0.4);
3261  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3262  h2Diffe->SetXTitle("#eta \b");
3263  h2Diffe->SetYTitle("#phi \b");
3264  h2Diffe->SetZTitle("<ADCAmpl> bigger 80.- HO Depth1 \b");
3265  h2Diffe->SetMarkerColor(2);
3266  h2Diffe->SetLineColor(2);
3267  h2Diffe->Draw("COLZ");
3268  }
3269 
3270  cHE->cd(3);
3271  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HO", depth);
3272  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3273  if (!twod3 || !twod0) {
3274  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3275  ptext->AddText("Missing histo");
3276  std::cout << "specHO test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3277  if (!twod3)
3278  ptext->AddText(hname3);
3279  if (!twod0)
3280  ptext->AddText(hname0);
3281  ptext->Draw();
3282  continue;
3283  } else {
3284  // To IDENTIFY: see color different bins in eta-phi space
3285  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HO%d", depth));
3286  h3Ceff->SetTitle(Form("HO Depth %d. \b", depth));
3287  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3288  gPad->SetGridy();
3289  gPad->SetGridx();
3290  gPad->SetLogz();
3291  h3Ceff->SetMarkerStyle(20);
3292  h3Ceff->SetMarkerSize(0.4);
3293  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3294  h3Ceff->SetXTitle("#eta \b");
3295  h3Ceff->SetYTitle("#phi \b");
3296  h3Ceff->SetZTitle("rate for channels of HO \b");
3297  h3Ceff->SetMarkerColor(2);
3298  h3Ceff->SetLineColor(2);
3299  h3Ceff->Draw("COLZ");
3300  }
3301 
3302  cHE->Update();
3303  cHE->Print(Form("ChkErrA_HO%d.png", depth));
3304  cHE->Clear();
3305 
3306  if (h2Ceff)
3307  delete h2Ceff;
3308  if (h2Diffe)
3309  delete h2Diffe;
3310  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3311  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3312  if (twod1)
3313  delete twod1;
3314  if (twod3)
3315  delete twod3;
3316  if (h3Ceff)
3317  delete h3Ceff;
3318  } // depth
3319 
3320  //=============================================================================== err A HF
3322  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HFx.png
3323 
3324  for (int depth = 1; depth <= 2; depth++) {
3325  TH2F *h2Ceff = NULL;
3326  TH2F *h2Diffe = NULL;
3327  // TH1F* h1diffADCAmpl= NULL;
3328  TH2F *h3Ceff = NULL;
3329 
3330  cHE->Clear();
3331  cHE->Divide(3, 1);
3332 
3333  cHE->cd(1);
3334  // h_mapDepth1ADCAmpl_HF div h_mapDepth1_HF
3335  TString hname1 = Form("h_mapDepth%dADCAmpl_HF", depth);
3336  TString hname0 = Form("h_mapDepth%d_HF", depth);
3337  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3338  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3339  if (!twod1 || !twod0) {
3340  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3341  ptext->AddText("Missing histo");
3342  std::cout << "specHF test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3343  if (!twod1)
3344  ptext->AddText(hname1);
3345  if (!twod0)
3346  ptext->AddText(hname0);
3347  ptext->Draw();
3348  continue;
3349  } else {
3350  // To IDENTIFY: see color different bins in eta-phi space
3351  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HF%d", depth));
3352  h2Ceff->SetTitle(Form("HF Depth %d. (No cut) \b", depth));
3353  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3354 
3355  gPad->SetGridy();
3356  gPad->SetGridx();
3357  gPad->SetLogz();
3358  h2Ceff->SetMarkerStyle(20);
3359  h2Ceff->SetMarkerSize(0.4);
3360  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3361  h2Ceff->SetXTitle("#eta \b");
3362  h2Ceff->SetYTitle("#phi \b");
3363  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HF \b");
3364  h2Ceff->SetMarkerColor(2);
3365  h2Ceff->SetLineColor(2);
3366  h2Ceff->Draw("COLZ");
3367  }
3368 
3369  cHE->cd(2);
3371  if (h2Ceff) {
3372  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3373  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HF", depth));
3374  h2Diffe->SetTitle(Form("HF Depth %d. Cut avg(ADCAmpl) > 20 \b", depth));
3375  int nx = h2Ceff->GetXaxis()->GetNbins();
3376  int ny = h2Ceff->GetYaxis()->GetNbins();
3377  for (int i = 1; i <= nx; i++) {
3378  for (int j = 1; j <= ny; j++) {
3379  double ccc1 = h2Ceff->GetBinContent(i, j);
3380  h2Diffe->SetBinContent(i, j, 0.);
3381  if (ccc1 > 20.)
3382  h2Diffe->SetBinContent(i, j, ccc1);
3383  }
3384  }
3385  gPad->SetGridy();
3386  gPad->SetGridx();
3387  gPad->SetLogz();
3388  h2Diffe->SetMarkerStyle(20);
3389  h2Diffe->SetMarkerSize(0.4);
3390  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3391  h2Diffe->SetXTitle("#eta \b");
3392  h2Diffe->SetYTitle("#phi \b");
3393  h2Diffe->SetZTitle("<ADCAmpl> bigger 20.- HF Depth1 \b");
3394  h2Diffe->SetMarkerColor(2);
3395  h2Diffe->SetLineColor(2);
3396  h2Diffe->Draw("COLZ");
3397  }
3398 
3399  cHE->cd(3);
3400  /*
3401  if (h2Ceff) {
3402  h1diffADCAmpl = new TH1F(Form("diffADCAmpl_Depth%d_HF",depth),"",
3403  100, -20.,200.);
3404  h1diffADCAmpl->SetTitle(Form("HF Depth %d \b",depth));
3405  int nx = h2Ceff->GetXaxis()->GetNbins();
3406  int ny = h2Ceff->GetYaxis()->GetNbins();
3407  for (int i=1;i<=nx;i++) {
3408  for (int j=1;j<=ny;j++) {
3409  if(h2Ceff->GetBinContent(i,j) !=0 ) {
3410  double ccc1 = h2Ceff->GetBinContent(i,j) ;
3411  h1diffADCAmpl->Fill(ccc1);
3412  }
3413  }
3414  }
3415  gPad->SetLogy();
3416  h1diffADCAmpl->SetMarkerStyle(20);
3417  h1diffADCAmpl->SetMarkerSize(0.4);
3418  h1diffADCAmpl->GetYaxis()->SetLabelSize(0.04);
3419  h1diffADCAmpl->SetXTitle("<ADCAmpl> in each cell \b");
3420  h1diffADCAmpl->SetMarkerColor(2);
3421  h1diffADCAmpl->SetLineColor(2);
3422  h1diffADCAmpl->Draw("");
3423  }
3424  */
3425  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HF", depth);
3426  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3427  if (!twod3 || !twod0) {
3428  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3429  ptext->AddText("Missing histo");
3430  std::cout << "specHF test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3431  if (!twod3)
3432  ptext->AddText(hname3);
3433  if (!twod0)
3434  ptext->AddText(hname0);
3435  ptext->Draw();
3436  continue;
3437  } else {
3438  // To IDENTIFY: see color different bins in eta-phi space
3439  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HF%d", depth));
3440  h3Ceff->SetTitle(Form("HF Depth %d. \b", depth));
3441  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3442  gPad->SetGridy();
3443  gPad->SetGridx();
3444  gPad->SetLogz();
3445  h3Ceff->SetMarkerStyle(20);
3446  h3Ceff->SetMarkerSize(0.4);
3447  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3448  h3Ceff->SetXTitle("#eta \b");
3449  h3Ceff->SetYTitle("#phi \b");
3450  h3Ceff->SetZTitle("rate for channels of HF \b");
3451  h3Ceff->SetMarkerColor(2);
3452  h3Ceff->SetLineColor(2);
3453  h3Ceff->Draw("COLZ");
3454  }
3455 
3456  cHE->Update();
3457  cHE->Print(Form("ChkErrA_HF%d.png", depth));
3458  cHE->Clear();
3459 
3460  if (h2Ceff)
3461  delete h2Ceff;
3462  if (h2Diffe)
3463  delete h2Diffe;
3464  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3465  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3466  if (twod1)
3467  delete twod1;
3468  if (twod3)
3469  delete twod3;
3470  if (h3Ceff)
3471  delete h3Ceff;
3472  } // depth
3473 
3474  std::cout << "************>>> average Amplitudes done" << std::endl;
3475 
3476  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3477  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3478  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3479  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3480  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3481 
3486 
3487  cout << " RBX analysis START for **************************" << endl;
3488  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3489  // int njeta = 22; int njphi = 18; int lsmax=2600;
3490  int njeta = 22;
3491  int njphi = 18;
3492  int lsmax = 1800;
3493  cout << ">>>>>>>>>>>>>>>>>>>>>>>> int njeta = 22; int njphi = 18; int lsmax=2600; "
3494  << endl;
3495 
3496  double alexall[njeta][njphi][lsmax];
3497 
3498  // for phi tables(!):
3499  double alexhb[njphi][lsmax];
3500  double alexhe[njphi][lsmax];
3501  double alexho[njphi][lsmax];
3502  double alexhf[njphi][lsmax];
3503 
3504  // for eta tables(!):
3505  double blexhb[njeta][lsmax];
3506  double blexhe[njeta][lsmax];
3507  double blexho[njeta][lsmax];
3508  double blexhf[njeta][lsmax];
3509 
3510  cout << ">>>>>>>>>>>>>>>>>>>>>>>> alexall [njeta][njphi][lsmax]; " << endl;
3511  int maxbinsRBX = MaxLum;
3512  int nx = maxbinsRBX; // # LS
3513  cout << ">>>>>>>>>>>>>>>>>>>>>>>> maxbinsRBX = MaxLum; " << endl;
3514  if (MaxLum > lsmax)
3515  cout << "*********************************** ERROR ERROR ERROR ERROR: MaxLum > 2600 " << endl;
3516  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3517 
3518  for (int i = 0; i < nx; i++) {
3519  for (int jphi = 0; jphi < njphi; jphi++) {
3520  alexhb[jphi][i] = 0.;
3521  alexhe[jphi][i] = 0.;
3522  alexho[jphi][i] = 0.;
3523  alexhf[jphi][i] = 0.;
3524 
3525  for (int jeta = 0; jeta < njeta; jeta++) {
3526  if (jphi == 0) {
3527  blexhb[jeta][i] = 0.;
3528  blexhe[jeta][i] = 0.;
3529  blexho[jeta][i] = 0.;
3530  blexhf[jeta][i] = 0.;
3531  }
3532 
3533  alexall[jeta][jphi][i] = 0.;
3534  }
3535  }
3536  }
3537 
3539  /*
3540  // j = ietaphi = 1- 396
3541  int ietaphimax = 396;
3542  int ny = ietaphimax + 1 ;
3543  for (int j=1;j<ny;j++) {
3544  int jeta = (j-1)/znphi;
3545  int jphi = (j-1)-znphi*jeta+1;// jphi=1-18
3546  jeta += 1;// jeta = 1-22 }
3547 // Outout is jeta = 1-22 jphi=1-18
3548 HB: j = 7,8,9,10 11,12,13,14
3549 HE: j = 3,4,5, 6, 7 14,15,16,17,18
3550 HO: j = 7,8,9,10 11,12,13,14
3551 HF: j = 0,1,2, 3 18,19,20,21
3552 */
3553 
3555  //======================================================================
3556  //======================================================================
3557  //======================================================================
3558  cout << " RBX general for HB **************************" << endl;
3559  TH2F *Ghb1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs0");
3560  TH2F *Ghb1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs00");
3561  TH2F *Ghb1 = (TH2F *)Ghb1LLL->Clone("Ghb1");
3562  Ghb1->Divide(Ghb1KKK, Ghb1LLL, 1, 1, "B"); // average A
3563  // Ghb1->Sumw2();
3564  // int nx = Ghb1->GetXaxis()->GetNbins(); // # LS
3565  int ny = Ghb1->GetYaxis()->GetNbins(); // # jetaphi indexes = 396 = 18*22
3566  // cout<<"***************************************** HB 54 ny= "<< ny <<endl;
3567  for (int j = 1; j <= ny; j++) {
3568  int jeta = (j - 1) / njphi; // jeta = 0-21
3569  if (jeta > 6 && jeta < 15) {
3570  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
3571  // cout<<"HB 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
3572  // over LS:
3573  for (int i = 1; i <= nx; i++) {
3574  double ccc1 = Ghb1->GetBinContent(i, j);
3575  alexall[jeta][jphi][i - 1] = ccc1;
3576  // if( i == 1 ) cout<<"HB 54 for LS=1 ccc1= "<< ccc1 <<endl;
3577  // if( ccc1 <= 0 ) cout<<"HB 54 ccc1= "<< ccc1 <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3578  // cout<<"HB 54 ccc1= "<< ccc1 <<" j= "<< j <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3579  } //i
3580  } //if
3581  } //j
3582  // clean-up
3583  if (Ghb1KKK)
3584  delete Ghb1KKK;
3585  if (Ghb1LLL)
3586  delete Ghb1LLL;
3587  // if (Ghb1) delete Ghb1;
3588 
3589  //====================================================================== alexhb[k][i]
3590  for (int jphi = 0; jphi < njphi; jphi++) {
3591  for (int i = 0; i < nx; i++) {
3592  double sumccc1 = 0.;
3593  int isum = 0;
3594  for (int jeta = 0; jeta < njeta; jeta++) {
3595  double ccc1 = alexall[jeta][jphi][i];
3596  if (ccc1 > 0.) {
3597  sumccc1 += ccc1;
3598  isum++;
3599  }
3600  } // for jeta
3601  if (isum > 0.)
3602  sumccc1 /= isum;
3603  alexhb[jphi][i] = sumccc1;
3604  }
3605  } //for for
3606 
3607  //====================================================================== blexhb[k][i]
3608  for (int keta = 0; keta < njeta; keta++) {
3609  for (int i = 0; i < nx; i++) {
3610  double sumccc1 = 0.;
3611  int isum = 0;
3612  for (int kphi = 0; kphi < njphi; kphi++) {
3613  double ccc1 = alexall[keta][kphi][i];
3614  if (ccc1 > 0.) {
3615  sumccc1 += ccc1;
3616  isum++;
3617  }
3618  } // for kphi
3619  if (isum > 0.)
3620  sumccc1 /= isum;
3621  blexhb[keta][i] = sumccc1;
3622  }
3623  } //for for
3624 
3626  //========================================================================================== 11 HB:: 2D jeta = 0 - 21 jphi =0 - 17
3627  //======================================================================
3628  //======================================================================
3629  //======================================================================
3630  //======================================================================
3631  cout << " RBX HB 2D plot *****" << endl;
3632  cRBX1->Clear();
3634  cRBX1->Divide(1, 1);
3635  cRBX1->cd(1);
3636  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
3637  // TH2F* Ghb42D = new TH2F("Ghb42D","", 22, -11., 11., 18, 0., 18. );
3638  // TH2F* Ghb42D0 = new TH2F("Ghb42D0","", 22, -11., 11., 18, 0., 18. );
3639  TH2F *Ghb42D = new TH2F("Ghb42D", "", 23, -11.5, 11.5, 18, 0., 18.);
3640  TH2F *Ghb42D0 = new TH2F("Ghb42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
3641  TH2F *Ghb42DF = (TH2F *)Ghb42D0->Clone("Ghb42DF");
3642  for (int jphi = 0; jphi < njphi; jphi++) {
3643  for (int jeta = 0; jeta < njeta; jeta++) {
3644  for (int i = 0; i < nx; i++) {
3645  double ccc1 = alexall[jeta][jphi][i];
3646  int neweta = jeta - 11 - 0.5;
3647  if (jeta >= 11)
3648  neweta = jeta - 11 + 1.5;
3649  if (ccc1 > 0.) {
3650  Ghb42D->Fill(neweta, jphi, ccc1);
3651  Ghb42D0->Fill(neweta, jphi, 1.);
3652  }
3653  // if(ccc1>0.) {Ghb42D ->Fill(jeta-11,jphi,ccc1); Ghb42D0 ->Fill(jeta-11,jphi,1.); }
3654  }
3655  }
3656  }
3657  Ghb42DF->Divide(Ghb42D, Ghb42D0, 1, 1, "B"); // average A
3658  // Ghb1->Sumw2();
3659  gPad->SetGridy();
3660  gPad->SetGridx(); // gPad->SetLogz();
3661  Ghb42DF->SetMarkerStyle(20);
3662  Ghb42DF->SetMarkerSize(0.4);
3663  Ghb42DF->GetZaxis()->SetLabelSize(0.04);
3664  Ghb42DF->SetXTitle("<A>_RBX #eta \b");
3665  Ghb42DF->SetYTitle(" #phi \b");
3666  Ghb42DF->SetZTitle("<A>_RBX - All \b");
3667  Ghb42DF->SetMarkerColor(2);
3668  Ghb42DF->SetLineColor(2); // Ghb42DF->SetMaximum(1.000); // Ghb42DF->SetMinimum(1.0);
3669  Ghb42DF->Draw("COLZ");
3670 
3672  cRBX1->Update();
3673  cRBX1->Print("RBX-HB-2Dplot.png");
3674  cRBX1->Clear();
3675  // clean-up
3676  if (Ghb42D)
3677  delete Ghb42D;
3678  if (Ghb42D0)
3679  delete Ghb42D0;
3680  if (Ghb42DF)
3681  delete Ghb42DF;
3682 
3683  //========================================================================================== 61 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3684  //======================================================================
3685  //======================================================================
3686  //======================================================================
3687  //======================================================================
3688  cout << " RBX HB 1D plot *****" << endl;
3689  cRBX1->Clear();
3691  cRBX1->Divide(1, 1);
3692  cRBX1->cd(1);
3693  TH1F *GphiHB1D = new TH1F("GphiHB1D", "", 18, 0., 18.);
3694  TH1F *GphiHB1D0 = new TH1F("GphiHB1D0", "", 18, 0., 18.);
3695  TH1F *GphiHB1DF = (TH1F *)GphiHB1D0->Clone("GphiHB1DF");
3696  for (int jphi = 0; jphi < 18; jphi++) {
3697  for (int jeta = 0; jeta < 22; jeta++) {
3698  for (int i = 0; i < nx; i++) {
3699  double ccc1 = alexall[jeta][jphi][i];
3700  if (ccc1 > 0.) {
3701  GphiHB1D->Fill(jphi, ccc1);
3702  GphiHB1D0->Fill(jphi, 1.);
3703  }
3704  }
3705  }
3706  }
3707  // GphiHB1D->Sumw2();GphiHB1D0->Sumw2();
3708  GphiHB1DF->Divide(GphiHB1D, GphiHB1D0, 1, 1, "B"); // average A
3709  // GphiHB1DF->Sumw2();
3710  for (int jphi = 1; jphi < 19; jphi++) {
3711  GphiHB1DF->SetBinError(jphi, 0.01);
3712  }
3713  gPad->SetGridy();
3714  gPad->SetGridx(); // gPad->SetLogz();
3715  GphiHB1DF->SetMarkerStyle(20);
3716  GphiHB1DF->SetMarkerSize(1.4);
3717  GphiHB1DF->GetZaxis()->SetLabelSize(0.08);
3718  GphiHB1DF->SetXTitle("PHI of RBX\b");
3719  GphiHB1DF->SetYTitle(" <Amplitude> \b");
3720  GphiHB1DF->SetZTitle("<A>_PHI - All \b");
3721  GphiHB1DF->SetMarkerColor(4);
3722  GphiHB1DF->SetLineColor(4);
3723  GphiHB1DF->SetMinimum(0.8); // GphiHB1DF->SetMaximum(1.000);
3724  GphiHB1DF->Draw("Error");
3726  cRBX1->Update();
3727  cRBX1->Print("RBX-HB-1Dplot.png");
3728  cRBX1->Clear();
3729  // clean-up
3730  if (GphiHB1D)
3731  delete GphiHB1D;
3732  if (GphiHB1D0)
3733  delete GphiHB1D0;
3734  if (GphiHB1DF)
3735  delete GphiHB1DF;
3736 
3737  //========================================================================================== 62 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3738  //======================================================================
3739  //======================================================================
3740  //======================================================================
3741  //======================================================================
3742  cout << " RBX HB 11D plot *eta*" << endl;
3743  cRBX1->Clear();
3745  cRBX1->Divide(1, 1);
3746  cRBX1->cd(1);
3747  TH1F *GetaHB11D = new TH1F("GetaHB11D", "", 23, -11.5, 11.5);
3748  TH1F *GetaHB11D0 = new TH1F("GetaHB11D0", "", 23, -11.5, 11.5);
3749  TH1F *GetaHB11DF = (TH1F *)GetaHB11D0->Clone("GetaHB11DF");
3750 
3751  for (int jeta = 0; jeta < 22; jeta++) {
3752  for (int jphi = 0; jphi < 18; jphi++) {
3753  for (int i = 0; i < nx; i++) {
3754  double ccc1 = alexall[jeta][jphi][i];
3755  int neweta = jeta - 11 - 0.5;
3756  if (jeta >= 11)
3757  neweta = jeta - 11 + 1.5;
3758  if (ccc1 > 0.) {
3759  GetaHB11D->Fill(neweta, ccc1);
3760  GetaHB11D0->Fill(neweta, 1.);
3761  // if( i == 0 ) cout<<"62 HB: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
3762  }
3763  }
3764  }
3765  }
3766  // GetaHB11D->Sumw2();GetaHB11D0->Sumw2();
3767  GetaHB11DF->Divide(GetaHB11D, GetaHB11D0, 1, 1, "B"); // average A
3768  // GetaHB11DF->Sumw2();
3769  for (int jeta = 1; jeta < 24; jeta++) {
3770  GetaHB11DF->SetBinError(jeta, 0.01);
3771  }
3772  gPad->SetGridy();
3773  gPad->SetGridx(); // gPad->SetLogz();
3774  GetaHB11DF->SetMarkerStyle(20);
3775  GetaHB11DF->SetMarkerSize(1.4);
3776  GetaHB11DF->GetZaxis()->SetLabelSize(0.08);
3777  GetaHB11DF->SetXTitle("#eta \b");
3778  GetaHB11DF->SetYTitle(" <A> \b");
3779  GetaHB11DF->SetZTitle("<A>_ETA - All \b");
3780  GetaHB11DF->SetMarkerColor(4);
3781  GetaHB11DF->SetLineColor(4);
3782  GetaHB11DF->SetMinimum(0.8); // GetaHB11DF->SetMaximum(1.000);
3783  GetaHB11DF->Draw("Error");
3784 
3786  cRBX1->Update();
3787  cRBX1->Print("RBX-HB-11Dplot.png");
3788  cRBX1->Clear();
3789  // clean-up
3790  if (GetaHB11D)
3791  delete GetaHB11D;
3792  if (GetaHB11D0)
3793  delete GetaHB11D0;
3794  if (GetaHB11DF)
3795  delete GetaHB11DF;
3796 
3797  //========================================================================================== 22 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
3798  //======================================================================
3799  //======================================================================22.11.2018
3800  //======================================================================
3801  //======================================================================
3802 
3803  gStyle->SetOptStat(1110000);
3804  cout << " RBX HB Ratio plots *****" << endl;
3805  cRBX31->Clear();
3807  // gain stabilitY:
3808  // Rij = Aij / A1j , where i-over LSs, j-channels
3809  //
3810  // nx = maxbinsRBX; // # LS
3811  //
3812  double ccc0HB = 0.;
3813  cRBX31->Divide(3, 1);
3814  //================
3815  cRBX31->cd(1);
3816  // TH1F* Ghb5 = new TH1F("Ghb5","", nx, 1., nx+1.);
3817  TH1F *Ghb51 = new TH1F("Ghb51", "", nx, 1., nx + 1.);
3818  TH1F *Ghb50 = new TH1F("Ghb50", "", nx, 1., nx + 1.);
3819  TH1F *Ghb5 = (TH1F *)Ghb50->Clone("Ghb5");
3820  // j - etaphi index:
3821  for (int j = 1; j <= ny; j++) {
3822  ccc0HB = Ghb1->GetBinContent(1, j);
3823  // 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;} }
3824  if (ccc0HB <= 0.)
3825  for (int i = 1; i <= nx; i++) {
3826  double ccc2 = Ghb1->GetBinContent(i, j);
3827  if (ccc2 > 0.) {
3828  ccc0HB = ccc2;
3829  break;
3830  }
3831  }
3832  if (ccc0HB > 0.) {
3833  // i - # LSs:
3834  for (int i = 1; i <= nx; i++) {
3835  double ccc1 = Ghb1->GetBinContent(i, j);
3836  if (ccc1 > 0.) {
3837  double Rij = ccc1 / ccc0HB;
3838  // Ghb5 ->Fill( float(i), Rij);
3839  Ghb51->Fill(float(i), Rij);
3840  Ghb50->Fill(float(i), 1.);
3841  }
3842  }
3843  }
3844  }
3845  Ghb5->Divide(Ghb51, Ghb50, 1, 1, "B"); // average A
3846  for (int i = 1; i <= nx; i++) {
3847  Ghb5->SetBinError(i, 0.0001);
3848  }
3849  Ghb5->SetMarkerStyle(20);
3850  Ghb5->SetMarkerSize(0.4);
3851  Ghb5->GetYaxis()->SetLabelSize(0.04);
3852  Ghb5->SetMarkerColor(2);
3853  Ghb5->SetLineColor(0);
3854  Ghb5->SetXTitle(" iLS \b");
3855  Ghb5->SetYTitle(" <R> \b");
3856  Ghb5->SetTitle("<Ri> vs iLS \b");
3857  Ghb5->SetMinimum(0.); //Ghb5->SetMaximum(2.5);
3858  // gPad->SetLogy();
3859  gPad->SetGridy();
3860  gPad->SetGridx();
3861  Ghb5->SetStats(0);
3862  Ghb5->GetYaxis()->SetLabelSize(0.025);
3863  Ghb5->Draw("Error");
3864  //================
3865  cRBX31->cd(2);
3866  TH2F *Ghb60 = new TH2F("Ghb60", "", 22, -11., 11., 18, 0., 18.);
3867  TH2F *Ghb61 = new TH2F("Ghb61", "", 22, -11., 11., 18, 0., 18.);
3868  TH2F *Ghb6 = new TH2F("Ghb6", "", 22, -11., 11., 18, 0., 18.);
3869 
3870  TH2F *G20hb60 = new TH2F("G20hb60", "", 22, -11., 11., 18, 0., 18.);
3871  TH2F *G20hb61 = new TH2F("G20hb61", "", 22, -11., 11., 18, 0., 18.);
3872  TH2F *G20hb6 = new TH2F("G20hb6", "", 22, -11., 11., 18, 0., 18.);
3873  TH2F *G30hb60 = new TH2F("G30hb60", "", 22, -11., 11., 18, 0., 18.);
3874  TH2F *G30hb61 = new TH2F("G30hb61", "", 22, -11., 11., 18, 0., 18.);
3875  TH2F *G30hb6 = new TH2F("G30hb6", "", 22, -11., 11., 18, 0., 18.);
3876  TH2F *G40hb60 = new TH2F("G40hb60", "", 22, -11., 11., 18, 0., 18.);
3877  TH2F *G40hb61 = new TH2F("G40hb61", "", 22, -11., 11., 18, 0., 18.);
3878  TH2F *G40hb6 = new TH2F("G40hb6", "", 22, -11., 11., 18, 0., 18.);
3879  // j - etaphi index; i - # LSs;
3880  //
3881  // define mean and RMS:
3882  double sumjHB = 0.;
3883  int njHB = 0;
3884  double meanjHB = 0.;
3885  for (int j = 1; j <= ny; j++) {
3886  ccc0HB = Ghb1->GetBinContent(1, j);
3887  if (ccc0HB <= 0.)
3888  for (int i = 1; i <= nx; i++) {
3889  double ccc2 = Ghb1->GetBinContent(i, j);
3890  if (ccc2 > 0.) {
3891  ccc0HB = ccc2;
3892  break;
3893  }
3894  }
3895  if (ccc0HB > 0.) {
3896  for (int i = 1; i <= nx; i++) {
3897  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3898  if (ccc1 > 0.) {
3899  sumjHB += ccc1;
3900  njHB++;
3901  }
3902  }
3903  meanjHB = sumjHB / njHB;
3904  }
3905  } // j
3906 
3907  double ssumjHB = 0.;
3908  njHB = 0;
3909  double sigmajHB = 0.;
3910  for (int j = 1; j <= ny; j++) {
3911  ccc0HB = Ghb1->GetBinContent(1, j);
3912  if (ccc0HB <= 0.)
3913  for (int i = 1; i <= nx; i++) {
3914  double ccc2 = Ghb1->GetBinContent(i, j);
3915  if (ccc2 > 0.) {
3916  ccc0HB = ccc2;
3917  break;
3918  }
3919  }
3920  if (ccc0HB > 0.) {
3921  for (int i = 1; i <= nx; i++) {
3922  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3923  if (ccc1 > 0.) {
3924  ssumjHB += (ccc1 - meanjHB) * (ccc1 - meanjHB);
3925  njHB++;
3926  }
3927  }
3928  sigmajHB = sqrt(ssumjHB / njHB);
3929  }
3930  } // j
3931 
3932  double dif3rmsHBMIN = meanjHB - 3 * sigmajHB;
3933  if (dif3rmsHBMIN < 0.)
3934  dif3rmsHBMIN = 0.;
3935  double dif3rmsHBMAX = meanjHB + 3 * sigmajHB;
3936  cout << "22HB-2 meanjHB= " << meanjHB << " sigmajHB= " << sigmajHB << " dif3rmsHBMIN= " << dif3rmsHBMIN
3937  << " dif3rmsHBMAX= " << dif3rmsHBMAX << endl;
3938 
3939  double MAXdif3rmsHBMIN = dif3rmsHBMIN;
3940  double MINdif3rmsHBMAX = dif3rmsHBMAX;
3941  if (MAXdif3rmsHBMIN < 0.95)
3942  MAXdif3rmsHBMIN = 0.95;
3943  if (MINdif3rmsHBMAX > 1.05)
3944  MINdif3rmsHBMAX = 1.05;
3945  cout << "22HB-2 MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
3946  //
3947  for (int j = 1; j <= ny; j++) {
3948  ccc0HB = Ghb1->GetBinContent(1, j);
3949  if (ccc0HB <= 0.)
3950  for (int i = 1; i <= nx; i++) {
3951  double ccc2 = Ghb1->GetBinContent(i, j);
3952  if (ccc2 > 0.) {
3953  ccc0HB = ccc2;
3954  break;
3955  }
3956  }
3957  if (ccc0HB > 0.) {
3958  int jeta = (j - 1) / 18; // jeta = 0-21
3959  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
3960  // i - # LSs:
3961  for (int i = 1; i <= nx; i++) {
3962  double ccc1 = Ghb1->GetBinContent(i, j);
3963  if (ccc1 > 0.) {
3964  double Rij = ccc1 / ccc0HB;
3965  if (Rij < MAXdif3rmsHBMIN || Rij > MINdif3rmsHBMAX) {
3966  Ghb61->Fill(jeta - 11, jphi, Rij);
3967  Ghb60->Fill(jeta - 11, jphi, 1.);
3968  }
3969  if (Rij < 0.8 || Rij > 1.2) {
3970  G20hb61->Fill(jeta - 11, jphi, Rij);
3971  G20hb60->Fill(jeta - 11, jphi, 1.);
3972  }
3973  if (Rij < 0.7 || Rij > 1.3) {
3974  G30hb61->Fill(jeta - 11, jphi, Rij);
3975  G30hb60->Fill(jeta - 11, jphi, 1.);
3976  }
3977  if (Rij < 0.6 || Rij > 1.4) {
3978  G40hb61->Fill(jeta - 11, jphi, Rij);
3979  G40hb60->Fill(jeta - 11, jphi, 1.);
3980  }
3981  } //if(ccc1>0.
3982  } // i
3983  } //if(ccc0HB>0
3984  } // j
3985  Ghb6->Divide(Ghb61, Ghb60, 1, 1, "B"); // average R
3986  G20hb6->Divide(G20hb61, G20hb60, 1, 1, "B"); // average R
3987  G30hb6->Divide(G30hb61, G30hb60, 1, 1, "B"); // average R
3988  G40hb6->Divide(G40hb61, G40hb60, 1, 1, "B"); // average R
3989 
3990  Ghb6->GetZaxis()->SetLabelSize(0.025);
3991  Ghb6->SetXTitle(" #eta \b");
3992  Ghb6->SetYTitle(" #phi \b");
3993  Ghb6->SetTitle("<Rj> for |1-<R>| > 0.05 \b");
3994  Ghb6->SetStats(0);
3995  Ghb6->Draw("COLZ");
3996  //================
3997  cRBX31->cd(3);
3998  TH1F *Ghb7 = new TH1F("Ghb7", "", 120, 0.4, 1.6);
3999  // j - etaphi index:
4000  for (int j = 1; j <= ny; j++) {
4001  ccc0HB = Ghb1->GetBinContent(1, j);
4002  if (ccc0HB <= 0.)
4003  for (int i = 1; i <= nx; i++) {
4004  double ccc2 = Ghb1->GetBinContent(i, j);
4005  if (ccc2 > 0.) {
4006  ccc0HB = ccc2;
4007  break;
4008  }
4009  }
4010  if (ccc0HB > 0.) {
4011  // i - # LSs:
4012  for (int i = 1; i <= nx; i++) {
4013  double ccc1 = Ghb1->GetBinContent(i, j);
4014  if (ccc1 > 0.) {
4015  double Rij = ccc1 / ccc0HB;
4016  Ghb7->Fill(Rij);
4017  }
4018  }
4019  }
4020  }
4021  Ghb7->SetMarkerStyle(20);
4022  Ghb7->SetMarkerSize(0.4);
4023  Ghb7->GetYaxis()->SetLabelSize(0.04);
4024  Ghb7->SetMarkerColor(2);
4025  Ghb7->SetLineColor(0);
4026  Ghb7->SetYTitle(" N \b");
4027  Ghb7->SetXTitle(" Rij \b");
4028  Ghb7->SetTitle(" Rij \b");
4029  //Ghb7->SetMinimum(0.8);Ghb7->SetMaximum(500.);
4030  gPad->SetGridy();
4031  gPad->SetGridx(); // gPad->SetLogy();
4032  // Ghb7->SetStats(1110000);
4033  Ghb7->GetYaxis()->SetLabelSize(0.025);
4034  Ghb7->Draw("Error");
4035  Float_t ymaxHB = Ghb7->GetMaximum();
4036  cout << "22HB-3 ymaxHB= " << ymaxHB << " MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN
4037  << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
4038  TLine *lineHB = new TLine(MAXdif3rmsHBMIN, 0., MAXdif3rmsHBMIN, ymaxHB);
4039  lineHB->SetLineColor(kBlue);
4040  lineHB->Draw();
4041  TLine *line1HB = new TLine(MINdif3rmsHBMAX, 0., MINdif3rmsHBMAX, ymaxHB);
4042  line1HB->SetLineColor(kBlue);
4043  line1HB->Draw();
4044  //================
4046  cRBX31->Update();
4047  cRBX31->Print("RBX-HB-3plots.png");
4048  cRBX31->Clear();
4049  // clean-up
4050  if (Ghb5)
4051  delete Ghb5;
4052  if (Ghb60)
4053  delete Ghb60;
4054  if (Ghb61)
4055  delete Ghb61;
4056  if (Ghb6)
4057  delete Ghb6;
4058  if (Ghb7)
4059  delete Ghb7;
4060 
4061  if (G20hb60)
4062  delete G20hb60;
4063  if (G20hb61)
4064  delete G20hb61;
4065  if (G30hb60)
4066  delete G30hb60;
4067  if (G30hb61)
4068  delete G30hb61;
4069  if (G40hb60)
4070  delete G40hb60;
4071  if (G40hb61)
4072  delete G40hb61;
4073 
4074  if (Ghb1)
4075  delete Ghb1;
4076  //========================================================================================== 22-1 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4077  //======================================================================
4078  //======================================================================28.11.2018
4079  //======================================================================
4080  //======================================================================
4081 
4082  gStyle->SetOptStat(1110000);
4083  cout << " RBX HB Ratio plotsmore *****" << endl;
4084  cRBX31->Clear();
4086  cRBX31->Divide(3, 1);
4087  //================
4088  cRBX31->cd(1);
4089  G20hb6->GetZaxis()->SetLabelSize(0.025);
4090  G20hb6->SetXTitle(" #eta \b");
4091  G20hb6->SetYTitle(" #phi \b");
4092  G20hb6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4093  G20hb6->SetStats(0);
4094  G20hb6->Draw("COLZ");
4095  //================
4096  cRBX31->cd(2);
4097  G30hb6->GetZaxis()->SetLabelSize(0.025);
4098  G30hb6->SetXTitle(" #eta \b");
4099  G30hb6->SetYTitle(" #phi \b");
4100  G30hb6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4101  G30hb6->SetStats(0);
4102  G30hb6->Draw("COLZ");
4103  //================
4104  cRBX31->cd(3);
4105  G40hb6->GetZaxis()->SetLabelSize(0.025);
4106  G40hb6->SetXTitle(" #eta \b");
4107  G40hb6->SetYTitle(" #phi \b");
4108  G40hb6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4109  G40hb6->SetStats(0);
4110  G40hb6->Draw("COLZ");
4111  //================
4112 
4114  cRBX31->Update();
4115  cRBX31->Print("RBX-HB-3plotsmore.png");
4116  cRBX31->Clear();
4117 
4118  // clean-up
4119  if (G20hb6)
4120  delete G20hb6;
4121  if (G30hb6)
4122  delete G30hb6;
4123  if (G40hb6)
4124  delete G40hb6;
4125  gStyle->SetOptStat(0);
4126 
4128 
4129  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4130  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4131  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4132  for (int jphi = 0; jphi < njphi; jphi++) {
4133  for (int jeta = 0; jeta < njeta; jeta++) {
4134  for (int i = 0; i < nx; i++) {
4135  alexall[jeta][jphi][i] = 0.;
4136  }
4137  }
4138  } // nulling
4139 
4141 
4143  //======================================================================
4144  //======================================================================
4145  //======================================================================
4146  cout << " RBX general for HE **************************" << endl;
4147  TH2F *Ghe1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs1");
4148  TH2F *Ghe1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs10");
4149  TH2F *Ghe1 = (TH2F *)Ghe1LLL->Clone("Ghe1");
4150  Ghe1->Divide(Ghe1KKK, Ghe1LLL, 1, 1, "B"); // average A
4151  // Ghe1->Sumw2();
4152  // int nx = Ghe1->GetXaxis()->GetNbins(); // # LS
4153  // nx = maxbinsRBX; // # LS
4154  ny = Ghe1->GetYaxis()->GetNbins(); // # jetaphi indexes
4155  for (int j = 1; j <= ny; j++) {
4156  int jeta = (j - 1) / njphi; // jeta = 0-21
4157  if ((jeta < 8 && jeta > 2) || (jeta < 19 && jeta > 13)) {
4158  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4159  // cout<<"HE 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4160  // over LS:
4161  for (int i = 1; i <= nx; i++) {
4162  double ccc1 = Ghe1->GetBinContent(i, j);
4163  alexall[jeta][jphi][i - 1] = ccc1;
4164  // if( i == 1 ) cout<<"HE 54 for LS=1 ccc1= "<< ccc1 <<endl;
4165  } //i
4166  } //if
4167  } //j
4168  // clean-up
4169  if (Ghe1KKK)
4170  delete Ghe1KKK;
4171  if (Ghe1LLL)
4172  delete Ghe1LLL;
4173  // if (Ghe1) delete Ghe1;
4174 
4175  //====================================================================== alexhe[k][i]
4176  for (int jphi = 0; jphi < njphi; jphi++) {
4177  for (int i = 0; i < nx; i++) {
4178  double sumccc1 = 0.;
4179  int isum = 0;
4180  for (int jeta = 0; jeta < njeta; jeta++) {
4181  double ccc1 = alexall[jeta][jphi][i];
4182  if (ccc1 > 0.) {
4183  sumccc1 += ccc1;
4184  isum++;
4185  }
4186  } // for jeta
4187  if (isum > 0.)
4188  sumccc1 /= isum;
4189  alexhe[jphi][i] = sumccc1;
4190  }
4191  } //for for
4192  //====================================================================== blexhe[k][i]
4193  for (int keta = 0; keta < njeta; keta++) {
4194  for (int i = 0; i < nx; i++) {
4195  double sumccc1 = 0.;
4196  int isum = 0;
4197  for (int kphi = 0; kphi < njphi; kphi++) {
4198  double ccc1 = alexall[keta][kphi][i];
4199  if (ccc1 > 0.) {
4200  sumccc1 += ccc1;
4201  isum++;
4202  }
4203  } // for kphi
4204  if (isum > 0.)
4205  sumccc1 /= isum;
4206  blexhe[keta][i] = sumccc1;
4207  }
4208  } //for for
4210  //========================================================================================== 21 HE:: 2D jeta = 0 - 21 jphi =0 - 17
4211  //======================================================================
4212  //======================================================================
4213  //======================================================================
4214  //======================================================================
4215  cout << " RBX HE 2D plot *****" << endl;
4216  cRBX1->Clear();
4218  cRBX1->Divide(1, 1);
4219  cRBX1->cd(1);
4220  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4221  TH2F *Ghe42D = new TH2F("Ghe42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4222  TH2F *Ghe42D0 = new TH2F("Ghe42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4223  // TH2F* Ghe42D = new TH2F("Ghe42D","", 22, -11., 11., 18, 0., 18. );
4224  // TH2F* Ghe42D0 = new TH2F("Ghe42D0","", 22, -11., 11., 18, 0., 18. );
4225  TH2F *Ghe42DF = (TH2F *)Ghe42D0->Clone("Ghe42DF");
4226  for (int jphi = 0; jphi < njphi; jphi++) {
4227  for (int jeta = 0; jeta < njeta; jeta++) {
4228  for (int i = 0; i < nx; i++) {
4229  double ccc1 = alexall[jeta][jphi][i];
4230  int neweta = jeta - 11 - 0.5;
4231  if (jeta >= 11)
4232  neweta = jeta - 11 + 1.5;
4233  if (ccc1 > 0.) {
4234  Ghe42D->Fill(neweta, jphi, ccc1);
4235  Ghe42D0->Fill(neweta, jphi, 1.);
4236  }
4237  // if(ccc1>0.) {Ghe42D ->Fill(jeta-11,jphi,ccc1); Ghe42D0 ->Fill(jeta-11,jphi,1.); }
4238  }
4239  }
4240  }
4241  Ghe42DF->Divide(Ghe42D, Ghe42D0, 1, 1, "B"); // average A
4242  // Ghe1->Sumw2();
4243  gPad->SetGridy();
4244  gPad->SetGridx(); // gPad->SetLogz();
4245  Ghe42DF->SetMarkerStyle(20);
4246  Ghe42DF->SetMarkerSize(0.4);
4247  Ghe42DF->GetZaxis()->SetLabelSize(0.04);
4248  Ghe42DF->SetXTitle("<A>_RBX #eta \b");
4249  Ghe42DF->SetYTitle(" #phi \b");
4250  Ghe42DF->SetZTitle("<A>_RBX - All \b");
4251  Ghe42DF->SetMarkerColor(2);
4252  Ghe42DF->SetLineColor(2); // Ghe42DF->SetMaximum(1.000); // Ghe42DF->SetMinimum(1.0);
4253  Ghe42DF->Draw("COLZ");
4254 
4256  cRBX1->Update();
4257  cRBX1->Print("RBX-HE-2Dplot.png");
4258  cRBX1->Clear();
4259  // clean-up
4260  if (Ghe42D)
4261  delete Ghe42D;
4262  if (Ghe42D0)
4263  delete Ghe42D0;
4264  if (Ghe42DF)
4265  delete Ghe42DF;
4266 
4267  //========================================================================================== 61 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4268  //======================================================================
4269  //======================================================================
4270  //======================================================================
4271  //======================================================================
4272  cout << " RBX HE 1D plot *****" << endl;
4273  cRBX1->Clear();
4275  cRBX1->Divide(1, 1);
4276  cRBX1->cd(1);
4277  TH1F *GphiHE1D = new TH1F("GphiHE1D", "", 18, 0., 18.);
4278  TH1F *GphiHE1D0 = new TH1F("GphiHE1D0", "", 18, 0., 18.);
4279  TH1F *GphiHE1DF = (TH1F *)GphiHE1D0->Clone("GphiHE1DF");
4280  for (int jphi = 0; jphi < 18; jphi++) {
4281  for (int jeta = 0; jeta < 22; jeta++) {
4282  for (int i = 0; i < nx; i++) {
4283  double ccc1 = alexall[jeta][jphi][i];
4284  if (ccc1 > 0.) {
4285  GphiHE1D->Fill(jphi, ccc1);
4286  GphiHE1D0->Fill(jphi, 1.);
4287  }
4288  }
4289  }
4290  }
4291  // GphiHE1D->Sumw2();GphiHE1D0->Sumw2();
4292  GphiHE1DF->Divide(GphiHE1D, GphiHE1D0, 1, 1, "B"); // average A
4293  // GphiHE1DF->Sumw2();
4294  for (int jphi = 1; jphi < 19; jphi++) {
4295  GphiHE1DF->SetBinError(jphi, 0.01);
4296  }
4297  gPad->SetGridy();
4298  gPad->SetGridx(); // gPad->SetLogz();
4299  GphiHE1DF->SetMarkerStyle(20);
4300  GphiHE1DF->SetMarkerSize(1.4);
4301  GphiHE1DF->GetZaxis()->SetLabelSize(0.08);
4302  GphiHE1DF->SetXTitle("PHI of RBX\b");
4303  GphiHE1DF->SetYTitle(" <Amplitude> \b");
4304  GphiHE1DF->SetZTitle("<A>_PHI - All \b");
4305  GphiHE1DF->SetMarkerColor(4);
4306  GphiHE1DF->SetLineColor(4);
4307  GphiHE1DF->SetMinimum(0.8); // GphiHE1DF->SetMaximum(1.000);
4308  GphiHE1DF->Draw("Error");
4310  cRBX1->Update();
4311  cRBX1->Print("RBX-HE-1Dplot.png");
4312  cRBX1->Clear();
4313  // clean-up
4314  if (GphiHE1D)
4315  delete GphiHE1D;
4316  if (GphiHE1D0)
4317  delete GphiHE1D0;
4318  if (GphiHE1DF)
4319  delete GphiHE1DF;
4320 
4321  //========================================================================================== 62 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4322  //======================================================================
4323  //======================================================================
4324  //======================================================================
4325  //======================================================================
4326  cout << " RBX HE 11D plot *eta*" << endl;
4327  cRBX1->Clear();
4329  cRBX1->Divide(1, 1);
4330  cRBX1->cd(1);
4331  TH1F *GetaHE11D = new TH1F("GetaHE11D", "", 23, -11.5, 11.5);
4332  TH1F *GetaHE11D0 = new TH1F("GetaHE11D0", "", 23, -11.5, 11.5);
4333  TH1F *GetaHE11DF = (TH1F *)GetaHE11D0->Clone("GetaHE11DF");
4334 
4335  for (int jeta = 0; jeta < 22; jeta++) {
4336  for (int jphi = 0; jphi < 18; jphi++) {
4337  for (int i = 0; i < nx; i++) {
4338  double ccc1 = alexall[jeta][jphi][i];
4339  int neweta = jeta - 11 - 0.5;
4340  if (jeta >= 11)
4341  neweta = jeta - 11 + 1.5;
4342  if (ccc1 > 0.) {
4343  GetaHE11D->Fill(neweta, ccc1);
4344  GetaHE11D0->Fill(neweta, 1.);
4345  // if( i == 0 ) cout<<"62 HE: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4346  }
4347  }
4348  }
4349  }
4350  // GetaHE11D->Sumw2();GetaHE11D0->Sumw2();
4351  GetaHE11DF->Divide(GetaHE11D, GetaHE11D0, 1, 1, "B"); // average A
4352  // GetaHE11DF->Sumw2();
4353  for (int jeta = 1; jeta < 24; jeta++) {
4354  GetaHE11DF->SetBinError(jeta, 0.01);
4355  }
4356  gPad->SetGridy();
4357  gPad->SetGridx(); // gPad->SetLogz();
4358  GetaHE11DF->SetMarkerStyle(20);
4359  GetaHE11DF->SetMarkerSize(1.4);
4360  GetaHE11DF->GetZaxis()->SetLabelSize(0.08);
4361  GetaHE11DF->SetXTitle("#eta \b");
4362  GetaHE11DF->SetYTitle(" <A> \b");
4363  GetaHE11DF->SetZTitle("<A>_ETA - All \b");
4364  GetaHE11DF->SetMarkerColor(4);
4365  GetaHE11DF->SetLineColor(4);
4366  GetaHE11DF->SetMinimum(0.8); // GetaHE11DF->SetMaximum(1.000);
4367  GetaHE11DF->Draw("Error");
4368 
4370  cRBX1->Update();
4371  cRBX1->Print("RBX-HE-11Dplot.png");
4372  cRBX1->Clear();
4373  // clean-up
4374  if (GetaHE11D)
4375  delete GetaHE11D;
4376  if (GetaHE11D0)
4377  delete GetaHE11D0;
4378  if (GetaHE11DF)
4379  delete GetaHE11DF;
4380 
4381  //========================================================================================== 22 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4382  //======================================================================
4383  //======================================================================22.11.2018
4384  //======================================================================
4385  //======================================================================
4386 
4387  gStyle->SetOptStat(1110000);
4388  cout << " RBX HE Ratio plots *****" << endl;
4389  cRBX31->Clear();
4391  // gain stabilitY:
4392  // Rij = Aij / A1j , where i-over LSs, j-channels
4393  //
4394  // nx = maxbinsRBX; // # LS
4395  //
4396  double ccc0HE = 0.;
4397  cRBX31->Divide(3, 1);
4398  //================
4399  cRBX31->cd(1);
4400  // TH1F* Ghe5 = new TH1F("Ghe5","", nx, 1., nx+1.);
4401  TH1F *Ghe51 = new TH1F("Ghe51", "", nx, 1., nx + 1.);
4402  TH1F *Ghe50 = new TH1F("Ghe50", "", nx, 1., nx + 1.);
4403  TH1F *Ghe5 = (TH1F *)Ghe50->Clone("Ghe5");
4404  // j - etaphi index:
4405  for (int j = 1; j <= ny; j++) {
4406  ccc0HE = Ghe1->GetBinContent(1, j);
4407  // 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;} }
4408  if (ccc0HE <= 0.)
4409  for (int i = 1; i <= nx; i++) {
4410  double ccc2 = Ghe1->GetBinContent(i, j);
4411  if (ccc2 > 0.) {
4412  ccc0HE = ccc2;
4413  break;
4414  }
4415  }
4416  if (ccc0HE > 0.) {
4417  // i - # LSs:
4418  for (int i = 1; i <= nx; i++) {
4419  double ccc1 = Ghe1->GetBinContent(i, j);
4420  if (ccc1 > 0.) {
4421  double Rij = ccc1 / ccc0HE;
4422  // Ghe5 ->Fill( float(i), Rij);
4423  Ghe51->Fill(float(i), Rij);
4424  Ghe50->Fill(float(i), 1.);
4425  }
4426  }
4427  }
4428  }
4429  Ghe5->Divide(Ghe51, Ghe50, 1, 1, "B"); // average A
4430  for (int i = 1; i <= nx; i++) {
4431  Ghe5->SetBinError(i, 0.0001);
4432  }
4433  Ghe5->SetMarkerStyle(20);
4434  Ghe5->SetMarkerSize(0.4);
4435  Ghe5->GetYaxis()->SetLabelSize(0.04);
4436  Ghe5->SetMarkerColor(2);
4437  Ghe5->SetLineColor(0);
4438  Ghe5->SetXTitle(" iLS \b");
4439  Ghe5->SetYTitle(" <R> \b");
4440  Ghe5->SetTitle("<Ri> vs iLS \b");
4441  Ghe5->SetMinimum(0.); //Ghe5->SetMaximum(2.5);
4442  // gPad->SetLogy();
4443  gPad->SetGridy();
4444  gPad->SetGridx();
4445  Ghe5->SetStats(0);
4446  Ghe5->GetYaxis()->SetLabelSize(0.025);
4447  Ghe5->Draw("Error");
4448  //================
4449  cRBX31->cd(2);
4450  TH2F *Ghe60 = new TH2F("Ghe60", "", 22, -11., 11., 18, 0., 18.);
4451  TH2F *Ghe61 = new TH2F("Ghe61", "", 22, -11., 11., 18, 0., 18.);
4452  TH2F *Ghe6 = new TH2F("Ghe6", "", 22, -11., 11., 18, 0., 18.);
4453 
4454  TH2F *G20he60 = new TH2F("G20he60", "", 22, -11., 11., 18, 0., 18.);
4455  TH2F *G20he61 = new TH2F("G20he61", "", 22, -11., 11., 18, 0., 18.);
4456  TH2F *G20he6 = new TH2F("G20he6", "", 22, -11., 11., 18, 0., 18.);
4457  TH2F *G30he60 = new TH2F("G30he60", "", 22, -11., 11., 18, 0., 18.);
4458  TH2F *G30he61 = new TH2F("G30he61", "", 22, -11., 11., 18, 0., 18.);
4459  TH2F *G30he6 = new TH2F("G30he6", "", 22, -11., 11., 18, 0., 18.);
4460  TH2F *G40he60 = new TH2F("G40he60", "", 22, -11., 11., 18, 0., 18.);
4461  TH2F *G40he61 = new TH2F("G40he61", "", 22, -11., 11., 18, 0., 18.);
4462  TH2F *G40he6 = new TH2F("G40he6", "", 22, -11., 11., 18, 0., 18.);
4463  // j - etaphi index; i - # LSs;
4464  //
4465  // define mean and RMS:
4466  double sumjHE = 0.;
4467  int njHE = 0;
4468  double meanjHE = 0.;
4469  for (int j = 1; j <= ny; j++) {
4470  ccc0HE = Ghe1->GetBinContent(1, j);
4471  if (ccc0HE <= 0.)
4472  for (int i = 1; i <= nx; i++) {
4473  double ccc2 = Ghe1->GetBinContent(i, j);
4474  if (ccc2 > 0.) {
4475  ccc0HE = ccc2;
4476  break;
4477  }
4478  }
4479  if (ccc0HE > 0.) {
4480  for (int i = 1; i <= nx; i++) {
4481  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4482  if (ccc1 > 0.) {
4483  sumjHE += ccc1;
4484  njHE++;
4485  }
4486  }
4487  meanjHE = sumjHE / njHE;
4488  }
4489  } // j
4490 
4491  double ssumjHE = 0.;
4492  njHE = 0;
4493  double sigmajHE = 0.;
4494  for (int j = 1; j <= ny; j++) {
4495  ccc0HE = Ghe1->GetBinContent(1, j);
4496  if (ccc0HE <= 0.)
4497  for (int i = 1; i <= nx; i++) {
4498  double ccc2 = Ghe1->GetBinContent(i, j);
4499  if (ccc2 > 0.) {
4500  ccc0HE = ccc2;
4501  break;
4502  }
4503  }
4504  if (ccc0HE > 0.) {
4505  for (int i = 1; i <= nx; i++) {
4506  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4507  if (ccc1 > 0.) {
4508  ssumjHE += (ccc1 - meanjHE) * (ccc1 - meanjHE);
4509  njHE++;
4510  }
4511  }
4512  sigmajHE = sqrt(ssumjHE / njHE);
4513  }
4514  } // j
4515 
4516  double dif3rmsHEMIN = meanjHE - 3 * sigmajHE;
4517  if (dif3rmsHEMIN < 0.)
4518  dif3rmsHEMIN = 0.;
4519  double dif3rmsHEMAX = meanjHE + 3 * sigmajHE;
4520  cout << "22HE-2 meanjHE= " << meanjHE << " sigmajHE= " << sigmajHE << " dif3rmsHEMIN= " << dif3rmsHEMIN
4521  << " dif3rmsHEMAX= " << dif3rmsHEMAX << endl;
4522 
4523  double MAXdif3rmsHEMIN = dif3rmsHEMIN;
4524  double MINdif3rmsHEMAX = dif3rmsHEMAX;
4525  if (MAXdif3rmsHEMIN < 0.95)
4526  MAXdif3rmsHEMIN = 0.95;
4527  if (MINdif3rmsHEMAX > 1.05)
4528  MINdif3rmsHEMAX = 1.05;
4529  cout << "22HE-2 MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4530  //
4531  for (int j = 1; j <= ny; j++) {
4532  ccc0HE = Ghe1->GetBinContent(1, j);
4533  if (ccc0HE <= 0.)
4534  for (int i = 1; i <= nx; i++) {
4535  double ccc2 = Ghe1->GetBinContent(i, j);
4536  if (ccc2 > 0.) {
4537  ccc0HE = ccc2;
4538  break;
4539  }
4540  }
4541  if (ccc0HE > 0.) {
4542  int jeta = (j - 1) / 18; // jeta = 0-21
4543  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
4544  // i - # LSs:
4545  for (int i = 1; i <= nx; i++) {
4546  double ccc1 = Ghe1->GetBinContent(i, j);
4547  if (ccc1 > 0.) {
4548  double Rij = ccc1 / ccc0HE;
4549  if (Rij < MAXdif3rmsHEMIN || Rij > MINdif3rmsHEMAX) {
4550  Ghe61->Fill(jeta - 11, jphi, Rij);
4551  Ghe60->Fill(jeta - 11, jphi, 1.);
4552  }
4553  if (Rij < 0.8 || Rij > 1.2) {
4554  G20he61->Fill(jeta - 11, jphi, Rij);
4555  G20he60->Fill(jeta - 11, jphi, 1.);
4556  }
4557  if (Rij < 0.7 || Rij > 1.3) {
4558  G30he61->Fill(jeta - 11, jphi, Rij);
4559  G30he60->Fill(jeta - 11, jphi, 1.);
4560  }
4561  if (Rij < 0.6 || Rij > 1.4) {
4562  G40he61->Fill(jeta - 11, jphi, Rij);
4563  G40he60->Fill(jeta - 11, jphi, 1.);
4564  }
4565  } //if(ccc1>0.
4566  } // i
4567  } //if(ccc0HE>0
4568  } // j
4569  Ghe6->Divide(Ghe61, Ghe60, 1, 1, "B"); // average R
4570  G20he6->Divide(G20he61, G20he60, 1, 1, "B"); // average R
4571  G30he6->Divide(G30he61, G30he60, 1, 1, "B"); // average R
4572  G40he6->Divide(G40he61, G40he60, 1, 1, "B"); // average R
4573 
4574  // Ghe6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
4575  // Ghe6->GetZaxis()->SetLabelOffset(-0.05);
4576  Ghe6->GetZaxis()->SetLabelSize(0.025);
4577 
4578  Ghe6->SetXTitle(" #eta \b");
4579  Ghe6->SetYTitle(" #phi \b");
4580  Ghe6->SetTitle(
4581  "<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);
4582  //gStyle->SetOptStat(kFALSE);
4583  Ghe6->SetStats(0);
4584  Ghe6->Draw("COLZ");
4585  //================
4586  cRBX31->cd(3);
4587  TH1F *Ghe7 = new TH1F("Ghe7", "", 120, 0.4, 1.6);
4588  // j - etaphi index:
4589  for (int j = 1; j <= ny; j++) {
4590  ccc0HE = Ghe1->GetBinContent(1, j);
4591  if (ccc0HE <= 0.)
4592  for (int i = 1; i <= nx; i++) {
4593  double ccc2 = Ghe1->GetBinContent(i, j);
4594  if (ccc2 > 0.) {
4595  ccc0HE = ccc2;
4596  break;
4597  }
4598  }
4599  if (ccc0HE > 0.) {
4600  // i - # LSs:
4601  for (int i = 1; i <= nx; i++) {
4602  double ccc1 = Ghe1->GetBinContent(i, j);
4603  if (ccc1 > 0.) {
4604  double Rij = ccc1 / ccc0HE;
4605  Ghe7->Fill(Rij);
4606  }
4607  }
4608  }
4609  }
4610  Ghe7->SetMarkerStyle(20);
4611  Ghe7->SetMarkerSize(0.4);
4612  Ghe7->GetYaxis()->SetLabelSize(0.04);
4613  Ghe7->SetMarkerColor(2);
4614  Ghe7->SetLineColor(0);
4615  Ghe7->SetYTitle(" N \b");
4616  Ghe7->SetXTitle(" Rij \b");
4617  Ghe7->SetTitle(" Rij \b");
4618  //Ghe7->SetMinimum(0.8);Ghe7->SetMaximum(500.);
4619  gPad->SetGridy();
4620  gPad->SetGridx(); // gPad->SetLogy();
4621  // Ghe7->SetStats(1110000);
4622  Ghe7->GetYaxis()->SetLabelSize(0.025);
4623  Ghe7->Draw("Error");
4624  Float_t ymaxHE = Ghe7->GetMaximum();
4625  cout << "22HE-3 ymaxHE= " << ymaxHE << " MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN
4626  << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4627  TLine *lineHE = new TLine(MAXdif3rmsHEMIN, 0., MAXdif3rmsHEMIN, ymaxHE);
4628  lineHE->SetLineColor(kBlue);
4629  lineHE->Draw();
4630  TLine *line1HE = new TLine(MINdif3rmsHEMAX, 0., MINdif3rmsHEMAX, ymaxHE);
4631  line1HE->SetLineColor(kBlue);
4632  line1HE->Draw();
4633  //================
4635  cRBX31->Update();
4636  cRBX31->Print("RBX-HE-3plots.png");
4637  cRBX31->Clear();
4638  // clean-up
4639  if (Ghe5)
4640  delete Ghe5;
4641  if (Ghe60)
4642  delete Ghe60;
4643  if (Ghe61)
4644  delete Ghe61;
4645  if (Ghe6)
4646  delete Ghe6;
4647  if (Ghe7)
4648  delete Ghe7;
4649 
4650  if (G20he60)
4651  delete G20he60;
4652  if (G20he61)
4653  delete G20he61;
4654  if (G30he60)
4655  delete G30he60;
4656  if (G30he61)
4657  delete G30he61;
4658  if (G40he60)
4659  delete G40he60;
4660  if (G40he61)
4661  delete G40he61;
4662 
4663  if (Ghe1)
4664  delete Ghe1;
4665  //========================================================================================== 22-1 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4666  //======================================================================
4667  //======================================================================28.11.2018
4668  //======================================================================
4669  //======================================================================
4670 
4671  gStyle->SetOptStat(1110000);
4672  cout << " RBX HE Ratio plotsmore *****" << endl;
4673  cRBX31->Clear();
4675  cRBX31->Divide(3, 1);
4676  //================
4677  cRBX31->cd(1);
4678  G20he6->GetZaxis()->SetLabelSize(0.025);
4679  G20he6->SetXTitle(" #eta \b");
4680  G20he6->SetYTitle(" #phi \b");
4681  G20he6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4682  G20he6->SetStats(0);
4683  G20he6->Draw("COLZ");
4684  //================
4685  cRBX31->cd(2);
4686  G30he6->GetZaxis()->SetLabelSize(0.025);
4687  G30he6->SetXTitle(" #eta \b");
4688  G30he6->SetYTitle(" #phi \b");
4689  G30he6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4690  G30he6->SetStats(0);
4691  G30he6->Draw("COLZ");
4692  //================
4693  cRBX31->cd(3);
4694  G40he6->GetZaxis()->SetLabelSize(0.025);
4695  G40he6->SetXTitle(" #eta \b");
4696  G40he6->SetYTitle(" #phi \b");
4697  G40he6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4698  G40he6->SetStats(0);
4699  G40he6->Draw("COLZ");
4700  //================
4701 
4703  cRBX31->Update();
4704  cRBX31->Print("RBX-HE-3plotsmore.png");
4705  cRBX31->Clear();
4706 
4707  // clean-up
4708  if (G20he6)
4709  delete G20he6;
4710  if (G30he6)
4711  delete G30he6;
4712  if (G40he6)
4713  delete G40he6;
4714  gStyle->SetOptStat(0);
4716 
4717  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4718  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4719  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4720  for (int jphi = 0; jphi < njphi; jphi++) {
4721  for (int jeta = 0; jeta < njeta; jeta++) {
4722  for (int i = 0; i < nx; i++) {
4723  alexall[jeta][jphi][i] = 0.;
4724  }
4725  }
4726  } // nulling
4727 
4729 
4731  //======================================================================
4732  //======================================================================
4733  //======================================================================
4734  cout << " RBX general for HO **************************" << endl;
4735  TH2F *Gho1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs2");
4736  TH2F *Gho1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs20");
4737  TH2F *Gho1 = (TH2F *)Gho1LLL->Clone("Gho1");
4738  Gho1->Divide(Gho1KKK, Gho1LLL, 1, 1, "B"); // average A
4739  // Gho1->Sumw2();
4740  // int nx = Gho1->GetXaxis()->GetNbins(); // # LS
4741  // nx = maxbinsRBX; // # LS
4742  ny = Gho1->GetYaxis()->GetNbins(); // # jetaphi indexes
4743  for (int j = 1; j <= ny; j++) {
4744  int jeta = (j - 1) / njphi; // jeta = 0-21
4745  if (jeta < 15 && jeta > 6) {
4746  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4747  // cout<<"HO 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4748  // over LS:
4749  for (int i = 1; i <= nx; i++) {
4750  double ccc1 = Gho1->GetBinContent(i, j);
4751  alexall[jeta][jphi][i - 1] = ccc1;
4752  // if( i == 1 ) cout<<"HO 54 for LS=1 ccc1= "<< ccc1 <<endl;
4753  } //i
4754  } //if
4755  } //j
4756  // clean-up
4757  if (Gho1KKK)
4758  delete Gho1KKK;
4759  if (Gho1LLL)
4760  delete Gho1LLL;
4761  // if (Gho1) delete Gho1;
4762 
4763  //====================================================================== alexho[k][i]
4764  for (int jphi = 0; jphi < njphi; jphi++) {
4765  for (int i = 0; i < nx; i++) {
4766  double sumccc1 = 0.;
4767  int isum = 0;
4768  for (int jeta = 0; jeta < njeta; jeta++) {
4769  double ccc1 = alexall[jeta][jphi][i];
4770  if (ccc1 > 0.) {
4771  sumccc1 += ccc1;
4772  isum++;
4773  }
4774  } // for jeta
4775  if (isum > 0.)
4776  sumccc1 /= isum;
4777  alexho[jphi][i] = sumccc1;
4778  }
4779  } //for for
4780  //====================================================================== blexho[k][i]
4781  for (int keta = 0; keta < njeta; keta++) {
4782  for (int i = 0; i < nx; i++) {
4783  double sumccc1 = 0.;
4784  int isum = 0;
4785  for (int kphi = 0; kphi < njphi; kphi++) {
4786  double ccc1 = alexall[keta][kphi][i];
4787  if (ccc1 > 0.) {
4788  sumccc1 += ccc1;
4789  isum++;
4790  }
4791  } // for kphi
4792  if (isum > 0.)
4793  sumccc1 /= isum;
4794  blexho[keta][i] = sumccc1;
4795  }
4796  } //for for
4797 
4799  //========================================================================================== 33 HO:: 2D jeta = 0 - 21 jphi =0 - 17
4800  //======================================================================
4801  //======================================================================
4802  //======================================================================
4803  //======================================================================
4804  cout << " RBX HO 2D plot *****" << endl;
4805  cRBX1->Clear();
4807  cRBX1->Divide(1, 1);
4808  cRBX1->cd(1);
4809  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4810  TH2F *Gho42D = new TH2F("Gho42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4811  TH2F *Gho42D0 = new TH2F("Gho42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4812  // TH2F* Gho42D = new TH2F("Gho42D","", 22, -11., 11., 18, 0., 18. );
4813  // TH2F* Gho42D0 = new TH2F("Gho42D0","", 22, -11., 11., 18, 0., 18. );
4814  TH2F *Gho42DF = (TH2F *)Gho42D0->Clone("Gho42DF");
4815  for (int jphi = 0; jphi < njphi; jphi++) {
4816  for (int jeta = 0; jeta < njeta; jeta++) {
4817  for (int i = 0; i < nx; i++) {
4818  double ccc1 = alexall[jeta][jphi][i];
4819  int neweta = jeta - 11 - 0.5;
4820  if (jeta >= 11)
4821  neweta = jeta - 11 + 1.5;
4822  if (ccc1 > 0.) {
4823  Gho42D->Fill(neweta, jphi, ccc1);
4824  Gho42D0->Fill(neweta, jphi, 1.);
4825  }
4826  // if(ccc1>0.) {Gho42D ->Fill(jeta-11,jphi,ccc1); Gho42D0 ->Fill(jeta-11,jphi,1.); }
4827  }
4828  }
4829  }
4830  Gho42DF->Divide(Gho42D, Gho42D0, 1, 1, "B"); // average A
4831  // Gho1->Sumw2();
4832  gPad->SetGridy();
4833  gPad->SetGridx(); // gPad->SetLogz();
4834  Gho42DF->SetMarkerStyle(20);
4835  Gho42DF->SetMarkerSize(0.4);
4836  Gho42DF->GetZaxis()->SetLabelSize(0.04);
4837  Gho42DF->SetXTitle("<A>_RBX #eta \b");
4838  Gho42DF->SetYTitle(" #phi \b");
4839  Gho42DF->SetZTitle("<A>_RBX - All \b");
4840  Gho42DF->SetMarkerColor(2);
4841  Gho42DF->SetLineColor(2); // Gho42DF->SetMaximum(1.000); // Gho42DF->SetMinimum(1.0);
4842  Gho42DF->Draw("COLZ");
4843 
4845  cRBX1->Update();
4846  cRBX1->Print("RBX-HO-2Dplot.png");
4847  cRBX1->Clear();
4848  // clean-up
4849  if (Gho42D)
4850  delete Gho42D;
4851  if (Gho42D0)
4852  delete Gho42D0;
4853  if (Gho42DF)
4854  delete Gho42DF;
4855 
4856  //========================================================================================== 61 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4857  //======================================================================
4858  //======================================================================
4859  //======================================================================
4860  //======================================================================
4861  cout << " RBX HO 1D plot *****" << endl;
4862  cRBX1->Clear();
4864  cRBX1->Divide(1, 1);
4865  cRBX1->cd(1);
4866  TH1F *GphiHO1D = new TH1F("GphiHO1D", "", 18, 0., 18.);
4867  TH1F *GphiHO1D0 = new TH1F("GphiHO1D0", "", 18, 0., 18.);
4868  TH1F *GphiHO1DF = (TH1F *)GphiHO1D0->Clone("GphiHO1DF");
4869  for (int jphi = 0; jphi < 18; jphi++) {
4870  for (int jeta = 0; jeta < 22; jeta++) {
4871  for (int i = 0; i < nx; i++) {
4872  double ccc1 = alexall[jeta][jphi][i];
4873  if (ccc1 > 0.) {
4874  GphiHO1D->Fill(jphi, ccc1);
4875  GphiHO1D0->Fill(jphi, 1.);
4876  }
4877  }
4878  }
4879  }
4880  // GphiHO1D->Sumw2();GphiHO1D0->Sumw2();
4881  GphiHO1DF->Divide(GphiHO1D, GphiHO1D0, 1, 1, "B"); // average A
4882  // GphiHO1DF->Sumw2();
4883  for (int jphi = 1; jphi < 19; jphi++) {
4884  GphiHO1DF->SetBinError(jphi, 0.01);
4885  }
4886  gPad->SetGridy();
4887  gPad->SetGridx(); // gPad->SetLogz();
4888  GphiHO1DF->SetMarkerStyle(20);
4889  GphiHO1DF->SetMarkerSize(1.4);
4890  GphiHO1DF->GetZaxis()->SetLabelSize(0.08);
4891  GphiHO1DF->SetXTitle("PHI of RBX\b");
4892  GphiHO1DF->SetYTitle(" <Amplitude> \b");
4893  GphiHO1DF->SetZTitle("<A>_PHI - All \b");
4894  GphiHO1DF->SetMarkerColor(4);
4895  GphiHO1DF->SetLineColor(4);
4896  GphiHO1DF->SetMinimum(0.8); // GphiHO1DF->SetMaximum(1.000);
4897  GphiHO1DF->Draw("Error");
4899  cRBX1->Update();
4900  cRBX1->Print("RBX-HO-1Dplot.png");
4901  cRBX1->Clear();
4902  // clean-up
4903  if (GphiHO1D)
4904  delete GphiHO1D;
4905  if (GphiHO1D0)
4906  delete GphiHO1D0;
4907  if (GphiHO1DF)
4908  delete GphiHO1DF;
4909 
4910  //========================================================================================== 62 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4911  //======================================================================
4912  //======================================================================
4913  //======================================================================
4914  //======================================================================
4915  cout << " RBX HO 11D plot *eta*" << endl;
4916  cRBX1->Clear();
4918  cRBX1->Divide(1, 1);
4919  cRBX1->cd(1);
4920  TH1F *GetaHO11D = new TH1F("GetaHO11D", "", 23, -11.5, 11.5);
4921  TH1F *GetaHO11D0 = new TH1F("GetaHO11D0", "", 23, -11.5, 11.5);
4922  TH1F *GetaHO11DF = (TH1F *)GetaHO11D0->Clone("GetaHO11DF");
4923 
4924  for (int jeta = 0; jeta < 22; jeta++) {
4925  for (int jphi = 0; jphi < 18; jphi++) {
4926  for (int i = 0; i < nx; i++) {
4927  double ccc1 = alexall[jeta][jphi][i];
4928  int neweta = jeta - 11 - 0.5;
4929  if (jeta >= 11)
4930  neweta = jeta - 11 + 1.5;
4931  if (ccc1 > 0.) {
4932  GetaHO11D->Fill(neweta, ccc1);
4933  GetaHO11D0->Fill(neweta, 1.);
4934  // if( i == 0 ) cout<<"62 HO: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4935  }
4936  }
4937  }
4938  }
4939  // GetaHO11D->Sumw2();GetaHO11D0->Sumw2();
4940  GetaHO11DF->Divide(GetaHO11D, GetaHO11D0, 1, 1, "B"); // average A
4941  // GetaHO11DF->Sumw2();
4942  for (int jeta = 1; jeta < 24; jeta++) {
4943  GetaHO11DF->SetBinError(jeta, 0.01);
4944  }
4945  gPad->SetGridy();
4946  gPad->SetGridx(); // gPad->SetLogz();
4947  GetaHO11DF->SetMarkerStyle(20);
4948  GetaHO11DF->SetMarkerSize(1.4);
4949  GetaHO11DF->GetZaxis()->SetLabelSize(0.08);
4950  GetaHO11DF->SetXTitle("#eta \b");
4951  GetaHO11DF->SetYTitle(" <A> \b");
4952  GetaHO11DF->SetZTitle("<A>_ETA - All \b");
4953  GetaHO11DF->SetMarkerColor(4);
4954  GetaHO11DF->SetLineColor(4);
4955  GetaHO11DF->SetMinimum(0.8); // GetaHO11DF->SetMaximum(1.000);
4956  GetaHO11DF->Draw("Error");
4957 
4959  cRBX1->Update();
4960  cRBX1->Print("RBX-HO-11Dplot.png");
4961  cRBX1->Clear();
4962  // clean-up
4963  if (GetaHO11D)
4964  delete GetaHO11D;
4965  if (GetaHO11D0)
4966  delete GetaHO11D0;
4967  if (GetaHO11DF)
4968  delete GetaHO11DF;
4969 
4970  //========================================================================================== 22 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4971  //======================================================================
4972  //======================================================================22.11.2018
4973  //======================================================================
4974  //======================================================================
4975 
4976  gStyle->SetOptStat(1110000);
4977  cout << " RBX HO Ratio plots *****" << endl;
4978  cRBX31->Clear();
4980  // gain stabilitY:
4981  // Rij = Aij / A1j , where i-over LSs, j-channels
4982  //
4983  // nx = maxbinsRBX; // # LS
4984  //
4985  double ccc0HO = 0.;
4986  cRBX31->Divide(3, 1);
4987  //================
4988  cRBX31->cd(1);
4989  // TH1F* Gho5 = new TH1F("Gho5","", nx, 1., nx+1.);
4990  TH1F *Gho51 = new TH1F("Gho51", "", nx, 1., nx + 1.);
4991  TH1F *Gho50 = new TH1F("Gho50", "", nx, 1., nx + 1.);
4992  TH1F *Gho5 = (TH1F *)Gho50->Clone("Gho5");
4993  // j - etaphi index:
4994  for (int j = 1; j <= ny; j++) {
4995  ccc0HO = Gho1->GetBinContent(1, j);
4996  // 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;} }
4997  if (ccc0HO <= 0.)
4998  for (int i = 1; i <= nx; i++) {
4999  double ccc2 = Gho1->GetBinContent(i, j);
5000  if (ccc2 > 0.) {
5001  ccc0HO = ccc2;
5002  break;
5003  }
5004  }
5005  if (ccc0HO > 0.) {
5006  // i - # LSs:
5007  for (int i = 1; i <= nx; i++) {
5008  double ccc1 = Gho1->GetBinContent(i, j);
5009  if (ccc1 > 0.) {
5010  double Rij = ccc1 / ccc0HO;
5011  // Gho5 ->Fill( float(i), Rij);
5012  Gho51->Fill(float(i), Rij);
5013  Gho50->Fill(float(i), 1.);
5014  }
5015  }
5016  }
5017  }
5018  Gho5->Divide(Gho51, Gho50, 1, 1, "B"); // average A
5019  for (int i = 1; i <= nx; i++) {
5020  Gho5->SetBinError(i, 0.0001);
5021  }
5022  Gho5->SetMarkerStyle(20);
5023  Gho5->SetMarkerSize(0.4);
5024  Gho5->GetYaxis()->SetLabelSize(0.04);
5025  Gho5->SetMarkerColor(2);
5026  Gho5->SetLineColor(0);
5027  Gho5->SetXTitle(" iLS \b");
5028  Gho5->SetYTitle(" <R> \b");
5029  Gho5->SetTitle("<Ri> vs iLS \b");
5030  Gho5->SetMinimum(0.); //Gho5->SetMaximum(2.5);
5031  // gPad->SetLogy();
5032  gPad->SetGridy();
5033  gPad->SetGridx();
5034  Gho5->SetStats(0);
5035  Gho5->GetYaxis()->SetLabelSize(0.025);
5036  Gho5->Draw("Error");
5037  //================
5038  cRBX31->cd(2);
5039  TH2F *Gho60 = new TH2F("Gho60", "", 22, -11., 11., 18, 0., 18.);
5040  TH2F *Gho61 = new TH2F("Gho61", "", 22, -11., 11., 18, 0., 18.);
5041  TH2F *Gho6 = new TH2F("Gho6", "", 22, -11., 11., 18, 0., 18.);
5042 
5043  TH2F *G20ho60 = new TH2F("G20ho60", "", 22, -11., 11., 18, 0., 18.);
5044  TH2F *G20ho61 = new TH2F("G20ho61", "", 22, -11., 11., 18, 0., 18.);
5045  TH2F *G20ho6 = new TH2F("G20ho6", "", 22, -11., 11., 18, 0., 18.);
5046  TH2F *G30ho60 = new TH2F("G30ho60", "", 22, -11., 11., 18, 0., 18.);
5047  TH2F *G30ho61 = new TH2F("G30ho61", "", 22, -11., 11., 18, 0., 18.);
5048  TH2F *G30ho6 = new TH2F("G30ho6", "", 22, -11., 11., 18, 0., 18.);
5049  TH2F *G40ho60 = new TH2F("G40ho60", "", 22, -11., 11., 18, 0., 18.);
5050  TH2F *G40ho61 = new TH2F("G40ho61", "", 22, -11., 11., 18, 0., 18.);
5051  TH2F *G40ho6 = new TH2F("G40ho6", "", 22, -11., 11., 18, 0., 18.);
5052 
5053  // j - etaphi index; i - # LSs;
5054  //
5055  // define mean and RMS:
5056  double sumjHO = 0.;
5057  int njHO = 0;
5058  double meanjHO = 0.;
5059  for (int j = 1; j <= ny; j++) {
5060  ccc0HO = Gho1->GetBinContent(1, j);
5061  if (ccc0HO <= 0.)
5062  for (int i = 1; i <= nx; i++) {
5063  double ccc2 = Gho1->GetBinContent(i, j);
5064  if (ccc2 > 0.) {
5065  ccc0HO = ccc2;
5066  break;
5067  }
5068  }
5069  if (ccc0HO > 0.) {
5070  for (int i = 1; i <= nx; i++) {
5071  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5072  if (ccc1 > 0.) {
5073  sumjHO += ccc1;
5074  njHO++;
5075  }
5076  }
5077  meanjHO = sumjHO / njHO;
5078  }
5079  } // j
5080 
5081  double ssumjHO = 0.;
5082  njHO = 0;
5083  double sigmajHO = 0.;
5084  for (int j = 1; j <= ny; j++) {
5085  ccc0HO = Gho1->GetBinContent(1, j);
5086  if (ccc0HO <= 0.)
5087  for (int i = 1; i <= nx; i++) {
5088  double ccc2 = Gho1->GetBinContent(i, j);
5089  if (ccc2 > 0.) {
5090  ccc0HO = ccc2;
5091  break;
5092  }
5093  }
5094  if (ccc0HO > 0.) {
5095  for (int i = 1; i <= nx; i++) {
5096  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5097  if (ccc1 > 0.) {
5098  ssumjHO += (ccc1 - meanjHO) * (ccc1 - meanjHO);
5099  njHO++;
5100  }
5101  }
5102  sigmajHO = sqrt(ssumjHO / njHO);
5103  }
5104  } // j
5105 
5106  double dif3rmsHOMIN = meanjHO - 3 * sigmajHO;
5107  if (dif3rmsHOMIN < 0.)
5108  dif3rmsHOMIN = 0.;
5109  double dif3rmsHOMAX = meanjHO + 3 * sigmajHO;
5110  cout << "22HO-2 meanjHO= " << meanjHO << " sigmajHO= " << sigmajHO << " dif3rmsHOMIN= " << dif3rmsHOMIN
5111  << " dif3rmsHOMAX= " << dif3rmsHOMAX << endl;
5112 
5113  double MAXdif3rmsHOMIN = dif3rmsHOMIN;
5114  double MINdif3rmsHOMAX = dif3rmsHOMAX;
5115  if (MAXdif3rmsHOMIN < 0.95)
5116  MAXdif3rmsHOMIN = 0.95;
5117  if (MINdif3rmsHOMAX > 1.05)
5118  MINdif3rmsHOMAX = 1.05;
5119  cout << "22HO-2 MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5120  //
5121  for (int j = 1; j <= ny; j++) {
5122  ccc0HO = Gho1->GetBinContent(1, j);
5123  if (ccc0HO <= 0.)
5124  for (int i = 1; i <= nx; i++) {
5125  double ccc2 = Gho1->GetBinContent(i, j);
5126  if (ccc2 > 0.) {
5127  ccc0HO = ccc2;
5128  break;
5129  }
5130  }
5131  if (ccc0HO > 0.) {
5132  int jeta = (j - 1) / 18; // jeta = 0-21
5133  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5134  // i - # LSs:
5135  for (int i = 1; i <= nx; i++) {
5136  double ccc1 = Gho1->GetBinContent(i, j);
5137  if (ccc1 > 0.) {
5138  double Rij = ccc1 / ccc0HO;
5139  if (Rij < MAXdif3rmsHOMIN || Rij > MINdif3rmsHOMAX) {
5140  Gho61->Fill(jeta - 11, jphi, Rij);
5141  Gho60->Fill(jeta - 11, jphi, 1.);
5142  }
5143  if (Rij < 0.8 || Rij > 1.2) {
5144  G20ho61->Fill(jeta - 11, jphi, Rij);
5145  G20ho60->Fill(jeta - 11, jphi, 1.);
5146  }
5147  if (Rij < 0.7 || Rij > 1.3) {
5148  G30ho61->Fill(jeta - 11, jphi, Rij);
5149  G30ho60->Fill(jeta - 11, jphi, 1.);
5150  }
5151  if (Rij < 0.6 || Rij > 1.4) {
5152  G40ho61->Fill(jeta - 11, jphi, Rij);
5153  G40ho60->Fill(jeta - 11, jphi, 1.);
5154  }
5155  } //if(ccc1>0.
5156  } // i
5157  } //if(ccc0HO>0
5158  } // j
5159  Gho6->Divide(Gho61, Gho60, 1, 1, "B"); // average R
5160  G20ho6->Divide(G20ho61, G20ho60, 1, 1, "B"); // average R
5161  G30ho6->Divide(G30ho61, G30ho60, 1, 1, "B"); // average R
5162  G40ho6->Divide(G40ho61, G40ho60, 1, 1, "B"); // average R
5163  // Gho6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5164  // Gho6->GetZaxis()->SetLabelOffset(-0.05);
5165  Gho6->GetZaxis()->SetLabelSize(0.025);
5166 
5167  Gho6->SetXTitle(" #eta \b");
5168  Gho6->SetYTitle(" #phi \b");
5169  Gho6->SetTitle(
5170  "<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);
5171  //gStyle->SetOptStat(kFALSE);
5172  Gho6->SetStats(0);
5173  Gho6->Draw("COLZ");
5174  //================
5175  cRBX31->cd(3);
5176  TH1F *Gho7 = new TH1F("Gho7", "", 120, 0.4, 1.6);
5177  // j - etaphi index:
5178  for (int j = 1; j <= ny; j++) {
5179  ccc0HO = Gho1->GetBinContent(1, j);
5180  if (ccc0HO <= 0.)
5181  for (int i = 1; i <= nx; i++) {
5182  double ccc2 = Gho1->GetBinContent(i, j);
5183  if (ccc2 > 0.) {
5184  ccc0HO = ccc2;
5185  break;
5186  }
5187  }
5188  if (ccc0HO > 0.) {
5189  // i - # LSs:
5190  for (int i = 1; i <= nx; i++) {
5191  double ccc1 = Gho1->GetBinContent(i, j);
5192  if (ccc1 > 0.) {
5193  double Rij = ccc1 / ccc0HO;
5194  Gho7->Fill(Rij);
5195  }
5196  }
5197  }
5198  }
5199  Gho7->SetMarkerStyle(20);
5200  Gho7->SetMarkerSize(0.4);
5201  Gho7->GetYaxis()->SetLabelSize(0.04);
5202  Gho7->SetMarkerColor(2);
5203  Gho7->SetLineColor(0);
5204  Gho7->SetYTitle(" N \b");
5205  Gho7->SetXTitle(" Rij \b");
5206  Gho7->SetTitle(" Rij \b");
5207  //Gho7->SetMinimum(0.8);Gho7->SetMaximum(500.);
5208  gPad->SetGridy();
5209  gPad->SetGridx(); // gPad->SetLogy();
5210  // Gho7->SetStats(1110000);
5211  Gho7->GetYaxis()->SetLabelSize(0.025);
5212  Gho7->Draw("Error");
5213  Float_t ymaxHO = Gho7->GetMaximum();
5214  cout << "22HO-3 ymaxHO= " << ymaxHO << " MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN
5215  << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5216  TLine *lineHO = new TLine(MAXdif3rmsHOMIN, 0., MAXdif3rmsHOMIN, ymaxHO);
5217  lineHO->SetLineColor(kBlue);
5218  lineHO->Draw();
5219  TLine *line1HO = new TLine(MINdif3rmsHOMAX, 0., MINdif3rmsHOMAX, ymaxHO);
5220  line1HO->SetLineColor(kBlue);
5221  line1HO->Draw();
5222  //================
5224  cRBX31->Update();
5225  cRBX31->Print("RBX-HO-3plots.png");
5226  cRBX31->Clear();
5227  // clean-up
5228  if (Gho5)
5229  delete Gho5;
5230  if (Gho60)
5231  delete Gho60;
5232  if (Gho61)
5233  delete Gho61;
5234  if (Gho6)
5235  delete Gho6;
5236  if (Gho7)
5237  delete Gho7;
5238 
5239  if (G20ho60)
5240  delete G20ho60;
5241  if (G20ho61)
5242  delete G20ho61;
5243  if (G30ho60)
5244  delete G30ho60;
5245  if (G30ho61)
5246  delete G30ho61;
5247  if (G40ho60)
5248  delete G40ho60;
5249  if (G40ho61)
5250  delete G40ho61;
5251 
5252  if (Gho1)
5253  delete Gho1;
5254  //========================================================================================== 22-1 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5255  //======================================================================
5256  //======================================================================28.11.2018
5257  //======================================================================
5258  //======================================================================
5259 
5260  gStyle->SetOptStat(1110000);
5261  cout << " RBX HO Ratio plotsmore *****" << endl;
5262  cRBX31->Clear();
5264  cRBX31->Divide(3, 1);
5265  //================
5266  cRBX31->cd(1);
5267  G20ho6->GetZaxis()->SetLabelSize(0.025);
5268  G20ho6->SetXTitle(" #eta \b");
5269  G20ho6->SetYTitle(" #phi \b");
5270  G20ho6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5271  G20ho6->SetStats(0);
5272  G20ho6->Draw("COLZ");
5273  //================
5274  cRBX31->cd(2);
5275  G30ho6->GetZaxis()->SetLabelSize(0.025);
5276  G30ho6->SetXTitle(" #eta \b");
5277  G30ho6->SetYTitle(" #phi \b");
5278  G30ho6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5279  G30ho6->SetStats(0);
5280  G30ho6->Draw("COLZ");
5281  //================
5282  cRBX31->cd(3);
5283  G40ho6->GetZaxis()->SetLabelSize(0.025);
5284  G40ho6->SetXTitle(" #eta \b");
5285  G40ho6->SetYTitle(" #phi \b");
5286  G40ho6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5287  G40ho6->SetStats(0);
5288  G40ho6->Draw("COLZ");
5289  //================
5290 
5292  cRBX31->Update();
5293  cRBX31->Print("RBX-HO-3plotsmore.png");
5294  cRBX31->Clear();
5295 
5296  // clean-up
5297  if (G20ho6)
5298  delete G20ho6;
5299  if (G30ho6)
5300  delete G30ho6;
5301  if (G40ho6)
5302  delete G40ho6;
5303  gStyle->SetOptStat(0);
5305 
5306  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5307  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5308  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5309  for (int jphi = 0; jphi < njphi; jphi++) {
5310  for (int jeta = 0; jeta < njeta; jeta++) {
5311  for (int i = 0; i < nx; i++) {
5312  alexall[jeta][jphi][i] = 0.;
5313  }
5314  }
5315  } // nulling
5316 
5318 
5320  //======================================================================
5321  //======================================================================
5322  //======================================================================
5323  cout << " RBX general for HF **************************" << endl;
5324  TH2F *Ghf1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs3");
5325  TH2F *Ghf1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs30");
5326  TH2F *Ghf1 = (TH2F *)Ghf1LLL->Clone("Ghf1");
5327  Ghf1->Divide(Ghf1KKK, Ghf1LLL, 1, 1, "B"); // average A
5328  // Ghf1->Sumw2();
5329  // int nx = Ghf1->GetXaxis()->GetNbins(); // # LS
5330  // nx = maxbinsRBX; // # LS
5331  ny = Ghf1->GetYaxis()->GetNbins(); // # jetaphi indexes
5332  for (int j = 1; j <= ny; j++) {
5333  int jeta = (j - 1) / njphi; // jeta = 0-21
5334  if (jeta < 4 || jeta > 17) {
5335  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
5336  // cout<<"HF 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
5337  // over LS:
5338  for (int i = 1; i <= nx; i++) {
5339  double ccc1 = Ghf1->GetBinContent(i, j);
5340  alexall[jeta][jphi][i - 1] = ccc1;
5341  // if( i == 1 ) cout<<"HF 54 for LS=1 ccc1= "<< ccc1 <<endl;
5342  } //i
5343  } //if
5344  } //j
5345  // clean-up
5346  if (Ghf1KKK)
5347  delete Ghf1KKK;
5348  if (Ghf1LLL)
5349  delete Ghf1LLL;
5350  // if (Ghf1) delete Ghf1;
5351 
5352  //====================================================================== alexhf[k][i]
5353  for (int jphi = 0; jphi < njphi; jphi++) {
5354  for (int i = 0; i < nx; i++) {
5355  double sumccc1 = 0.;
5356  int isum = 0;
5357  for (int jeta = 0; jeta < njeta; jeta++) {
5358  double ccc1 = alexall[jeta][jphi][i];
5359  if (ccc1 > 0.) {
5360  sumccc1 += ccc1;
5361  isum++;
5362  }
5363  } // for jeta
5364  if (isum > 0.)
5365  sumccc1 /= isum;
5366  alexhf[jphi][i] = sumccc1;
5367  }
5368  } //for for
5369  //====================================================================== blexhf[k][i]
5370  for (int keta = 0; keta < njeta; keta++) {
5371  for (int i = 0; i < nx; i++) {
5372  double sumccc1 = 0.;
5373  int isum = 0;
5374  for (int kphi = 0; kphi < njphi; kphi++) {
5375  double ccc1 = alexall[keta][kphi][i];
5376  if (ccc1 > 0.) {
5377  sumccc1 += ccc1;
5378  isum++;
5379  }
5380  } // for kphi
5381  if (isum > 0.)
5382  sumccc1 /= isum;
5383  blexhf[keta][i] = sumccc1;
5384  }
5385  } //for for
5387  //========================================================================================== 60 HF:: 2D jeta = 0 - 21 jphi =0 - 17
5388  //======================================================================
5389  //======================================================================
5390  //======================================================================
5391  //======================================================================
5392  cout << " RBX HF 2D plot *****" << endl;
5393  cRBX1->Clear();
5395  cRBX1->Divide(1, 1);
5396  cRBX1->cd(1);
5397  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
5398  TH2F *Ghf42D = new TH2F("Ghf42D", "", 23, -11.5, 11.5, 18, 0., 18.);
5399  TH2F *Ghf42D0 = new TH2F("Ghf42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
5400  // TH2F* Ghf42D = new TH2F("Ghf42D","", 22, -11., 11., 18, 0., 18. );
5401  // TH2F* Ghf42D0 = new TH2F("Ghf42D0","", 22, -11., 11., 18, 0., 18. );
5402  TH2F *Ghf42DF = (TH2F *)Ghf42D0->Clone("Ghf42DF");
5403  for (int jphi = 0; jphi < njphi; jphi++) {
5404  for (int jeta = 0; jeta < njeta; jeta++) {
5405  for (int i = 0; i < nx; i++) {
5406  double ccc1 = alexall[jeta][jphi][i];
5407  int neweta = jeta - 11 - 0.5;
5408  if (jeta >= 11)
5409  neweta = jeta - 11 + 1.5;
5410  if (ccc1 > 0.) {
5411  Ghf42D->Fill(neweta, jphi, ccc1);
5412  Ghf42D0->Fill(neweta, jphi, 1.);
5413  }
5414  // if(ccc1>0.) {Ghf42D ->Fill(jeta-11,jphi,ccc1); Ghf42D0 ->Fill(jeta-11,jphi,1.); }
5415  }
5416  }
5417  }
5418  Ghf42DF->Divide(Ghf42D, Ghf42D0, 1, 1, "B"); // average A
5419  // Ghf1->Sumw2();
5420  gPad->SetGridy();
5421  gPad->SetGridx(); // gPad->SetLogz();
5422  Ghf42DF->SetMarkerStyle(20);
5423  Ghf42DF->SetMarkerSize(0.4);
5424  Ghf42DF->GetZaxis()->SetLabelSize(0.04);
5425  Ghf42DF->SetXTitle("<A>_RBX #eta \b");
5426  Ghf42DF->SetYTitle(" #phi \b");
5427  Ghf42DF->SetZTitle("<A>_RBX - All \b");
5428  Ghf42DF->SetMarkerColor(2);
5429  Ghf42DF->SetLineColor(2); // Ghf42DF->SetMaximum(1.000); // Ghf42DF->SetMinimum(1.0);
5430  Ghf42DF->Draw("COLZ");
5431 
5433  cRBX1->Update();
5434  cRBX1->Print("RBX-HF-2Dplot.png");
5435  cRBX1->Clear();
5436  // clean-up
5437  if (Ghf42D)
5438  delete Ghf42D;
5439  if (Ghf42D0)
5440  delete Ghf42D0;
5441  if (Ghf42DF)
5442  delete Ghf42DF;
5443 
5444  //========================================================================================== 61 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5445  //======================================================================
5446  //======================================================================
5447  //======================================================================
5448  //======================================================================
5449  cout << " RBX HF 1D plot *****" << endl;
5450  cRBX1->Clear();
5452  cRBX1->Divide(1, 1);
5453  cRBX1->cd(1);
5454  TH1F *GphiHF1D = new TH1F("GphiHF1D", "", 18, 0., 18.);
5455  TH1F *GphiHF1D0 = new TH1F("GphiHF1D0", "", 18, 0., 18.);
5456  TH1F *GphiHF1DF = (TH1F *)GphiHF1D0->Clone("GphiHF1DF");
5457  for (int jphi = 0; jphi < 18; jphi++) {
5458  for (int jeta = 0; jeta < 22; jeta++) {
5459  for (int i = 0; i < nx; i++) {
5460  double ccc1 = alexall[jeta][jphi][i];
5461  if (ccc1 > 0.) {
5462  GphiHF1D->Fill(jphi, ccc1);
5463  GphiHF1D0->Fill(jphi, 1.);
5464  }
5465  }
5466  }
5467  }
5468  // GphiHF1D->Sumw2();GphiHF1D0->Sumw2();
5469  GphiHF1DF->Divide(GphiHF1D, GphiHF1D0, 1, 1, "B"); // average A
5470  // GphiHF1DF->Sumw2();
5471  for (int jphi = 1; jphi < 19; jphi++) {
5472  GphiHF1DF->SetBinError(jphi, 0.01);
5473  }
5474  gPad->SetGridy();
5475  gPad->SetGridx(); // gPad->SetLogz();
5476  GphiHF1DF->SetMarkerStyle(20);
5477  GphiHF1DF->SetMarkerSize(1.4);
5478  GphiHF1DF->GetZaxis()->SetLabelSize(0.08);
5479  GphiHF1DF->SetXTitle("PHI of RBX\b");
5480  GphiHF1DF->SetYTitle(" <Amplitude> \b");
5481  GphiHF1DF->SetZTitle("<A>_PHI - All \b");
5482  GphiHF1DF->SetMarkerColor(4);
5483  GphiHF1DF->SetLineColor(4);
5484  GphiHF1DF->SetMinimum(0.8); // GphiHF1DF->SetMaximum(1.000);
5485  GphiHF1DF->Draw("Error");
5487  cRBX1->Update();
5488  cRBX1->Print("RBX-HF-1Dplot.png");
5489  cRBX1->Clear();
5490  // clean-up
5491  if (GphiHF1D)
5492  delete GphiHF1D;
5493  if (GphiHF1D0)
5494  delete GphiHF1D0;
5495  if (GphiHF1DF)
5496  delete GphiHF1DF;
5497 
5498  //========================================================================================== 62 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5499  //======================================================================
5500  //======================================================================
5501  //======================================================================
5502  //======================================================================
5503  cout << " RBX HF 11D plot *eta*" << endl;
5504  cRBX1->Clear();
5506  cRBX1->Divide(1, 1);
5507  cRBX1->cd(1);
5508  TH1F *GetaHF11D = new TH1F("GetaHF11D", "", 23, -11.5, 11.5);
5509  TH1F *GetaHF11D0 = new TH1F("GetaHF11D0", "", 23, -11.5, 11.5);
5510  TH1F *GetaHF11DF = (TH1F *)GetaHF11D0->Clone("GetaHF11DF");
5511 
5512  for (int jeta = 0; jeta < 22; jeta++) {
5513  for (int jphi = 0; jphi < 18; jphi++) {
5514  for (int i = 0; i < nx; i++) {
5515  double ccc1 = alexall[jeta][jphi][i];
5516  int neweta = jeta - 11 - 0.5;
5517  if (jeta >= 11)
5518  neweta = jeta - 11 + 1.5;
5519  if (ccc1 > 0.) {
5520  GetaHF11D->Fill(neweta, ccc1);
5521  GetaHF11D0->Fill(neweta, 1.);
5522  // if( i == 0 ) cout<<"62 HF: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
5523  }
5524  }
5525  }
5526  }
5527  // GetaHF11D->Sumw2();GetaHF11D0->Sumw2();
5528  GetaHF11DF->Divide(GetaHF11D, GetaHF11D0, 1, 1, "B"); // average A
5529  // GetaHF11DF->Sumw2();
5530  for (int jeta = 1; jeta < 24; jeta++) {
5531  GetaHF11DF->SetBinError(jeta, 0.01);
5532  }
5533  gPad->SetGridy();
5534  gPad->SetGridx(); // gPad->SetLogz();
5535  GetaHF11DF->SetMarkerStyle(20);
5536  GetaHF11DF->SetMarkerSize(1.4);
5537  GetaHF11DF->GetZaxis()->SetLabelSize(0.08);
5538  GetaHF11DF->SetXTitle("#eta \b");
5539  GetaHF11DF->SetYTitle(" <A> \b");
5540  GetaHF11DF->SetZTitle("<A>_ETA - All \b");
5541  GetaHF11DF->SetMarkerColor(4);
5542  GetaHF11DF->SetLineColor(4);
5543  GetaHF11DF->SetMinimum(0.8); // GetaHF11DF->SetMaximum(1.000);
5544  GetaHF11DF->Draw("Error");
5545 
5547  cRBX1->Update();
5548  cRBX1->Print("RBX-HF-11Dplot.png");
5549  cRBX1->Clear();
5550  // clean-up
5551  if (GetaHF11D)
5552  delete GetaHF11D;
5553  if (GetaHF11D0)
5554  delete GetaHF11D0;
5555  if (GetaHF11DF)
5556  delete GetaHF11DF;
5557 
5558  //========================================================================================== 22 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5559  //======================================================================
5560  //======================================================================22.11.2018
5561  //======================================================================
5562  //======================================================================
5563 
5564  gStyle->SetOptStat(1110000);
5565  cout << " RBX HF Ratio plots *****" << endl;
5566  cRBX31->Clear();
5568  // gain stabilitY:
5569  // Rij = Aij / A1j , where i-over LSs, j-channels
5570  //
5571  // nx = maxbinsRBX; // # LS
5572  //
5573  double ccc0HF = 0.;
5574  cRBX31->Divide(3, 1);
5575  //================
5576  cRBX31->cd(1);
5577  // TH1F* Ghf5 = new TH1F("Ghf5","", nx, 1., nx+1.);
5578  TH1F *Ghf51 = new TH1F("Ghf51", "", nx, 1., nx + 1.);
5579  TH1F *Ghf50 = new TH1F("Ghf50", "", nx, 1., nx + 1.);
5580  TH1F *Ghf5 = (TH1F *)Ghf50->Clone("Ghf5");
5581  // j - etaphi index:
5582  for (int j = 1; j <= ny; j++) {
5583  ccc0HF = Ghf1->GetBinContent(1, j);
5584  // 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;} }
5585  if (ccc0HF <= 0.)
5586  for (int i = 1; i <= nx; i++) {
5587  double ccc2 = Ghf1->GetBinContent(i, j);
5588  if (ccc2 > 0.) {
5589  ccc0HF = ccc2;
5590  break;
5591  }
5592  }
5593  if (ccc0HF > 0.) {
5594  // i - # LSs:
5595  for (int i = 1; i <= nx; i++) {
5596  double ccc1 = Ghf1->GetBinContent(i, j);
5597  if (ccc1 > 0.) {
5598  double Rij = ccc1 / ccc0HF;
5599  // Ghf5 ->Fill( float(i), Rij);
5600  Ghf51->Fill(float(i), Rij);
5601  Ghf50->Fill(float(i), 1.);
5602  }
5603  }
5604  }
5605  }
5606  Ghf5->Divide(Ghf51, Ghf50, 1, 1, "B"); // average A
5607  for (int i = 1; i <= nx; i++) {
5608  Ghf5->SetBinError(i, 0.0001);
5609  }
5610  Ghf5->SetMarkerStyle(20);
5611  Ghf5->SetMarkerSize(0.4);
5612  Ghf5->GetYaxis()->SetLabelSize(0.04);
5613  Ghf5->SetMarkerColor(2);
5614  Ghf5->SetLineColor(0);
5615  Ghf5->SetXTitle(" iLS \b");
5616  Ghf5->SetYTitle(" <R> \b");
5617  Ghf5->SetTitle("<Ri> vs iLS \b");
5618  Ghf5->SetMinimum(0.); //Ghf5->SetMaximum(2.5);
5619  // gPad->SetLogy();
5620  gPad->SetGridy();
5621  gPad->SetGridx();
5622  Ghf5->SetStats(0);
5623  Ghf5->GetYaxis()->SetLabelSize(0.025);
5624  Ghf5->Draw("Error");
5625  //================
5626  cRBX31->cd(2);
5627  TH2F *Ghf60 = new TH2F("Ghf60", "", 22, -11., 11., 18, 0., 18.);
5628  TH2F *Ghf61 = new TH2F("Ghf61", "", 22, -11., 11., 18, 0., 18.);
5629  TH2F *Ghf6 = new TH2F("Ghf6", "", 22, -11., 11., 18, 0., 18.);
5630 
5631  TH2F *G20hf60 = new TH2F("G20hf60", "", 22, -11., 11., 18, 0., 18.);
5632  TH2F *G20hf61 = new TH2F("G20hf61", "", 22, -11., 11., 18, 0., 18.);
5633  TH2F *G20hf6 = new TH2F("G20hf6", "", 22, -11., 11., 18, 0., 18.);
5634  TH2F *G30hf60 = new TH2F("G30hf60", "", 22, -11., 11., 18, 0., 18.);
5635  TH2F *G30hf61 = new TH2F("G30hf61", "", 22, -11., 11., 18, 0., 18.);
5636  TH2F *G30hf6 = new TH2F("G30hf6", "", 22, -11., 11., 18, 0., 18.);
5637  TH2F *G40hf60 = new TH2F("G40hf60", "", 22, -11., 11., 18, 0., 18.);
5638  TH2F *G40hf61 = new TH2F("G40hf61", "", 22, -11., 11., 18, 0., 18.);
5639  TH2F *G40hf6 = new TH2F("G40hf6", "", 22, -11., 11., 18, 0., 18.);
5640  // j - etaphi index; i - # LSs;
5641  //
5642  // define mean and RMS:
5643  double sumjHF = 0.;
5644  int njHF = 0;
5645  double meanjHF = 0.;
5646  for (int j = 1; j <= ny; j++) {
5647  ccc0HF = Ghf1->GetBinContent(1, j);
5648  if (ccc0HF <= 0.)
5649  for (int i = 1; i <= nx; i++) {
5650  double ccc2 = Ghf1->GetBinContent(i, j);
5651  if (ccc2 > 0.) {
5652  ccc0HF = ccc2;
5653  break;
5654  }
5655  }
5656  if (ccc0HF > 0.) {
5657  for (int i = 1; i <= nx; i++) {
5658  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5659  if (ccc1 > 0.) {
5660  sumjHF += ccc1;
5661  njHF++;
5662  }
5663  }
5664  meanjHF = sumjHF / njHF;
5665  }
5666  } // j
5667 
5668  double ssumjHF = 0.;
5669  njHF = 0;
5670  double sigmajHF = 0.;
5671  for (int j = 1; j <= ny; j++) {
5672  ccc0HF = Ghf1->GetBinContent(1, j);
5673  if (ccc0HF <= 0.)
5674  for (int i = 1; i <= nx; i++) {
5675  double ccc2 = Ghf1->GetBinContent(i, j);
5676  if (ccc2 > 0.) {
5677  ccc0HF = ccc2;
5678  break;
5679  }
5680  }
5681  if (ccc0HF > 0.) {
5682  for (int i = 1; i <= nx; i++) {
5683  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5684  if (ccc1 > 0.) {
5685  ssumjHF += (ccc1 - meanjHF) * (ccc1 - meanjHF);
5686  njHF++;
5687  }
5688  }
5689  sigmajHF = sqrt(ssumjHF / njHF);
5690  }
5691  } // j
5692 
5693  double dif3rmsHFMIN = meanjHF - 3 * sigmajHF;
5694  if (dif3rmsHFMIN < 0.)
5695  dif3rmsHFMIN = 0.;
5696  double dif3rmsHFMAX = meanjHF + 3 * sigmajHF;
5697  cout << "22HF-2 meanjHF= " << meanjHF << " sigmajHF= " << sigmajHF << " dif3rmsHFMIN= " << dif3rmsHFMIN
5698  << " dif3rmsHFMAX= " << dif3rmsHFMAX << endl;
5699 
5700  double MAXdif3rmsHFMIN = dif3rmsHFMIN;
5701  double MINdif3rmsHFMAX = dif3rmsHFMAX;
5702  if (MAXdif3rmsHFMIN < 0.95)
5703  MAXdif3rmsHFMIN = 0.95;
5704  if (MINdif3rmsHFMAX > 1.05)
5705  MINdif3rmsHFMAX = 1.05;
5706  cout << "22HF-2 MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5707  //
5708  for (int j = 1; j <= ny; j++) {
5709  ccc0HF = Ghf1->GetBinContent(1, j);
5710  if (ccc0HF <= 0.)
5711  for (int i = 1; i <= nx; i++) {
5712  double ccc2 = Ghf1->GetBinContent(i, j);
5713  if (ccc2 > 0.) {
5714  ccc0HF = ccc2;
5715  break;
5716  }
5717  }
5718  if (ccc0HF > 0.) {
5719  int jeta = (j - 1) / 18; // jeta = 0-21
5720  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5721  // i - # LSs:
5722  for (int i = 1; i <= nx; i++) {
5723  double ccc1 = Ghf1->GetBinContent(i, j);
5724  if (ccc1 > 0.) {
5725  double Rij = ccc1 / ccc0HF;
5726  if (Rij < MAXdif3rmsHFMIN || Rij > MINdif3rmsHFMAX) {
5727  Ghf61->Fill(jeta - 11, jphi, Rij);
5728  Ghf60->Fill(jeta - 11, jphi, 1.);
5729  }
5730  if (Rij < 0.8 || Rij > 1.2) {
5731  G20hf61->Fill(jeta - 11, jphi, Rij);
5732  G20hf60->Fill(jeta - 11, jphi, 1.);
5733  }
5734  if (Rij < 0.7 || Rij > 1.3) {
5735  G30hf61->Fill(jeta - 11, jphi, Rij);
5736  G30hf60->Fill(jeta - 11, jphi, 1.);
5737  }
5738  if (Rij < 0.6 || Rij > 1.4) {
5739  G40hf61->Fill(jeta - 11, jphi, Rij);
5740  G40hf60->Fill(jeta - 11, jphi, 1.);
5741  }
5742  } //if(ccc1>0.
5743  } // i
5744  } //if(ccc0HF>0
5745  } // j
5746  Ghf6->Divide(Ghf61, Ghf60, 1, 1, "B"); // average R
5747  G20hf6->Divide(G20hf61, G20hf60, 1, 1, "B"); // average R
5748  G30hf6->Divide(G30hf61, G30hf60, 1, 1, "B"); // average R
5749  G40hf6->Divide(G40hf61, G40hf60, 1, 1, "B"); // average R
5750  // Ghf6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5751  // Ghf6->GetZaxis()->SetLabelOffset(-0.05);
5752  Ghf6->GetZaxis()->SetLabelSize(0.025);
5753 
5754  Ghf6->SetXTitle(" #eta \b");
5755  Ghf6->SetYTitle(" #phi \b");
5756  Ghf6->SetTitle(
5757  "<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);
5758  //gStyle->SetOptStat(kFALSE);
5759  Ghf6->SetStats(0);
5760  Ghf6->Draw("COLZ");
5761  //================
5762  cRBX31->cd(3);
5763  TH1F *Ghf7 = new TH1F("Ghf7", "", 120, 0.4, 1.6);
5764  // j - etaphi index:
5765  for (int j = 1; j <= ny; j++) {
5766  ccc0HF = Ghf1->GetBinContent(1, j);
5767  if (ccc0HF <= 0.)
5768  for (int i = 1; i <= nx; i++) {
5769  double ccc2 = Ghf1->GetBinContent(i, j);
5770  if (ccc2 > 0.) {
5771  ccc0HF = ccc2;
5772  break;
5773  }
5774  }
5775  if (ccc0HF > 0.) {
5776  // i - # LSs:
5777  for (int i = 1; i <= nx; i++) {
5778  double ccc1 = Ghf1->GetBinContent(i, j);
5779  if (ccc1 > 0.) {
5780  double Rij = ccc1 / ccc0HF;
5781  Ghf7->Fill(Rij);
5782  }
5783  }
5784  }
5785  }
5786  Ghf7->SetMarkerStyle(20);
5787  Ghf7->SetMarkerSize(0.4);
5788  Ghf7->GetYaxis()->SetLabelSize(0.04);
5789  Ghf7->SetMarkerColor(2);
5790  Ghf7->SetLineColor(0);
5791  Ghf7->SetYTitle(" N \b");
5792  Ghf7->SetXTitle(" Rij \b");
5793  Ghf7->SetTitle(" Rij \b");
5794  //Ghf7->SetMinimum(0.8);Ghf7->SetMaximum(500.);
5795  gPad->SetGridy();
5796  gPad->SetGridx(); // gPad->SetLogy();
5797  // Ghf7->SetStats(1110000);
5798  Ghf7->GetYaxis()->SetLabelSize(0.025);
5799  Ghf7->Draw("Error");
5800  Float_t ymaxHF = Ghf7->GetMaximum();
5801  cout << "22HF-3 ymaxHF= " << ymaxHF << " MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN
5802  << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5803  TLine *lineHF = new TLine(MAXdif3rmsHFMIN, 0., MAXdif3rmsHFMIN, ymaxHF);
5804  lineHF->SetLineColor(kBlue);
5805  lineHF->Draw();
5806  TLine *line1HF = new TLine(MINdif3rmsHFMAX, 0., MINdif3rmsHFMAX, ymaxHF);
5807  line1HF->SetLineColor(kBlue);
5808  line1HF->Draw();
5809  //================
5811  cRBX31->Update();
5812  cRBX31->Print("RBX-HF-3plots.png");
5813  cRBX31->Clear();
5814  // clean-up
5815  if (Ghf5)
5816  delete Ghf5;
5817  if (Ghf60)
5818  delete Ghf60;
5819  if (Ghf61)
5820  delete Ghf61;
5821  if (Ghf6)
5822  delete Ghf6;
5823  if (Ghf7)
5824  delete Ghf7;
5825 
5826  if (G20hf60)
5827  delete G20hf60;
5828  if (G20hf61)
5829  delete G20hf61;
5830  if (G30hf60)
5831  delete G30hf60;
5832  if (G30hf61)
5833  delete G30hf61;
5834  if (G40hf60)
5835  delete G40hf60;
5836  if (G40hf61)
5837  delete G40hf61;
5838 
5839  if (Ghf1)
5840  delete Ghf1;
5841  //========================================================================================== 22-1 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5842  //======================================================================
5843  //======================================================================28.11.2018
5844  //======================================================================
5845  //======================================================================
5846 
5847  gStyle->SetOptStat(1110000);
5848  cout << " RBX HF Ratio plotsmore *****" << endl;
5849  cRBX31->Clear();
5851  cRBX31->Divide(3, 1);
5852  //================
5853  cRBX31->cd(1);
5854  G20hf6->GetZaxis()->SetLabelSize(0.025);
5855  G20hf6->SetXTitle(" #eta \b");
5856  G20hf6->SetYTitle(" #phi \b");
5857  G20hf6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5858  G20hf6->SetStats(0);
5859  G20hf6->Draw("COLZ");
5860  //================
5861  cRBX31->cd(2);
5862  G30hf6->GetZaxis()->SetLabelSize(0.025);
5863  G30hf6->SetXTitle(" #eta \b");
5864  G30hf6->SetYTitle(" #phi \b");
5865  G30hf6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5866  G30hf6->SetStats(0);
5867  G30hf6->Draw("COLZ");
5868  //================
5869  cRBX31->cd(3);
5870  G40hf6->GetZaxis()->SetLabelSize(0.025);
5871  G40hf6->SetXTitle(" #eta \b");
5872  G40hf6->SetYTitle(" #phi \b");
5873  G40hf6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5874  G40hf6->SetStats(0);
5875  G40hf6->Draw("COLZ");
5876  //================
5877 
5879  cRBX31->Update();
5880  cRBX31->Print("RBX-HF-3plotsmore.png");
5881  cRBX31->Clear();
5882 
5883  // clean-up
5884  if (G20hf6)
5885  delete G20hf6;
5886  if (G30hf6)
5887  delete G30hf6;
5888  if (G40hf6)
5889  delete G40hf6;
5890  gStyle->SetOptStat(0);
5892  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5893  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5894  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5896 
5898 
5900  //=============================================================================== occupancyHB
5901  // For occupancy plots. Produces OccPlots_HBx.png (x=1)
5902  int mymaxbins = MaxLum;
5903  {
5904  cHB->Clear();
5905  cHB->Divide(2, 1);
5907  cHB->cd(1);
5908  TH2F *occhbm = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HBM");
5909  TH1F *uyhbm = new TH1F("uyhbm", "", mymaxbins, 1., mymaxbins + 1.);
5910  for (int i = 1; i <= occhbm->GetXaxis()->GetNbins(); i++) {
5911  double ccc1 = occhbm->GetBinContent(i);
5912  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5913  if (ccc1 > 0.)
5914  uyhbm->Fill(float(i), ccc1);
5915  }
5916  // gPad->SetLogy();
5917  uyhbm->SetMarkerStyle(20);
5918  uyhbm->SetMarkerSize(0.6);
5919  uyhbm->GetYaxis()->SetLabelSize(0.04);
5920  uyhbm->SetXTitle("min/av occupancy - HBM \b");
5921  uyhbm->SetMarkerColor(2);
5922  uyhbm->SetLineColor(0);
5923  uyhbm->SetMaximum(1.0);
5924  uyhbm->SetMinimum(0.2);
5925  gPad->SetGridy();
5926  uyhbm->Draw("Error");
5928  cHB->cd(2);
5929  TH2F *occhbp = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HBP");
5930  TH1F *uyhbp = new TH1F("uyhbp", "", mymaxbins, 1., mymaxbins + 1.);
5931  for (int i = 1; i <= occhbp->GetXaxis()->GetNbins(); i++) {
5932  double ccc1 = occhbp->GetBinContent(i);
5933  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5934  if (ccc1 > 0.)
5935  uyhbp->Fill(float(i), ccc1);
5936  }
5937  // gPad->SetLogy();
5938  uyhbp->SetMarkerStyle(20);
5939  uyhbp->SetMarkerSize(0.6);
5940  uyhbp->GetYaxis()->SetLabelSize(0.04);
5941  uyhbp->SetXTitle("min/av occupancy - HBP \b");
5942  uyhbp->SetMarkerColor(2);
5943  uyhbp->SetLineColor(0);
5944  uyhbp->SetMaximum(1.0);
5945  uyhbp->SetMinimum(0.2);
5946  gPad->SetGridy();
5947  uyhbp->Draw("Error");
5949 
5951  cHB->Update();
5952  cHB->Print(Form("OccPlots_HB.png"));
5953  cHB->Clear();
5954 
5955  // clean-up
5956  if (occhbm)
5957  delete occhbm;
5958  if (uyhbm)
5959  delete uyhbm;
5960  if (occhbp)
5961  delete occhbp;
5962  if (uyhbp)
5963  delete uyhbp;
5964  }
5965  //=============================================================================== occupancyHE
5966  // For occupancy plots. Produces OccPlots_HEx.png (x=1)
5967  {
5968  cHB->Clear();
5969  cHB->Divide(2, 1);
5971  cHB->cd(1);
5972  TH2F *occhem = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HEM");
5973  TH1F *uyhem = new TH1F("uyhem", "", mymaxbins, 1., mymaxbins + 1.);
5974  for (int i = 1; i <= occhem->GetXaxis()->GetNbins(); i++) {
5975  double ccc1 = occhem->GetBinContent(i);
5976  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5977  if (ccc1 > 0.)
5978  uyhem->Fill(float(i), ccc1);
5979  }
5980  // gPad->SetLogy();
5981  uyhem->SetMarkerStyle(20);
5982  uyhem->SetMarkerSize(0.6);
5983  uyhem->GetYaxis()->SetLabelSize(0.04);
5984  uyhem->SetXTitle("min/av occupancy - HEM \b");
5985  uyhem->SetMarkerColor(2);
5986  uyhem->SetLineColor(0);
5987  uyhem->SetMaximum(1.0);
5988  uyhem->SetMinimum(0.2);
5989  gPad->SetGridy();
5990  uyhem->Draw("Error");
5992  cHB->cd(2);
5993  TH2F *occhep = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HEP");
5994  TH1F *uyhep = new TH1F("uyhep", "", mymaxbins, 1., mymaxbins + 1.);
5995  for (int i = 1; i <= occhep->GetXaxis()->GetNbins(); i++) {
5996  double ccc1 = occhep->GetBinContent(i);
5997  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5998  if (ccc1 > 0.)
5999  uyhep->Fill(float(i), ccc1);
6000  }
6001  // gPad->SetLogy();
6002  uyhep->SetMarkerStyle(20);
6003  uyhep->SetMarkerSize(0.6);
6004  uyhep->GetYaxis()->SetLabelSize(0.04);
6005  uyhep->SetXTitle("min/av occupancy - HEP \b");
6006  uyhep->SetMarkerColor(2);
6007  uyhep->SetLineColor(0);
6008  uyhep->SetMaximum(1.0);
6009  uyhep->SetMinimum(0.2);
6010  gPad->SetGridy();
6011  uyhep->Draw("Error");
6013 
6015  cHB->Update();
6016  cHB->Print(Form("OccPlots_HE.png"));
6017  cHB->Clear();
6018 
6019  // clean-up
6020  if (occhem)
6021  delete occhem;
6022  if (uyhem)
6023  delete uyhem;
6024  if (occhep)
6025  delete occhep;
6026  if (uyhep)
6027  delete uyhep;
6028  }
6029  //=============================================================================== occupancyHO
6030  // For occupancy plots. Produces OccPlots_HOx.png (x=1)
6031  {
6032  cHB->Clear();
6033  cHB->Divide(2, 1);
6035  cHB->cd(1);
6036  TH2F *occhom = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HOM");
6037  TH1F *uyhom = new TH1F("uyhom", "", mymaxbins, 1., mymaxbins + 1.);
6038  for (int i = 1; i <= occhom->GetXaxis()->GetNbins(); i++) {
6039  double ccc1 = occhom->GetBinContent(i);
6040  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6041  if (ccc1 > 0.)
6042  uyhom->Fill(float(i), ccc1);
6043  }
6044  // gPad->SetLogy();
6045  uyhom->SetMarkerStyle(20);
6046  uyhom->SetMarkerSize(0.6);
6047  uyhom->GetYaxis()->SetLabelSize(0.04);
6048  uyhom->SetXTitle("min/av occupancy - HOM \b");
6049  uyhom->SetMarkerColor(2);
6050  uyhom->SetLineColor(0);
6051  uyhom->SetMaximum(1.0);
6052  uyhom->SetMinimum(0.2);
6053  gPad->SetGridy();
6054  uyhom->Draw("Error");
6056  cHB->cd(2);
6057  TH2F *occhop = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HOP");
6058  TH1F *uyhop = new TH1F("uyhop", "", mymaxbins, 1., mymaxbins + 1.);
6059  for (int i = 1; i <= occhop->GetXaxis()->GetNbins(); i++) {
6060  double ccc1 = occhop->GetBinContent(i);
6061  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6062  if (ccc1 > 0.)
6063  uyhop->Fill(float(i), ccc1);
6064  }
6065  // gPad->SetLogy();
6066  uyhop->SetMarkerStyle(20);
6067  uyhop->SetMarkerSize(0.6);
6068  uyhop->GetYaxis()->SetLabelSize(0.04);
6069  uyhop->SetXTitle("min/av occupancy - HOP \b");
6070  uyhop->SetMarkerColor(2);
6071  uyhop->SetLineColor(0);
6072  uyhop->SetMaximum(1.0);
6073  uyhop->SetMinimum(0.2);
6074  gPad->SetGridy();
6075  uyhop->Draw("Error");
6077 
6079  cHB->Update();
6080  cHB->Print(Form("OccPlots_HO.png"));
6081  cHB->Clear();
6082 
6083  // clean-up
6084  if (occhom)
6085  delete occhom;
6086  if (uyhom)
6087  delete uyhom;
6088  if (occhop)
6089  delete occhop;
6090  if (uyhop)
6091  delete uyhop;
6092  }
6093  //=============================================================================== occupancyHF
6094  // For occupancy plots. Produces OccPlots_HFx.png (x=1)
6095  {
6096  cHB->Clear();
6097  cHB->Divide(2, 1);
6099  cHB->cd(1);
6100  TH2F *occhfm = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HFM");
6101  TH1F *uyhfm = new TH1F("uyhfm", "", mymaxbins, 1., mymaxbins + 1.);
6102  for (int i = 1; i <= occhfm->GetXaxis()->GetNbins(); i++) {
6103  double ccc1 = occhfm->GetBinContent(i);
6104  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6105  if (ccc1 > 0.)
6106  uyhfm->Fill(float(i), ccc1);
6107  }
6108  // gPad->SetLogy();
6109  uyhfm->SetMarkerStyle(20);
6110  uyhfm->SetMarkerSize(0.6);
6111  uyhfm->GetYaxis()->SetLabelSize(0.04);
6112  uyhfm->SetXTitle("min/av occupancy - HFM \b");
6113  uyhfm->SetMarkerColor(2);
6114  uyhfm->SetLineColor(0);
6115  uyhfm->SetMaximum(1.0);
6116  uyhfm->SetMinimum(0.2);
6117  gPad->SetGridy();
6118  uyhfm->Draw("Error");
6120  cHB->cd(2);
6121  TH2F *occhfp = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HFP");
6122  TH1F *uyhfp = new TH1F("uyhfp", "", mymaxbins, 1., mymaxbins + 1.);
6123  for (int i = 1; i <= occhfp->GetXaxis()->GetNbins(); i++) {
6124  double ccc1 = occhfp->GetBinContent(i);
6125  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6126  if (ccc1 > 0.)
6127  uyhfp->Fill(float(i), ccc1);
6128  }
6129  // gPad->SetLogy();
6130  uyhfp->SetMarkerStyle(20);
6131  uyhfp->SetMarkerSize(0.6);
6132  uyhfp->GetYaxis()->SetLabelSize(0.04);
6133  uyhfp->SetXTitle("min/av occupancy - HFP \b");
6134  uyhfp->SetMarkerColor(2);
6135  uyhfp->SetLineColor(0);
6136  uyhfp->SetMaximum(1.0);
6137  uyhfp->SetMinimum(0.2);
6138  gPad->SetGridy();
6139  uyhfp->Draw("Error");
6141 
6143  cHB->Update();
6144  cHB->Print(Form("OccPlots_HF.png"));
6145  cHB->Clear();
6146 
6147  // clean-up
6148  if (occhfm)
6149  delete occhfm;
6150  if (uyhfm)
6151  delete uyhfm;
6152  if (occhfp)
6153  delete occhfp;
6154  if (uyhfp)
6155  delete uyhfp;
6156  }
6157  std::cout << "************>>> occupancy plots done" << std::endl;
6158 
6163  //************************* ***** Signal *****
6164  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots " << endl;
6165  int maxbins = MaxLum;
6166  cout << ">>>> maxbins = " << maxbins << endl;
6167  TH1F *SummedAmplitudeHisto[4]; // 1d histogramm for subdet
6168  SummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HB");
6169  SummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HE");
6170  SummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HO");
6171  SummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HF");
6172  TH1F *SummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6173  SummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HB");
6174  SummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HE");
6175  SummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HO");
6176  SummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HF");
6177  for (int sub = 0; sub < 4; sub++) {
6178  cHE->Clear();
6179  cHE->Divide(2, 1);
6180  cHE->cd(1);
6181  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6182  // cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sub = "<< sub <<endl;
6183  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6184  double ccc1 = 0.;
6185  if (SummedAmplitudeHisto[sub])
6186  ccc1 = SummedAmplitudeHisto[sub]->GetBinContent(i);
6187  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6188  if (ccc1 > 0.)
6189  kslpq->Fill(float(i), ccc1);
6190  }
6191  // gPad->SetLogy();
6192  kslpq->SetMarkerStyle(20);
6193  kslpq->SetMarkerSize(0.8);
6194  kslpq->GetYaxis()->SetLabelSize(0.04);
6195  kslpq->SetXTitle("SumA of channels w/ signal per LS \b");
6196  kslpq->SetMarkerColor(2);
6197  kslpq->SetLineColor(0);
6198  // kslpq->SetMinimum(0.8);
6199  gPad->SetGridx();
6200  kslpq->Draw("Error");
6202  cHE->cd(2);
6203  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6204  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6205  double ccc1 = 0.;
6206  if (SummedAmplitudeOccupancyHisto[sub])
6207  ccc1 = SummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6208  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6209  if (ccc1 > 0.)
6210  pqmks->Fill(float(i), ccc1);
6211  }
6212  // gPad->SetLogy();
6213  pqmks->SetMarkerStyle(20);
6214  pqmks->SetMarkerSize(0.8);
6215  pqmks->GetYaxis()->SetLabelSize(0.04);
6216  pqmks->SetXTitle("Occupancy of channels w/ signal per LS \b");
6217  pqmks->SetMarkerColor(4);
6218  pqmks->SetLineColor(0);
6219  // pqmks->SetMinimum(0.8);
6220  gPad->SetGridx();
6221  pqmks->Draw("Error");
6222  cHE->Update();
6223  if (sub == 0)
6224  cHE->Print("SummedAmplitudesSignal_HB.png");
6225  if (sub == 1)
6226  cHE->Print("SummedAmplitudesSignal_HE.png");
6227  if (sub == 2)
6228  cHE->Print("SummedAmplitudesSignal_HO.png");
6229  if (sub == 3)
6230  cHE->Print("SummedAmplitudesSignal_HF.png");
6231  cHE->Clear();
6232  if (kslpq)
6233  delete kslpq;
6234  if (pqmks)
6235  delete pqmks;
6236  } //for
6237  // clean-up
6238  //for (unsigned int i=0; i<4; i++) {delete SummedAmplitudeHisto[i];delete SummedAmplitudeOccupancyHisto[i];}
6239 
6242  //************************* ***** NoSignal *****
6243  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots NoSignal " << endl;
6244  TH1F *NoSignalSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6245  NoSignalSummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HB");
6246  NoSignalSummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HE");
6247  NoSignalSummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HO");
6248  NoSignalSummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HF");
6249  TH1F *NoSignalSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6250  NoSignalSummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HB");
6251  NoSignalSummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HE");
6252  NoSignalSummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HO");
6253  NoSignalSummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HF");
6254  for (int sub = 0; sub < 4; sub++) {
6255  cHE->Clear();
6256  cHE->Divide(2, 1);
6257 
6258  cHE->cd(1);
6259  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6260  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6261  double ccc1 = 0.;
6262  if (NoSignalSummedAmplitudeHisto[sub])
6263  ccc1 = NoSignalSummedAmplitudeHisto[sub]->GetBinContent(i);
6264  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6265  if (ccc1 > 0.)
6266  kslpq->Fill(float(i), ccc1);
6267  }
6268  // gPad->SetLogy();
6269  kslpq->SetMarkerStyle(20);
6270  kslpq->SetMarkerSize(0.8);
6271  kslpq->GetYaxis()->SetLabelSize(0.04);
6272  kslpq->SetXTitle("SumA of channels w/o signal per LS \b");
6273  kslpq->SetMarkerColor(2);
6274  kslpq->SetLineColor(0);
6275  if (sub == 0) {
6276  kslpq->SetMaximum(20000.);
6277  kslpq->SetMinimum(5000.);
6278  } else if (sub == 1) {
6279  kslpq->SetMaximum(40000.);
6280  kslpq->SetMinimum(0.);
6281  } else if (sub == 2) {
6282  kslpq->SetMaximum(10000.);
6283  kslpq->SetMinimum(15000.);
6284  } else if (sub == 3) {
6285  kslpq->SetMaximum(100000.);
6286  kslpq->SetMinimum(0.);
6287  }
6288  gPad->SetGridx();
6289  kslpq->Draw("Error");
6291  cHE->cd(2);
6292  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6293  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6294  double ccc1 = 0.;
6295  if (NoSignalSummedAmplitudeOccupancyHisto[sub])
6296  ccc1 = NoSignalSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6297  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6298  if (ccc1 > 0.)
6299  pqmks->Fill(float(i), ccc1);
6300  }
6301  // gPad->SetLogy();
6302  pqmks->SetMarkerStyle(20);
6303  pqmks->SetMarkerSize(0.8);
6304  pqmks->GetYaxis()->SetLabelSize(0.04);
6305  pqmks->SetXTitle("Occupancy of channels w/o signal per LS \b");
6306  pqmks->SetMarkerColor(4);
6307  pqmks->SetLineColor(0);
6308  if (sub == 0) {
6309  pqmks->SetMaximum(600.);
6310  pqmks->SetMinimum(200.);
6311  } else if (sub == 1) {
6312  pqmks->SetMaximum(910.);
6313  pqmks->SetMinimum(10.);
6314  } else if (sub == 2) {
6315  pqmks->SetMaximum(200.);
6316  pqmks->SetMinimum(50.);
6317  } else if (sub == 3) {
6318  pqmks->SetMaximum(866.);
6319  pqmks->SetMinimum(856.);
6320  }
6321  gPad->SetGridx();
6322  pqmks->Draw("Error");
6323  cHE->Update();
6324  if (sub == 0)
6325  cHE->Print("NoSignalSummedAmplitudes_HB.png");
6326  if (sub == 1)
6327  cHE->Print("NoSignalSummedAmplitudes_HE.png");
6328  if (sub == 2)
6329  cHE->Print("NoSignalSummedAmplitudes_HO.png");
6330  if (sub == 3)
6331  cHE->Print("NoSignalSummedAmplitudes_HF.png");
6332  cHE->Clear();
6333  if (kslpq)
6334  delete kslpq;
6335  if (pqmks)
6336  delete pqmks;
6337  } //for
6338  // clean-up
6339  //for (unsigned int i=0; i<4; i++) {delete NoSignalSummedAmplitudeHisto[i];delete NoSignalSummedAmplitudeOccupancyHisto[i];}
6341 
6344  //************************* ***** MaxxValues *****
6345  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots Maxx " << endl;
6346  TH1F *MaxxSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6347  MaxxSummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HB");
6348  MaxxSummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HE");
6349  MaxxSummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HO");
6350  MaxxSummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HF");
6351  TH1F *MaxxSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6352  MaxxSummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HB");
6353  MaxxSummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HE");
6354  MaxxSummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HO");
6355  MaxxSummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HF");
6356  TH1F *SAmplitudeHisto[4]; // 1d histogramm for subdet
6357  SAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HB");
6358  SAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HE");
6359  SAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HO");
6360  SAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HF");
6361  TH1F *OccupancyHisto[4]; // 1d histogramm for subdet
6362  OccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HB");
6363  OccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HE");
6364  OccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HO");
6365  OccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HF");
6366 
6367  int countamplmaxHB = 0;
6368  int countamplmaxHE = 0;
6369  int countamplmaxHO = 0;
6370  int countamplmaxHF = 0;
6371  int countoccumaxHB = 0;
6372  int countoccumaxHE = 0;
6373  int countoccumaxHO = 0;
6374  int countoccumaxHF = 0;
6375  unsigned long int countamplHB = 0;
6376  unsigned long int countamplHE = 0;
6377  unsigned long int countamplHO = 0;
6378  unsigned long int countamplHF = 0;
6379  unsigned long int countoccuHB = 0;
6380  unsigned long int countoccuHE = 0;
6381  unsigned long int countoccuHO = 0;
6382  unsigned long int countoccuHF = 0;
6383  gStyle->SetOptStat(110000);
6384  for (int sub = 0; sub < 4; sub++) {
6385  cFour->Clear();
6386  cFour->Divide(2, 2);
6387 
6388  cFour->cd(1);
6389  TH1F *lpqxc = new TH1F("lpqxc", "", maxbins, 1., maxbins + 1.);
6390  for (int i = 1; i <= lpqxc->GetXaxis()->GetNbins(); i++) {
6391  double ccc1 = 0.;
6392  if (MaxxSummedAmplitudeHisto[sub])
6393  ccc1 = MaxxSummedAmplitudeHisto[sub]->GetBinContent(i);
6394  // if(ccc1>0.) cout<<"111111111111111111111111111 iLS = "<<i<<" LS= "<<ccc1<<endl;
6395  if (ccc1 > 0.)
6396  lpqxc->Fill(float(i), ccc1);
6397  if (sub == 0 && ccc1 > 60000.)
6398  countamplmaxHB++;
6399  if (sub == 1 && ccc1 > 60000.)
6400  countamplmaxHE++;
6401  if (sub == 2 && ccc1 > 150000.)
6402  countamplmaxHO++;
6403  if (sub == 3 && ccc1 > 22000.)
6404  countamplmaxHF++;
6405  }
6406  // gPad->SetLogy();
6407  lpqxc->SetMarkerStyle(20);
6408  lpqxc->SetMarkerSize(0.8);
6409  // lpqxc->GetYaxis()->SetLabelSize(0.08);
6410  if (sub == 0)
6411  lpqxc->SetXTitle("HB: max SA over LS-events per LS \b");
6412  if (sub == 1)
6413  lpqxc->SetXTitle("HE: max SA over LS-events per LS \b");
6414  if (sub == 2)
6415  lpqxc->SetXTitle("HO: max SA over LS-events per LS \b");
6416  if (sub == 3)
6417  lpqxc->SetXTitle("HF: max SA over LS-events per LS \b");
6418  lpqxc->SetMarkerColor(2);
6419  lpqxc->SetLineColor(0);
6420  gPad->SetGridx();
6421  lpqxc->Draw("Error");
6422 
6424  cFour->cd(2);
6425  TH1F *hpzlm = new TH1F("hpzlm", "", maxbins, 1., maxbins + 1.);
6426  for (int i = 1; i <= hpzlm->GetXaxis()->GetNbins(); i++) {
6427  double ccc1 = 0.;
6428  if (MaxxSummedAmplitudeOccupancyHisto[sub])
6429  ccc1 = MaxxSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6430  // if(ccc1>0.) cout<<"2222222222222222222222222 iLS = "<<i<<" LS= "<<ccc1<<endl;
6431  if (ccc1 > 0.)
6432  hpzlm->Fill(float(i), ccc1);
6433  if (sub == 0 && ccc1 > 2000.)
6434  countoccumaxHB++;
6435  if (sub == 1 && ccc1 > 1200.)
6436  countoccumaxHE++;
6437  if (sub == 2 && ccc1 > 2000.)
6438  countoccumaxHO++;
6439  if (sub == 3 && ccc1 > 860.)
6440  countoccumaxHF++;
6441  }
6442  // gPad->SetLogy();
6443  hpzlm->SetMarkerStyle(20);
6444  hpzlm->SetMarkerSize(0.8);
6445  // hpzlm->GetYaxis()->SetLabelSize(0.08);
6446  if (sub == 0)
6447  hpzlm->SetXTitle("HB: max Occupancy over LS-events per LS \b");
6448  if (sub == 1)
6449  hpzlm->SetXTitle("HE: max Occupancy over LS-events per LS \b");
6450  if (sub == 2)
6451  hpzlm->SetXTitle("HO: max Occupancy over LS-events per LS \b");
6452  if (sub == 3)
6453  hpzlm->SetXTitle("HF: max Occupancy over LS-events per LS \b");
6454  hpzlm->SetMarkerColor(4);
6455  hpzlm->SetLineColor(0);
6456  gPad->SetGridx();
6457  if (sub == 3) {
6458  hpzlm->SetMaximum(866.);
6459  hpzlm->SetMinimum(856.);
6460  }
6461  hpzlm->Draw("Error");
6462 
6464  cFour->cd(3);
6465  gPad->SetLogy();
6466  if (SAmplitudeHisto[sub]) {
6467  for (int i = 1; i <= SAmplitudeHisto[sub]->GetXaxis()->GetNbins(); i++) {
6468  // if(sub==0 && i * 800> 60000.) {
6469  // cout<<">=>=>>=> countamplHB= "<<countamplHB<<" content = "<<SAmplitudeHisto[sub]->GetBinContent(i)<<" sub= "<<sub<<" i= "<<i<< endl;
6470  // countamplHB+=SAmplitudeHisto[sub]->GetBinContent(i);
6471  // }
6472  if (sub == 0 && i * 800 > 60000.)
6473  countamplHB += SAmplitudeHisto[sub]->GetBinContent(i);
6474  if (sub == 1 && i * 1000 > 60000.)
6475  countamplHE += SAmplitudeHisto[sub]->GetBinContent(i);
6476  if (sub == 2 && i * 2500 > 150000.)
6477  countamplHO += SAmplitudeHisto[sub]->GetBinContent(i);
6478  if (sub == 3 && i * 1400 > 22000.)
6479  countamplHF += SAmplitudeHisto[sub]->GetBinContent(i);
6480  }
6481  SAmplitudeHisto[sub]->SetMarkerStyle(20);
6482  SAmplitudeHisto[sub]->SetMarkerSize(0.8);
6483  if (sub == 0)
6484  SAmplitudeHisto[sub]->SetTitle("HB event Amplitude\b");
6485  if (sub == 1)
6486  SAmplitudeHisto[sub]->SetTitle("HE event Amplitude\b");
6487  if (sub == 2)
6488  SAmplitudeHisto[sub]->SetTitle("HO event Amplitude\b");
6489  if (sub == 3)
6490  SAmplitudeHisto[sub]->SetTitle("HF event Amplitude\b");
6491  // SAmplitudeHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6492  SAmplitudeHisto[sub]->SetXTitle("event amplitude \b");
6493  SAmplitudeHisto[sub]->SetMarkerColor(2);
6494  SAmplitudeHisto[sub]->SetLineColor(2);
6495  SAmplitudeHisto[sub]->Draw("");
6496  }
6498  cFour->cd(4);
6499  gPad->SetLogy();
6500  if (OccupancyHisto[sub]) {
6501  for (int i = 1; i <= OccupancyHisto[sub]->GetXaxis()->GetNbins(); i++) {
6502  if (sub == 0 && i * 30 > 2000.)
6503  countoccuHB += OccupancyHisto[sub]->GetBinContent(i);
6504  if (sub == 1 && i * 20 > 1200.)
6505  countoccuHE += OccupancyHisto[sub]->GetBinContent(i);
6506  if (sub == 2 && i * 25 > 2000.)
6507  countoccuHO += OccupancyHisto[sub]->GetBinContent(i);
6508  if (sub == 3 && i * 10 > 860.)
6509  countoccuHF += OccupancyHisto[sub]->GetBinContent(i);
6510  }
6511  OccupancyHisto[sub]->SetMarkerStyle(20);
6512  OccupancyHisto[sub]->SetMarkerSize(0.8);
6513  if (sub == 0)
6514  OccupancyHisto[sub]->SetTitle("HB event Occupancy\b");
6515  if (sub == 1)
6516  OccupancyHisto[sub]->SetTitle("HE event Occupancy\b");
6517  if (sub == 2)
6518  OccupancyHisto[sub]->SetTitle("HO event Occupancy\b");
6519  if (sub == 3)
6520  OccupancyHisto[sub]->SetTitle("HF event Occupancy\b");
6521  // OccupancyHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6522  OccupancyHisto[sub]->SetXTitle("event occupancy \b");
6523  OccupancyHisto[sub]->SetMarkerColor(4);
6524  OccupancyHisto[sub]->SetLineColor(4);
6525  OccupancyHisto[sub]->Draw("");
6526  }
6527 
6528  cFour->Update();
6529  if (sub == 0)
6530  cFour->Print("MaxxSummedAmplitudes_HB.png");
6531  if (sub == 1)
6532  cFour->Print("MaxxSummedAmplitudes_HE.png");
6533  if (sub == 2)
6534  cFour->Print("MaxxSummedAmplitudes_HO.png");
6535  if (sub == 3)
6536  cFour->Print("MaxxSummedAmplitudes_HF.png");
6537  cFour->Clear();
6538  if (lpqxc)
6539  delete lpqxc;
6540  if (hpzlm)
6541  delete hpzlm;
6542  } //for
6543  gStyle->SetOptStat(0);
6545  cout << ">=>=>>=> countamplmaxHB= " << countamplmaxHB << " countamplmaxHE= " << countamplmaxHE
6546  << " countamplmaxHO= " << countamplmaxHO << " countamplmaxHF= " << countamplmaxHF << endl;
6547  cout << ">=>=>>=> countoccumaxHB= " << countoccumaxHB << " countoccumaxHE= " << countoccumaxHE
6548  << " countoccumaxHO= " << countoccumaxHO << " countoccumaxHF= " << countoccumaxHF << endl;
6549  cout << ">=>=>>=> countamplHB= " << countamplHB << " countamplHE= " << countamplHE << " countamplHO= " << countamplHO
6550  << " countamplHF= " << countamplHF << endl;
6551  cout << ">=>=>>=> countoccuHB= " << countoccuHB << " countoccuHE= " << countoccuHE << " countoccuHO= " << countoccuHO
6552  << " countoccuHF= " << countoccuHF << endl;
6553 
6556  //************************* ***** channelsummedA over depths *****
6557  cout << ">>>>>>>>>>>>>>>>>>>>>>>>channelsummedA over depths " << endl;
6558  TH1F *ChannelDepthsummedAmplitudesPlots[4]; // 1d histogramm for subdet
6559  ChannelDepthsummedAmplitudesPlots[0] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HB");
6560  ChannelDepthsummedAmplitudesPlots[1] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HE");
6561  ChannelDepthsummedAmplitudesPlots[2] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HO");
6562  ChannelDepthsummedAmplitudesPlots[3] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HF");
6563  TLine *litebdt[4];
6564  if (ChannelDepthsummedAmplitudesPlots[0])
6565  litebdt[0] = new TLine(80., 0.8, 80., ChannelDepthsummedAmplitudesPlots[0]->GetBinContent(4) + 100.);
6566  if (ChannelDepthsummedAmplitudesPlots[1])
6567  litebdt[1] = new TLine(200., 0.8, 200., ChannelDepthsummedAmplitudesPlots[1]->GetBinContent(7) + 100.);
6568  if (ChannelDepthsummedAmplitudesPlots[2])
6569  litebdt[2] = new TLine(1200., 0.8, 1200., ChannelDepthsummedAmplitudesPlots[2]->GetBinContent(17) + 100.);
6570  if (ChannelDepthsummedAmplitudesPlots[3])
6571  litebdt[3] = new TLine(600., 0.8, 600., ChannelDepthsummedAmplitudesPlots[3]->GetBinContent(6) + 100.);
6572 
6573  gStyle->SetOptStat(110000);
6574  cFour1->Clear();
6575  cFour1->Divide(2, 2);
6576  for (int sub = 0; sub < 4; sub++) {
6577  if (sub == 0)
6578  cFour1->cd(1);
6579  if (sub == 1)
6580  cFour1->cd(2);
6581  if (sub == 2)
6582  cFour1->cd(3);
6583  if (sub == 3)
6584  cFour1->cd(4);
6585  gPad->SetLogy();
6586  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerStyle(20);
6587  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerSize(0.8);
6588  if (sub == 0)
6589  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HB channel Amplitudes\b");
6590  if (sub == 1)
6591  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HE channel Amplitudes\b");
6592  if (sub == 2)
6593  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HO channel Amplitudes\b");
6594  if (sub == 3)
6595  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HF channel Amplitudes\b");
6596  if (sub == 0)
6597  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HB channel depths summed Amplitudes \b");
6598  if (sub == 1)
6599  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HE channel depths summed Amplitudes \b");
6600  if (sub == 2)
6601  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HO channel depths summed Amplitudes \b");
6602  if (sub == 3)
6603  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HF channel depths summed Amplitudes \b");
6604  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerColor(2);
6605  ChannelDepthsummedAmplitudesPlots[sub]->SetLineColor(2);
6606  ChannelDepthsummedAmplitudesPlots[sub]->Draw("");
6607  litebdt[sub]->SetLineColor(kBlue);
6608  litebdt[sub]->Draw("s");
6609  } //for
6610  cFour1->Update();
6611  cFour1->Print("ChannelDepthsummedAmplitudes.png");
6612  cFour1->Clear();
6613  gStyle->SetOptStat(0);
6614 
6617  //************************* ***** Ataildepth1_HB *****
6618  cout << ">>>>>>>>>>>>>>>>>>>>>>>>2DAtaildepth " << endl;
6620  cHB->Clear();
6621  cHB->Divide(2, 1);
6622 
6623  TH2F *DAtaildepth1[2]; // 1d histogramm for subdet
6624  DAtaildepth1[0] = (TH2F *)dir->FindObjectAny("h_2DAtaildepth1_HB");
6625  DAtaildepth1[1] = (TH2F *)dir->FindObjectAny("h_2D0Ataildepth1_HB");
6626  cHB->cd(1);
6627  if (!DAtaildepth1[0] || !DAtaildepth1[1]) {
6628  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 1" << endl;
6629  } else {
6630  TH2F *tail1 = (TH2F *)DAtaildepth1[0]->Clone("tail1");
6631  tail1->Divide(DAtaildepth1[0], DAtaildepth1[1], 1, 1, "B");
6632  // tail1->Sumw2();
6633  gPad->SetGridy();
6634  gPad->SetGridx();
6635  gPad->SetLogz();
6636  tail1->SetMarkerStyle(20);
6637  tail1->SetMarkerSize(0.4);
6638  tail1->SetTitle("Amplitudes for tail-events (HBdepth1) \b");
6639  tail1->SetXTitle("#eta \b");
6640  tail1->SetYTitle("#phi \b");
6641  tail1->SetZTitle("2D <A> in the tail - HB Depth1 \b");
6642  tail1->SetMarkerColor(2);
6643  tail1->SetLineColor(2);
6644  tail1->Draw("COLZ");
6645  }
6646  TH2F *DAtaildepth2[2]; // 1d histogramm for subdet
6647  DAtaildepth2[0] = (TH2F *)dir->FindObjectAny("h_2DAtaildepth2_HB");
6648  DAtaildepth2[1] = (TH2F *)dir->FindObjectAny("h_2D0Ataildepth2_HB");
6649  cHB->cd(2);
6650  if (!DAtaildepth2[0] || !DAtaildepth2[1]) {
6651  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 2" << endl;
6652  } else {
6653  TH2F *tail2 = (TH2F *)DAtaildepth2[0]->Clone("tail2");
6654  tail2->Divide(DAtaildepth2[0], DAtaildepth2[1], 1, 1, "B");
6655  // tail2->Sumw2();
6656  gPad->SetGridy();
6657  gPad->SetGridx();
6658  gPad->SetLogz();
6659  tail2->SetMarkerStyle(20);
6660  tail2->SetMarkerSize(0.4);
6661  tail2->SetTitle("Amplitudes for tail-events (HBdepth2) \b");
6662  tail2->SetXTitle("#eta \b");
6663  tail2->SetYTitle("#phi \b");
6664  tail2->SetZTitle("2D <A> in the tail - HB Depth2 \b");
6665  tail2->SetMarkerColor(2);
6666  tail2->SetLineColor(2);
6667  tail2->Draw("COLZ");
6668  }
6669 
6670  cHB->Update();
6671  cHB->Print("AtaildepthHB.png");
6672  cHB->Clear();
6673 
6676  //************************* ***** sum(Signal+NoSignal) occupancy for HF *****
6677  cout << ">>>>>>>>>>>>>>>>>>>>>>>>sumOccupancyHF " << endl;
6679  cHB->Clear();
6680  cHB->Divide(1, 1);
6681  cHB->cd(1);
6682  if (SummedAmplitudeOccupancyHisto[3]) {
6683  TH1F *ufrew1 = (TH1F *)SummedAmplitudeOccupancyHisto[3]->Clone("ufrew1");
6684  if (SummedAmplitudeOccupancyHisto[3] && NoSignalSummedAmplitudeOccupancyHisto[3])
6685  ufrew1->Add(SummedAmplitudeOccupancyHisto[3], NoSignalSummedAmplitudeOccupancyHisto[3], 1, 1);
6686  ufrew1->GetXaxis()->SetRangeUser(1., maxbins + 1.);
6687  gPad->SetGridx();
6688  ufrew1->SetMarkerStyle(20);
6689  ufrew1->SetMarkerSize(0.8);
6690  ufrew1->GetYaxis()->SetLabelSize(0.04);
6691  ufrew1->SetTitle("HF Occupancy vs LS\b");
6692  ufrew1->SetXTitle("average occupancy per LS HF\b");
6693  ufrew1->SetMarkerColor(4);
6694  ufrew1->SetLineColor(0);
6695  ufrew1->SetMaximum(866.);
6696  ufrew1->SetMinimum(856.);
6697  ufrew1->Draw("Error");
6698  cHB->Update();
6699  cHB->Print("sumOccupancyHF.png");
6700  cHB->Clear();
6701  if (ufrew1)
6702  delete ufrew1;
6703  }
6704 
6712  //====================================================================================================================
6713  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =====================================================================" << endl;
6714 
6715  //=====================================================================================================
6716  cout << ">>>>>>>>>>>>>>>>>>>>>>>> ==================================================" << endl;
6717 
6718  //=====================================================================================
6719  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6720  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6721  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6722  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6723 
6724  cout << ">>>>>>> START NOW CREATING OF HTML PAGES <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
6725  //======================================================================
6726  // Creating each test kind for each subdet html pages:
6727  std::string raw_class;
6728  int ind = 0;
6729  ofstream htmlFile;
6730  for (int test = 0; test <= 5; test++) { //Test: 0,
6731  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
6732 
6733  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
6734  if (test == 0) {
6735  if (sub == 1) {
6736  htmlFile.open("HB_CapID.html");
6737  }
6738  if (sub == 2) {
6739  htmlFile.open("HE_CapID.html");
6740  }
6741  if (sub == 3) {
6742  htmlFile.open("HO_CapID.html");
6743  }
6744  if (sub == 4) {
6745  htmlFile.open("HF_CapID.html");
6746  }
6747  }
6748  if (test == 1) {
6749  if (sub == 1) {
6750  htmlFile.open("HB_ADCampl.html");
6751  }
6752  if (sub == 2) {
6753  htmlFile.open("HE_ADCampl.html");
6754  }
6755  if (sub == 3) {
6756  htmlFile.open("HO_ADCampl.html");
6757  }
6758  if (sub == 4) {
6759  htmlFile.open("HF_ADCampl.html");
6760  }
6761  }
6762  if (test == 2) {
6763  if (sub == 1) {
6764  htmlFile.open("HB_Width.html");
6765  }
6766  if (sub == 2) {
6767  htmlFile.open("HE_Width.html");
6768  }
6769  if (sub == 3) {
6770  htmlFile.open("HO_Width.html");
6771  }
6772  if (sub == 4) {
6773  htmlFile.open("HF_Width.html");
6774  }
6775  }
6776  if (test == 3) {
6777  if (sub == 1) {
6778  htmlFile.open("HB_Ratio.html");
6779  }
6780  if (sub == 2) {
6781  htmlFile.open("HE_Ratio.html");
6782  }
6783  if (sub == 3) {
6784  htmlFile.open("HO_Ratio.html");
6785  }
6786  if (sub == 4) {
6787  htmlFile.open("HF_Ratio.html");
6788  }
6789  }
6790  if (test == 4) {
6791  if (sub == 1) {
6792  htmlFile.open("HB_Tmean.html");
6793  }
6794  if (sub == 2) {
6795  htmlFile.open("HE_Tmean.html");
6796  }
6797  if (sub == 3) {
6798  htmlFile.open("HO_Tmean.html");
6799  }
6800  if (sub == 4) {
6801  htmlFile.open("HF_Tmean.html");
6802  }
6803  }
6804  if (test == 5) {
6805  if (sub == 1) {
6806  htmlFile.open("HB_Tmax.html");
6807  }
6808  if (sub == 2) {
6809  htmlFile.open("HE_Tmax.html");
6810  }
6811  if (sub == 3) {
6812  htmlFile.open("HO_Tmax.html");
6813  }
6814  if (sub == 4) {
6815  htmlFile.open("HF_Tmax.html");
6816  }
6817  }
6818 
6819  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
6820  htmlFile << "<head>" << std::endl;
6821  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
6822  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
6823  htmlFile << "<style type=\"text/css\">" << std::endl;
6824  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
6825  << std::endl;
6826  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
6827  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
6828  "text-align: center;}"
6829  << std::endl;
6830  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
6831  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
6832  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
6833  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
6834  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
6835  htmlFile << "</style>" << std::endl;
6836  htmlFile << "<body>" << std::endl;
6837 
6838  if (test == 0) {
6839  if (sub == 1)
6840  htmlFile << "<h1> Cap ID estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6841  if (sub == 2)
6842  htmlFile << "<h1> Cap ID estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6843  if (sub == 3)
6844  htmlFile << "<h1> Cap ID estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6845  if (sub == 4)
6846  htmlFile << "<h1> Cap ID estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6847  }
6848  if (test == 1) {
6849  if (sub == 1)
6850  htmlFile << "<h1> Mean ADC Amplitude estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6851  if (sub == 2)
6852  htmlFile << "<h1> Mean ADC Amplitude estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6853  if (sub == 3)
6854  htmlFile << "<h1> Mean ADC Amplitude estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6855  if (sub == 4)
6856  htmlFile << "<h1> Mean ADC Amplitude estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6857  }
6858  if (test == 2) {
6859  if (sub == 1)
6860  htmlFile << "<h1> Width estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6861  if (sub == 2)
6862  htmlFile << "<h1> Width estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6863  if (sub == 3)
6864  htmlFile << "<h1> Width estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6865  if (sub == 4)
6866  htmlFile << "<h1> Width estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6867  }
6868  if (test == 3) {
6869  if (sub == 1)
6870  htmlFile << "<h1> Ratio estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6871  if (sub == 2)
6872  htmlFile << "<h1> Ratio estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6873  if (sub == 3)
6874  htmlFile << "<h1> Ratio estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6875  if (sub == 4)
6876  htmlFile << "<h1> Ratio estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6877  }
6878  if (test == 4) {
6879  if (sub == 1)
6880  htmlFile << "<h1> Mean bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6881  if (sub == 2)
6882  htmlFile << "<h1> Mean bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6883  if (sub == 3)
6884  htmlFile << "<h1> Mean bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6885  if (sub == 4)
6886  htmlFile << "<h1> Mean bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6887  }
6888  if (test == 5) {
6889  if (sub == 1)
6890  htmlFile << "<h1> Maximum bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6891  if (sub == 2)
6892  htmlFile << "<h1> Maximum bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6893  if (sub == 3)
6894  htmlFile << "<h1> Maximum bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6895  if (sub == 4)
6896  htmlFile << "<h1> Maximum bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6897  }
6898 
6899  if (test == 1) {
6900  htmlFile << "<a name=\"Top\"></a>\n";
6901  htmlFile << "<b>Contents:<br>\n";
6902  htmlFile << "1. <a href=\"#Aij\">A_ij_LS (averaged over events in LS) </a><br>\n";
6903  htmlFile << "2. <a href=\"#OverflowAij\">A_ij_LS in overflow & underflow</a><br>\n";
6904  htmlFile << "3. <a href=\"#MainEstimator\">Main Estimator !!! </a><br>\n";
6905  htmlFile << "4. <a href=\"#ErrorA\">Error type A </a><br>\n";
6906  htmlFile << "5. <a href=\"#ErrorAaverage\">ErrorA cross check</a><br>\n";
6907  htmlFile << "6. <a href=\"#ErrorAoccupancy\">ErrorA occupancy plots</a><br>\n";
6908  htmlFile << "7. <a href=\"#ErrorB\">Error type B</a><br>\n";
6909  htmlFile << "8. <a href=\"#LSstatus\">Table of Average channel-Amplitude in Depthes over LSs </a><br>\n";
6910  htmlFile << "9. <a href=\"#RBXstatus\">RBX Status </a><br>\n";
6911  htmlFile << "10. <a href=\"#RBXPHItable\">Table of Average RBX-Amplitude in Phi over LSs </a><br>\n";
6912  htmlFile << "11. <a href=\"#RBXETAtable\">Table of Average RBX-Amplitude in Eta over LSs </a><br>\n";
6913  htmlFile << "12. <a href=\"#RBX3plots\">RBX A-Ratio to 1st LS: 3 plots </a><br>\n";
6915  }
6916 
6917  // htmlFile << "<a href=\"#Top\">to top</a><br>\n";
6918 
6919  htmlFile << "<br>" << std::endl;
6920  if (test == 0) {
6921  htmlFile << "<h2> 0. Rate of CapID failures over all events of Run </h2>" << std::endl;
6922  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
6923  if (sub == 1)
6924  htmlFile << " <img src=\"MapCapIdErrorHB.png\" />" << std::endl;
6925  if (sub == 2)
6926  htmlFile << " <img src=\"MapCapIdErrorHE.png\" />" << std::endl;
6927  if (sub == 3)
6928  htmlFile << " <img src=\"MapCapIdErrorHO.png\" />" << std::endl;
6929  if (sub == 4)
6930  htmlFile << " <img src=\"MapCapIdErrorHF.png\" />" << std::endl;
6931  }
6932  if (test == 1)
6933  htmlFile << "<a name=\"Aij\"></a>\n";
6934  if (test != 0)
6935  htmlFile << "<h2> 1. Distribution of estimator averaged over events in LS, histogramed over all channels and "
6936  "all LSs </h2>"
6937  << std::endl;
6938  if (test == 0) {
6939  if (sub == 1)
6940  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6941  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6942  if (sub == 2)
6943  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6944  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2), " << CutAb[sub][3]
6945  << " (Depth3).</h2>" << std::endl;
6946  if (sub == 3)
6947  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6948  << CutAb[sub][1] << " (Depth4).</h2>" << std::endl;
6949  if (sub == 4)
6950  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6951  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6952  }
6953 
6954  if (test != 0)
6955  htmlFile << "<h3> see Overflow and Underflow </h3>" << std::endl;
6956  if (test == 0)
6957  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
6958 
6959  if (test == 0) {
6960  if (sub == 1)
6961  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HB.png\" />" << std::endl;
6962  if (sub == 2)
6963  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HE.png\" />" << std::endl;
6964  if (sub == 3)
6965  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HO.png\" />" << std::endl;
6966  if (sub == 4)
6967  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HF.png\" />" << std::endl;
6968  }
6969  if (test == 1) {
6970  if (sub == 1)
6971  htmlFile << " <img src=\"H_ADCamplHB.png\" />" << std::endl;
6972  if (sub == 2)
6973  htmlFile << " <img src=\"H_ADCamplHE.png\" />" << std::endl;
6974  if (sub == 3)
6975  htmlFile << " <img src=\"H_ADCamplHO.png\" />" << std::endl;
6976  if (sub == 4)
6977  htmlFile << " <img src=\"H_ADCamplHF.png\" />" << std::endl;
6978  }
6979  if (test == 2) {
6980  if (sub == 1)
6981  htmlFile << " <img src=\"H_WidthHB.png\" />" << std::endl;
6982  if (sub == 2)
6983  htmlFile << " <img src=\"H_WidthHE.png\" />" << std::endl;
6984  if (sub == 3)
6985  htmlFile << " <img src=\"H_WidthHO.png\" />" << std::endl;
6986  if (sub == 4)
6987  htmlFile << " <img src=\"H_WidthHF.png\" />" << std::endl;
6988  }
6989  if (test == 3) {
6990  if (sub == 1)
6991  htmlFile << " <img src=\"H_RatioHB.png\" />" << std::endl;
6992  if (sub == 2)
6993  htmlFile << " <img src=\"H_RatioHE.png\" />" << std::endl;
6994  if (sub == 3)
6995  htmlFile << " <img src=\"H_RatioHO.png\" />" << std::endl;
6996  if (sub == 4)
6997  htmlFile << " <img src=\"H_RatioHF.png\" />" << std::endl;
6998  }
6999  if (test == 4) {
7000  if (sub == 1)
7001  htmlFile << " <img src=\"H_TmeanHB.png\" />" << std::endl;
7002  if (sub == 2)
7003  htmlFile << " <img src=\"H_TmeanHE.png\" />" << std::endl;
7004  if (sub == 3)
7005  htmlFile << " <img src=\"H_TmeanHO.png\" />" << std::endl;
7006  if (sub == 4)
7007  htmlFile << " <img src=\"H_TmeanHF.png\" />" << std::endl;
7008  }
7009  if (test == 5) {
7010  if (sub == 1)
7011  htmlFile << " <img src=\"H_TmaxHB.png\" />" << std::endl;
7012  if (sub == 2)
7013  htmlFile << " <img src=\"H_TmaxHE.png\" />" << std::endl;
7014  if (sub == 3)
7015  htmlFile << " <img src=\"H_TmaxHO.png\" />" << std::endl;
7016  if (sub == 4)
7017  htmlFile << " <img src=\"H_TmaxHF.png\" />" << std::endl;
7018  }
7019  htmlFile << "<br>" << std::endl;
7020  if (test == 1)
7021  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7022 
7023  if (test == 0)
7024  htmlFile << "<h2> 2a. Number of bad channels per event distribution in Run</h2>" << std::endl;
7025  if (test == 0)
7026  htmlFile << "<h3> Legends: dots correspond to BAD LS candidates. </h3>" << std::endl;
7027  if (test == 0) {
7028  if (sub == 1)
7029  htmlFile << " <img src=\"HistNBadChsHB.png\" />" << std::endl;
7030  if (sub == 2)
7031  htmlFile << " <img src=\"HistNBadChsHE.png\" />" << std::endl;
7032  if (sub == 3)
7033  htmlFile << " <img src=\"HistNBadChsHO.png\" />" << std::endl;
7034  if (sub == 4)
7035  htmlFile << " <img src=\"HistNBadChsHF.png\" />" << std::endl;
7036  }
7037 
7038  if (test == 1)
7039  htmlFile << "<a name=\"OverflowAij\"></a>\n";
7040  if (test != 0)
7041  htmlFile << "<h2> 2. Estimator averaged over all events in the RUN for entries in overflow and underflow of "
7042  "corresponding histogram above </h2>"
7043  << std::endl;
7044  // if (test !=0) htmlFile << "<h2> 2. Estimator averaged over all events in the RUN </h2>"<< std::endl;
7045  if (test == 0)
7046  htmlFile << "<h2> 2b. Averaged number of bad channels for each LS </h2>" << std::endl;
7047  // if (test !=0) htmlFile << "<h3> Channel legend: white - good, other colour - bad. </h3>"<< std::endl;
7048  if (test == 0) {
7049  if (sub == 1)
7050  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7051  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7052  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7053  if (sub == 2)
7054  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7055  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3) correspond BAD LS.</h3>"
7056  << std::endl;
7057  if (sub == 3)
7058  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7059  << " (Depth4) correspond BAD LS.</h3>" << std::endl;
7060  if (sub == 4)
7061  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7062  << Cut0[test][sub][2] << " (Depth2) correspond BAD LS.</h3>" << std::endl;
7063  }
7064  if (test == 0) {
7065  if (sub == 1)
7066  htmlFile << " <img src=\"HistNBCMNHB.png\" />" << std::endl;
7067  if (sub == 2)
7068  htmlFile << " <img src=\"HistNBCMNHE.png\" />" << std::endl;
7069  if (sub == 3)
7070  htmlFile << " <img src=\"HistNBCMNHO.png\" />" << std::endl;
7071  if (sub == 4)
7072  htmlFile << " <img src=\"HistNBCMNHF.png\" />" << std::endl;
7073  }
7074  if (test == 1) {
7075  if (sub == 1)
7076  htmlFile << " <img src=\"MapADCamplHB.png\" />" << std::endl;
7077  if (sub == 2)
7078  htmlFile << " <img src=\"MapADCamplHE.png\" />" << std::endl;
7079  if (sub == 3)
7080  htmlFile << " <img src=\"MapADCamplHO.png\" />" << std::endl;
7081  if (sub == 4)
7082  htmlFile << " <img src=\"MapADCamplHF.png\" />" << std::endl;
7083  }
7084  if (test == 2) {
7085  if (sub == 1)
7086  htmlFile << " <img src=\"MapWidthHB.png\" />" << std::endl;
7087  if (sub == 2)
7088  htmlFile << " <img src=\"MapWidthHE.png\" />" << std::endl;
7089  if (sub == 3)
7090  htmlFile << " <img src=\"MapWidthHO.png\" />" << std::endl;
7091  if (sub == 4)
7092  htmlFile << " <img src=\"MapWidthHF.png\" />" << std::endl;
7093  }
7094  if (test == 3) {
7095  if (sub == 1)
7096  htmlFile << " <img src=\"MapRatioHB.png\" />" << std::endl;
7097  if (sub == 2)
7098  htmlFile << " <img src=\"MapRatioHE.png\" />" << std::endl;
7099  if (sub == 3)
7100  htmlFile << " <img src=\"MapRatioHO.png\" />" << std::endl;
7101  if (sub == 4)
7102  htmlFile << " <img src=\"MapRatioHF.png\" />" << std::endl;
7103  }
7104  if (test == 4) {
7105  if (sub == 1)
7106  htmlFile << " <img src=\"MapTmeanHB.png\" />" << std::endl;
7107  if (sub == 2)
7108  htmlFile << " <img src=\"MapTmeanHE.png\" />" << std::endl;
7109  if (sub == 3)
7110  htmlFile << " <img src=\"MapTmeanHO.png\" />" << std::endl;
7111  if (sub == 4)
7112  htmlFile << " <img src=\"MapTmeanHF.png\" />" << std::endl;
7113  }
7114  if (test == 5) {
7115  if (sub == 1)
7116  htmlFile << " <img src=\"MapTmaxHB.png\" />" << std::endl;
7117  if (sub == 2)
7118  htmlFile << " <img src=\"MapTmaxHE.png\" />" << std::endl;
7119  if (sub == 3)
7120  htmlFile << " <img src=\"MapTmaxHO.png\" />" << std::endl;
7121  if (sub == 4)
7122  htmlFile << " <img src=\"MapTmaxHF.png\" />" << std::endl;
7123  }
7124  htmlFile << "<br>" << std::endl;
7125  if (test == 1)
7126  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7127 
7128  if (test == 1)
7129  htmlFile << "<a name=\"MainEstimator\"></a>\n";
7130  if (test != 0)
7131  htmlFile
7132  << "<h2> 3. Distribution of estimator averaged over events in LS and over all channels for each LS </h2>"
7133  << std::endl;
7134  if (test == 0) {
7135  if (sub == 1)
7136  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7137  << " (Depth2) in each LS.</h2>" << std::endl;
7138  if (sub == 2)
7139  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7140  << " (Depth2), " << CutPo[sub][3] << " (Depth3) in each LS.</h2>" << std::endl;
7141  if (sub == 3)
7142  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][4] << " (Depth4) in each LS.</h2>"
7143  << std::endl;
7144  if (sub == 4)
7145  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7146  << " (Depth2) in each LS.</h2>" << std::endl;
7147  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
7148  }
7149  if (test != 0) {
7150  if (sub == 1)
7151  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7152  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7153  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7154  if (sub == 2)
7155  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7156  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7157  << " (Depth4), " << Cut0[test][sub][5] << " (Depth5), " << Cut0[test][sub][6] << " (Depth6), "
7158  << Cut0[test][sub][7] << " (Depth7) correspond BAD LS. </h3>" << std::endl;
7159  if (sub == 3)
7160  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7161  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7162  if (sub == 4)
7163  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7164  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7165  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7166  }
7167  if (test == 0) {
7168  if (sub == 1)
7169  htmlFile << " <img src=\"HistPortHB.png\" />" << std::endl;
7170  if (sub == 2)
7171  htmlFile << " <img src=\"HistPortHE.png\" />" << std::endl;
7172  if (sub == 3)
7173  htmlFile << " <img src=\"HistPortHO.png\" />" << std::endl;
7174  if (sub == 4)
7175  htmlFile << " <img src=\"HistPortHF.png\" />" << std::endl;
7176  }
7177  if (test == 1) {
7178  if (sub == 1)
7179  htmlFile << " <img src=\"HistADCamplHB.png\" />" << std::endl;
7180  if (sub == 2)
7181  htmlFile << " <img src=\"HistADCamplHE.png\" />" << std::endl;
7182  if (sub == 3)
7183  htmlFile << " <img src=\"HistADCamplHO.png\" />" << std::endl;
7184  if (sub == 4)
7185  htmlFile << " <img src=\"HistADCamplHF.png\" />" << std::endl;
7186  }
7187  if (test == 2) {
7188  if (sub == 1)
7189  htmlFile << " <img src=\"HistWidthHB.png\" />" << std::endl;
7190  if (sub == 2)
7191  htmlFile << " <img src=\"HistWidthHE.png\" />" << std::endl;
7192  if (sub == 3)
7193  htmlFile << " <img src=\"HistWidthHO.png\" />" << std::endl;
7194  if (sub == 4)
7195  htmlFile << " <img src=\"HistWidthHF.png\" />" << std::endl;
7196  }
7197  if (test == 3) {
7198  if (sub == 1)
7199  htmlFile << " <img src=\"HistRatioHB.png\" />" << std::endl;
7200  if (sub == 2)
7201  htmlFile << " <img src=\"HistRatioHE.png\" />" << std::endl;
7202  if (sub == 3)
7203  htmlFile << " <img src=\"HistRatioHO.png\" />" << std::endl;
7204  if (sub == 4)
7205  htmlFile << " <img src=\"HistRatioHF.png\" />" << std::endl;
7206  }
7207  if (test == 4) {
7208  if (sub == 1)
7209  htmlFile << " <img src=\"HistTmeanHB.png\" />" << std::endl;
7210  if (sub == 2)
7211  htmlFile << " <img src=\"HistTmeanHE.png\" />" << std::endl;
7212  if (sub == 3)
7213  htmlFile << " <img src=\"HistTmeanHO.png\" />" << std::endl;
7214  if (sub == 4)
7215  htmlFile << " <img src=\"HistTmeanHF.png\" />" << std::endl;
7216  }
7217  if (test == 5) {
7218  if (sub == 1)
7219  htmlFile << " <img src=\"HistTmaxHB.png\" />" << std::endl;
7220  if (sub == 2)
7221  htmlFile << " <img src=\"HistTmaxHE.png\" />" << std::endl;
7222  if (sub == 3)
7223  htmlFile << " <img src=\"HistTmaxHO.png\" />" << std::endl;
7224  if (sub == 4)
7225  htmlFile << " <img src=\"HistTmaxHF.png\" />" << std::endl;
7226  }
7227  htmlFile << "<br>" << std::endl;
7228 
7229  if (test == 1) {
7230  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7231  htmlFile << "<a name=\"ErrorA\"></a>\n";
7232  htmlFile << "<h2> 4. Error type A</h2>\n";
7233  htmlFile << "<h3> note: no sence to see plots of this item if max difference is too large(due to very high A "
7234  "of some channels)</h3>\n";
7235  htmlFile << "<br>\n";
7236 
7237  //HB:
7238  if (sub == 1) {
7239  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.6 (p-p collisions) </h3>\n";
7240  htmlFile << " <img src=\"HistErrA_HB.png\" />\n";
7241  htmlFile << "<br>\n";
7242  if (flagErrAB_HB[0] == -1)
7243  htmlFile << "<h3>test was not possible</h3>\n";
7244  else if (flagErrAB_HB[0] == 0)
7245  htmlFile << "<h3> Fine:NoErrorA_HB (Mean of max difference " << avedelta_HB
7246  << " is within 0.1-1.6) </h3>\n";
7247  else if (flagErrAB_HB[0] == 1)
7248  htmlFile << "<<h3> ErrorA_HB is available once Mean of max difference " << avedelta_HB
7249  << " is out 0.1-1.6 (p-p collisions)</font></h3>\n";
7250  else
7251  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7252  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7253 
7254  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7255 
7256  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7257  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >25), "
7258  "3) with channel Amplitude (A<35); </h2>\n";
7259  htmlFile << " <img src=\"ChkErrA_HB1.png\" /><br><br>\n";
7260  htmlFile << " <img src=\"ChkErrA_HB2.png\" /><br>\n";
7261  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7262 
7263  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7264  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 25 "
7265  "(HBM:neg.eta;HBP:pos.eta) </h2>\n";
7266  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7267  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.6 at least for HF- or "
7268  "HF+ </h2>\n";
7269  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.6 and is the same "
7270  "for HF- and HF+ </h2>\n";
7271  htmlFile << " <img src=\"OccPlots_HB.png\" /><br><br>\n";
7272  htmlFile << "<br>\n";
7273  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7274 
7275  htmlFile << "<a name=\"ErrorB\"></a>\n";
7276  htmlFile << "<h2> 7. Error type B\n";
7277  htmlFile << "<h3> ErrorB identification: digi-collection size != 10.</h3>\n";
7278  htmlFile << " <img src=\"HistErrB_HB_1.png\" />\n<br>\n";
7279  htmlFile << " <img src=\"HistErrB_HB_2.png\" />\n<br>\n";
7280  htmlFile << "<br>\n";
7281  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HB << " LS </h3>\n";
7282  htmlFile << "<br>\n";
7283  }
7284 
7285  //HE:
7286  if (sub == 2) {
7287  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.2-1.8 (p-p collisions) </h3>\n";
7288  htmlFile << " <img src=\"HistErrA_HE.png\" />\n";
7289  htmlFile << "<br>\n";
7290  if (flagErrAB_HE[0] == -1)
7291  htmlFile << "<h3>test was not possible</h3>\n";
7292  else if (flagErrAB_HE[0] == 0)
7293  htmlFile << "<h3> Fine:NoErrorA_HE (Mean of max difference " << avedelta_HE
7294  << " is within 0.2-1.8) </h3>\n";
7295  else if (flagErrAB_HE[0] == 1)
7296  htmlFile << "<<h3> ErrorA_HE is available once Mean of max difference " << avedelta_HE
7297  << " is out 0.2-1.8 (p-p collisions)</font></h3>\n";
7298  else
7299  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7300  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7301 
7302  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7303 
7304  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7305  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> "
7306  ">1000.fC), 3) with channel Amplitude (A<500fC); </h2>\n";
7307  htmlFile << " <img src=\"ChkErrA_HE1.png\" /><br><br>\n";
7308  htmlFile << " <img src=\"ChkErrA_HE2.png\" /><br>\n";
7309  htmlFile << " <img src=\"ChkErrA_HE3.png\" /><br>\n";
7310  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7311 
7312  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7313  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 35 "
7314  "(HEM:neg.eta;HEP:pos.eta) </h2>\n";
7315  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7316  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.3 at least for HF- or "
7317  "HF+ </h2>\n";
7318  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.3 and is the same "
7319  "for HF- and HF+ </h2>\n";
7320  htmlFile << " <img src=\"OccPlots_HE.png\" /><br><br>\n";
7321  htmlFile << "<br>\n";
7322  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7323 
7324  htmlFile << "<a name=\"ErrorB\"></a>\n";
7325  htmlFile << "<h2> 7. Error type B\n";
7326  htmlFile << "<h3> ErrorB identification: digi-collection size != 8.</h3>\n";
7327  htmlFile << " <img src=\"HistErrB_HE_1.png\" />\n<br>\n";
7328  htmlFile << " <img src=\"HistErrB_HE_2.png\" />\n<br>\n";
7329  htmlFile << " <img src=\"HistErrB_HE_3.png\" />\n<br>\n";
7330  htmlFile << "<br>\n";
7331  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HE << " LS </h3>\n";
7332  htmlFile << "<br>\n";
7333  }
7334 
7335  //HO:
7336  if (sub == 3) {
7337  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.5 (p-p collisions) </h3>\n";
7338  htmlFile << " <img src=\"HistErrA_HO.png\" />\n";
7339  htmlFile << "<br>\n";
7340  if (flagErrAB_HO[0] == -1)
7341  htmlFile << "<h3>test was not possible</h3>\n";
7342  else if (flagErrAB_HO[0] == 0)
7343  htmlFile << "<h3> Fine:NoErrorA_HO (Mean of max difference " << avedelta_HO
7344  << " is within 0.1-1.5) </h3>\n";
7345  else if (flagErrAB_HO[0] == 1)
7346  htmlFile << "<<h3> ErrorA_HO is available once Mean of max difference " << avedelta_HO
7347  << " is out 0.1-1.5 (p-p collisions)</font></h3>\n";
7348  else
7349  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7350  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7351 
7352  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7353 
7354  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7355  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >80), "
7356  "3) with channel Amplitude (A<100); </h2>\n";
7357  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7358  htmlFile << " <img src=\"ChkErrA_HO4.png\" /><br><br>\n";
7359  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7360 
7361  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7362  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 80 "
7363  "(HOM:neg.eta;HOP:pos.eta) </h2>\n";
7364  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7365  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7366  "HF+ </h2>\n";
7367  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7368  "for HF- and HF+ </h2>\n";
7369  htmlFile << " <img src=\"OccPlots_HO.png\" /><br><br>\n";
7370  htmlFile << "<br>\n";
7371  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7372 
7373  htmlFile << "<a name=\"ErrorB\"></a>\n";
7374  htmlFile << "<h2> 7. Error type B\n";
7375  htmlFile << "<h3> ErrorB identification: digi-collection size != 10. </h3>\n";
7376  htmlFile << " <img src=\"HistErrB_HO_4.png\" />\n<br>\n";
7377  htmlFile << "<br>\n";
7378  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HO << " LS </h3>\n";
7379  htmlFile << "<br>\n";
7380  }
7381 
7382  //HF:
7383  if (sub == 4) {
7384  // flagSpecHF+=1;
7385  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.8-2.4 (p-p collisions) </h3>\n";
7386  htmlFile << " <img src=\"HistErrA_HF.png\" />\n";
7387  htmlFile << "<br>\n";
7388  if (flagErrAB_HF[0] == -1)
7389  htmlFile << "<h3>test was not possible</h3>\n";
7390  else if (flagErrAB_HF[0] == 0)
7391  htmlFile << "<h3> Fine:NoErrorA_HF (Mean of max difference " << avedelta_HF
7392  << " is within 0.8-2.4) </h3>\n";
7393  else if (flagErrAB_HF[0] == 1)
7394  htmlFile << "<<h3> ErrorA_HF is available once Mean of max difference " << avedelta_HF
7395  << " is out 0.8-2.4 (p-p collisions)</font></h3>\n";
7396  else
7397  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7398  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7399 
7400  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7401 
7402  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7403  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >20), "
7404  "3) with channel Amplitude (A<20); </h2>\n";
7405  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7406  htmlFile << " <img src=\"ChkErrA_HF1.png\" /><br><br>\n";
7407  htmlFile << " <img src=\"ChkErrA_HF2.png\" /><br>\n";
7408  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7409 
7410  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7411  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 20 "
7412  "(HFM:neg.eta;HFP:pos.eta) </h2>\n";
7413  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7414  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7415  "HF+ </h2>\n";
7416  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7417  "for HF- and HF+ </h2>\n";
7418  htmlFile << " <img src=\"OccPlots_HF.png\" /><br><br>\n";
7419  htmlFile << "<br>\n";
7420  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7421 
7422  htmlFile << "<a name=\"ErrorB\"></a>\n";
7423  htmlFile << "<h2> 7. Error type B\n";
7424  htmlFile << "<h3> ErrorB identification: digi-collection size != 4. </h3>\n";
7425  htmlFile << " <img src=\"HistErrB_HF_1.png\" />\n<br>\n";
7426  htmlFile << " <img src=\"HistErrB_HF_2.png\" />\n<br>\n";
7427  htmlFile << "<br>\n";
7428  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HF << " LS </h3>\n";
7429  htmlFile << "<br>\n";
7430  }
7431  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7432 
7433  } //test=1 Amplitude
7434 
7435  if (test == 1)
7436  htmlFile << "<a name=\"LSstatus\"></a>\n";
7437  // Continue with common sections
7438  if (sub == 1) {
7439  htmlFile << "<h2> 8.Lumisection Status for HB: </h2>" << std::endl;
7440  // htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: <td class=\"s6\" align=\"center\">"<<Cut0[test][sub][1]<<" (Depth1), "<<Cut0[test][sub][2]<<" (Depth2). </td></h3>"<< std::endl;
7441  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7442  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), "
7443  << Cut0[test][sub][4] << " (Depth4), </h3>" << std::endl;
7444  }
7445  if (sub == 2) {
7446  htmlFile << "<h2> 8.Lumisection Status for HE: </h2>" << std::endl;
7447  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7448  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3),"
7449  << Cut0[test][sub][4] << " (Depth4)," << Cut0[test][sub][5] << " (Depth5)," << Cut0[test][sub][6]
7450  << " (Depth6)," << Cut0[test][sub][7] << " (Depth7). </h3>" << std::endl;
7451  }
7452  if (sub == 3) {
7453  // htmlFile << Form("<h2> %d.Lumisection Status for HO </h2>",4+flagSpecHF)<< std::endl;
7454  htmlFile << "<h2> 8.Lumisection Status for HO: </h2>" << std::endl;
7455  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][4]
7456  << " (Depth4). </h3>" << std::endl;
7457  }
7458  if (sub == 4) {
7459  htmlFile << "<h2> 8.Lumisection Status for HF: </h2>" << std::endl;
7460  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7461  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), "
7462  << Cut0[test][sub][4] << " (Depth4), </h3>" << std::endl;
7463  }
7464  htmlFile << "<br>" << std::endl;
7465  htmlFile << "<table>" << std::endl;
7466  htmlFile << "<tr>";
7467  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7468  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7469  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7471 
7472  int kkkkkkmax = k_max[sub];
7473  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
7474  kkkkkkmax = k_maxupgrade[sub];
7475  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
7476  // if (test==1 && sub==4) kkkkkkmax = k_maxupgrade[sub];
7477 
7478  if (test == 0)
7479  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7480  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > Depth " << k << " </td>" << std::endl;
7481  if (test == 1)
7482  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7483  htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth " << k << " </td>" << std::endl;
7484  if (test == 2)
7485  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7486  htmlFile << "<td class=\"s1\" align=\"center\">< W > Depth " << k << " </td>" << std::endl;
7487  if (test == 3)
7488  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7489  htmlFile << "<td class=\"s1\" align=\"center\">< R > Depth " << k << " </td>" << std::endl;
7490  if (test == 4)
7491  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7492  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > Depth " << k << " </td>" << std::endl;
7493  if (test == 5)
7494  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7495  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > Depth " << k << " </td>" << std::endl;
7496  htmlFile << "</tr>" << std::endl;
7497 
7498  ind = 0;
7499  for (int i = 1; i <= MaxLum; i++) {
7500  if ((ind % 2) == 1)
7501  raw_class = "<td class=\"s2\" align=\"center\">";
7502  else
7503  raw_class = "<td class=\"s3\" align=\"center\">";
7504  htmlFile << "<tr>" << std::endl;
7505  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7506  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7507  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7508  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
7509  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k]) {
7510  if (test == 1)
7511  htmlFile << "<td class=\"s6\" align=\"center\">"
7512  << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7513  else
7514  htmlFile << "<td class=\"s6\" align=\"center\">" << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i))
7515  << "</td>" << std::endl;
7516  } else {
7517  if (test == 1)
7518  htmlFile << raw_class << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7519  else
7520  htmlFile << raw_class << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7521  }
7522  }
7523  htmlFile << "</tr>" << std::endl;
7524  ind += 1;
7525  }
7526  htmlFile << "</table>" << std::endl;
7527 
7528  htmlFile << "<br>" << std::endl;
7529  if (test == 1)
7530  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7531  htmlFile << "<br>" << std::endl;
7532 
7533  // Only for Amplitudes (test=1):
7535  if (test == 1) {
7538  htmlFile << "<a name=\"RBXstatus\"></a>\n";
7539 
7540  //HB j = 7,8,9,10 11,12,13,14
7541  if (sub == 1) {
7542  htmlFile << "<h2> 9. Average Amplitudes of RBX for HB: </h2>" << std::endl;
7543  htmlFile << "<h3> where </h3>" << std::endl;
7544  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7545  "(Positive direction); </h3>"
7546  << std::endl;
7547  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7548  // 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;
7549  htmlFile << " <img src=\"RBX-HB-2Dplot.png\" />\n";
7550  htmlFile << "<br>\n";
7551 
7552  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HB: </h2>" << std::endl;
7553  htmlFile << " <img src=\"RBX-HB-1Dplot.png\" />\n";
7554  htmlFile << "<br>\n";
7555 
7556  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HB: </h2>" << std::endl;
7557  htmlFile << " <img src=\"RBX-HB-11Dplot.png\" />\n";
7558  htmlFile << "<br>\n";
7559 
7560  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7561  }
7562  // HE: j = 3,4,5, 6, 7 14,15,16,17,18
7563  if (sub == 2) {
7564  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HE: </h2>" << std::endl;
7565  htmlFile << "<h3> where </h3>" << std::endl;
7566  htmlFile << "<h3> jeta = 3,4,5, 6, 7 (Negative direction); ............&& ............ jeta = "
7567  "14,15,16,17,18 (Positive direction); </h3>"
7568  << std::endl;
7569  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7570  // 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;
7571  htmlFile << " <img src=\"RBX-HE-2Dplot.png\" />\n";
7572  htmlFile << "<br>\n";
7573 
7574  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HE: </h2>" << std::endl;
7575  htmlFile << " <img src=\"RBX-HE-1Dplot.png\" />\n";
7576  htmlFile << "<br>\n";
7577 
7578  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HE: </h2>" << std::endl;
7579  htmlFile << " <img src=\"RBX-HE-11Dplot.png\" />\n";
7580  htmlFile << "<br>\n";
7581 
7582  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7583  }
7584  // HO: j = 7,8,9,10 11,12,13,14
7585  if (sub == 3) {
7586  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HO: </h2>" << std::endl;
7587  htmlFile << "<h3> where </h3>" << std::endl;
7588  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7589  "(Positive direction); </h3>"
7590  << std::endl;
7591  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7592  // 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;
7593  htmlFile << " <img src=\"RBX-HO-2Dplot.png\" />\n";
7594  htmlFile << "<br>\n";
7595 
7596  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HO: </h2>" << std::endl;
7597  htmlFile << " <img src=\"RBX-HO-1Dplot.png\" />\n";
7598  htmlFile << "<br>\n";
7599 
7600  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HO: </h2>" << std::endl;
7601  htmlFile << " <img src=\"RBX-HO-11Dplot.png\" />\n";
7602  htmlFile << "<br>\n";
7603 
7604  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7605  }
7606  //HF:j = 0,1,2, 3 18,19,20,21
7607  if (sub == 4) {
7608  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HF: </h2>" << std::endl;
7609  htmlFile << "<h3> where </h3>" << std::endl;
7610  htmlFile << "<h3> jeta = 0,1,2, 3 (Negative direction); ............&& ............ jeta = 18,19,20,21 "
7611  "(Positive direction); </h3>"
7612  << std::endl;
7613  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7614  // 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;
7615  htmlFile << " <img src=\"RBX-HF-2Dplot.png\" />\n";
7616  htmlFile << "<br>\n";
7617 
7618  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HF: </h2>" << std::endl;
7619  htmlFile << " <img src=\"RBX-HF-1Dplot.png\" />\n";
7620  htmlFile << "<br>\n";
7621 
7622  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HF: </h2>" << std::endl;
7623  htmlFile << " <img src=\"RBX-HF-11Dplot.png\" />\n";
7624  htmlFile << "<br>\n";
7625 
7626  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7627  }
7628  htmlFile << "<br>" << std::endl;
7629 
7632 
7633  htmlFile << "<a name=\"RBXPHItable\"></a>\n";
7634  int cutA_ALL = 0;
7635  // float cutA_HB = 100.;float cutA_HE = 1000000.;float cutA_HO = 150.;float cutA_HF = 500.;
7636  if (sub == 1) {
7637  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HB: </h2>" << std::endl;
7638  htmlFile
7639  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7640  << cutA_HB << std::endl;
7641  cutA_ALL = cutA_HB;
7642  }
7643  if (sub == 2) {
7644  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HE: </h2>" << std::endl;
7645  htmlFile
7646  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7647  << cutA_HE << std::endl;
7648  cutA_ALL = cutA_HE;
7649  }
7650  if (sub == 3) {
7651  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HO: </h2>" << std::endl;
7652  htmlFile
7653  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7654  << cutA_HO << std::endl;
7655  cutA_ALL = cutA_HO;
7656  }
7657  if (sub == 4) {
7658  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HF: </h2>" << std::endl;
7659  htmlFile
7660  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7661  << cutA_HF << std::endl;
7662  cutA_ALL = cutA_HF;
7663  }
7664 
7665  htmlFile << "<br>" << std::endl;
7666  htmlFile << "<table>" << std::endl;
7667  htmlFile << "<tr>";
7668  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7669  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7670  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7672 
7673  // k is jphi
7674  for (int k = 0; k < njphi; k++)
7675  htmlFile << "<td class=\"s1\" align=\"center\"> iPHI " << k << " </td>" << std::endl;
7676  htmlFile << "</tr>" << std::endl;
7678 
7679  ind = 0;
7680  // i is LS
7681  for (int i = 1; i <= MaxLum; i++) {
7682  if ((ind % 2) == 1)
7683  raw_class = "<td class=\"s2\" align=\"center\">";
7684  else
7685  raw_class = "<td class=\"s3\" align=\"center\">";
7686  htmlFile << "<tr>" << std::endl;
7687  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7688  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7689  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7690 
7691  // k is jphi
7692  for (int k = 0; k < njphi; k++) {
7693  if (sub == 1) {
7694  if (int(alexhb[k][i - 1]) > cutA_ALL) {
7695  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7696  } else {
7697  htmlFile << raw_class << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7698  }
7699  } // HB end
7700  if (sub == 2) {
7701  if (int(alexhe[k][i - 1]) > cutA_ALL) {
7702  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7703  } else {
7704  htmlFile << raw_class << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7705  }
7706  } // HE end
7707  if (sub == 3) {
7708  if (int(alexho[k][i - 1]) > cutA_ALL) {
7709  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexho[k][i - 1]) << "</td>" << std::endl;
7710  } else {
7711  htmlFile << raw_class << int(alexho[k][i - 1]) << "</td>" << std::endl;
7712  }
7713  } // HO end
7714  if (sub == 4) {
7715  if (int(alexhf[k][i - 1]) > cutA_ALL) {
7716  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7717  } else {
7718  htmlFile << raw_class << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7719  }
7720  } // HF end
7722  } // k over PHI-RBX
7723  htmlFile << "</tr>" << std::endl;
7724  ind += 1;
7725  } // i over LSs
7726  htmlFile << "</table>" << std::endl;
7727  htmlFile << "<br>" << std::endl;
7728  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7729  htmlFile << "<br>" << std::endl;
7731 
7732  htmlFile << "<a name=\"RBXETAtable\"></a>\n";
7733  int cutB_ALL = 0;
7734  // float cutB_HB = 100.;float cutB_HE = 1000000.;float cutB_HO = 150.;float cutB_HF = 500.;
7735  if (sub == 1) {
7736  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HB: </h2>" << std::endl;
7737  htmlFile
7738  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7739  << cutB_HB << std::endl;
7740  cutB_ALL = cutB_HB;
7741  }
7742  if (sub == 2) {
7743  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HE: </h2>" << std::endl;
7744  htmlFile
7745  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7746  << cutB_HE << std::endl;
7747  cutB_ALL = cutB_HE;
7748  }
7749  if (sub == 3) {
7750  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HO: </h2>" << std::endl;
7751  htmlFile
7752  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7753  << cutB_HO << std::endl;
7754  cutB_ALL = cutB_HO;
7755  }
7756  if (sub == 4) {
7757  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HF: </h2>" << std::endl;
7758  htmlFile
7759  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7760  << cutB_HF << std::endl;
7761  cutB_ALL = cutB_HF;
7762  }
7763 
7764  htmlFile << "<br>" << std::endl;
7765  htmlFile << "<table>" << std::endl;
7766  htmlFile << "<tr>";
7767  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7768  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7769  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7771 
7772  // k is jeta
7773  for (int k = 0; k < njeta; k++)
7774  htmlFile << "<td class=\"s1\" align=\"center\"> iETA " << k << " </td>" << std::endl;
7775  htmlFile << "</tr>" << std::endl;
7777 
7778  ind = 0;
7779  // i is LS
7780  for (int i = 1; i <= MaxLum; i++) {
7781  if ((ind % 2) == 1)
7782  raw_class = "<td class=\"s2\" align=\"center\">";
7783  else
7784  raw_class = "<td class=\"s3\" align=\"center\">";
7785  htmlFile << "<tr>" << std::endl;
7786  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7787  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7788  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7789 
7790  // k is jeta
7791  for (int k = 0; k < njeta; k++) {
7792  if (sub == 1) {
7793  if (int(blexhb[k][i - 1]) > cutB_ALL) {
7794  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7795  } else {
7796  htmlFile << raw_class << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7797  }
7798  } // HB end
7799  if (sub == 2) {
7800  if (int(blexhe[k][i - 1]) > cutB_ALL) {
7801  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7802  } else {
7803  htmlFile << raw_class << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7804  }
7805  } // HE end
7806  if (sub == 3) {
7807  if (int(blexho[k][i - 1]) > cutB_ALL) {
7808  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexho[k][i - 1]) << "</td>" << std::endl;
7809  } else {
7810  htmlFile << raw_class << int(blexho[k][i - 1]) << "</td>" << std::endl;
7811  }
7812  } // HO end
7813  if (sub == 4) {
7814  if (int(blexhf[k][i - 1]) > cutB_ALL) {
7815  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7816  } else {
7817  htmlFile << raw_class << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7818  }
7819  } // HF end
7821  } // k over ETA-RBX
7822  htmlFile << "</tr>" << std::endl;
7823  ind += 1;
7824  } // i over LSs
7825  htmlFile << "</table>" << std::endl;
7826  htmlFile << "<br>" << std::endl;
7827  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7828  htmlFile << "<br>" << std::endl;
7830 
7833  htmlFile << "<a name=\"RBX3plots\"></a>\n";
7834  htmlFile << "<br>\n";
7835  htmlFile << "<h2> 12. (Rij) - RBX-amplitudes normilized on reference LS (~=1st) </h2>" << std::endl;
7836  htmlFile << "<h3> ( Rji . . is ratio of . . . . A_j_i . . to . . A_j_ref . . . . for . . j-RBX . . and . . "
7837  "i-LS . ) </h3>"
7838  << std::endl;
7839 
7840  htmlFile << "<br>\n";
7841  htmlFile << "<h2> . . . . . . . . . . . . . . 1) . average Ri vs iLS:. . . . . . . . . . . . . . . . . . . . . "
7842  ". . 2) . average Rj shown for Rij outside meanValue range either 0.95-1.05 or 3RMS: . . . . . . . "
7843  ". . . . . . . . . . . . . . . . . . 3) . Rij: </h2>"
7844  << std::endl;
7845  htmlFile << "<br>\n";
7846  if (sub == 1) {
7847  htmlFile << " <img src=\"RBX-HB-3plots.png\" />\n";
7848  }
7849  if (sub == 2) {
7850  htmlFile << " <img src=\"RBX-HE-3plots.png\" />\n";
7851  }
7852  if (sub == 3) {
7853  htmlFile << " <img src=\"RBX-HO-3plots.png\" />\n";
7854  }
7855  if (sub == 4) {
7856  htmlFile << " <img src=\"RBX-HF-3plots.png\" />\n";
7857  }
7858  htmlFile << "<br>\n";
7859 
7860  htmlFile << "<br>\n";
7861  htmlFile << "<h2> . 4). average Rj shown for Rij outside meanValue range 0.80-1.20: . . . . . . . .5) . "
7862  "average Rj shown for Rij outside meanValue range 0.70-1.30: . . . . . . . .6). average Rj shown "
7863  "for Rij outside meanValue range 0.60-1.40: </h2>"
7864  << std::endl;
7865  htmlFile << "<br>\n";
7866  if (sub == 1) {
7867  htmlFile << " <img src=\"RBX-HB-3plotsmore.png\" />\n";
7868  }
7869  if (sub == 2) {
7870  htmlFile << " <img src=\"RBX-HE-3plotsmore.png\" />\n";
7871  }
7872  if (sub == 3) {
7873  htmlFile << " <img src=\"RBX-HO-3plotsmore.png\" />\n";
7874  }
7875  if (sub == 4) {
7876  htmlFile << " <img src=\"RBX-HF-3plotsmore.png\" />\n";
7877  }
7878  htmlFile << "<br>\n";
7879 
7880  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7881 
7882  //=========================================================
7883 
7884  } // test=1
7885 
7886  //===============================================================================
7887 
7888  htmlFile.close();
7889  } // sub main loop
7890  } //test main loop
7891  //===============================================================================
7892  //===============================================================================
7893  //===============================================================================
7894  //===============================================================================
7895  //===============================================================================
7896 
7897  //======================================================================
7898  // Creating tests html pages:
7899 
7900  for (int test = 0; test <= 5; test++) { //Test: 0,
7901  if (test == 0)
7902  htmlFile.open("CapID_GL.html");
7903  if (test == 1)
7904  htmlFile.open("ADCampl_GL.html");
7905  if (test == 2)
7906  htmlFile.open("Width_GL.html");
7907  if (test == 3)
7908  htmlFile.open("Ratio_GL.html");
7909  if (test == 4)
7910  htmlFile.open("Tmean_GL.html");
7911  if (test == 5)
7912  htmlFile.open("Tmax_GL.html");
7913 
7914  // cout<<"Creating tests html pages: test= "<< test << endl;
7915 
7916  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
7917  htmlFile << "<head>" << std::endl;
7918  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
7919  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
7920  htmlFile << "<style type=\"text/css\">" << std::endl;
7921  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
7922  << std::endl;
7923  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
7924  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
7925  "text-align: center;}"
7926  << std::endl;
7927  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
7928  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
7929  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
7930  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
7931  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
7932  htmlFile << "</style>" << std::endl;
7933  htmlFile << "<body>" << std::endl;
7934  if (test == 0)
7935  htmlFile << "<h1> CAP ID ERRORS, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7936  if (test == 1)
7937  htmlFile << "<h1> ADC AMPLITIDE, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7938  if (test == 2)
7939  htmlFile << "<h1> WIDTH, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7940  if (test == 3)
7941  htmlFile << "<h1> RATIO, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7942  if (test == 4)
7943  htmlFile << "<h1> TIMING MEAN, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7944  if (test == 5)
7945  htmlFile << "<h1> TIMING MAX, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7946  htmlFile << "<br>" << std::endl;
7947  htmlFile << "<h2> 1. Map of suspicious channels with this criterion for whole HCAL </h2>" << std::endl;
7948  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
7949  htmlFile << "<br>" << std::endl;
7950  if (test == 0)
7951  htmlFile << " <img src=\"MapCapIdError.png\" />" << std::endl;
7952  if (test == 1)
7953  htmlFile << " <img src=\"MapADCAmpl.png\" />" << std::endl;
7954  if (test == 2)
7955  htmlFile << " <img src=\"MapWidth.png\" />" << std::endl;
7956  if (test == 3)
7957  htmlFile << " <img src=\"MapRatio.png\" />" << std::endl;
7958  if (test == 4)
7959  htmlFile << " <img src=\"MapTmean.png\" />" << std::endl;
7960  if (test == 5)
7961  htmlFile << " <img src=\"MapTmax.png\" />" << std::endl;
7962  htmlFile << "<br>" << std::endl;
7963  htmlFile << "<h2> 2. For whole HCAL: </h2>" << std::endl;
7964  htmlFile << "<br>" << std::endl;
7965  if (test == 0)
7966  htmlFile << " <img src=\"HistCapID.png\" />" << std::endl;
7967  if (test == 1)
7968  htmlFile << " <img src=\"HistADCAmpl.png\" />" << std::endl;
7969  if (test == 2)
7970  htmlFile << " <img src=\"HistWidth.png\" />" << std::endl;
7971  if (test == 3)
7972  htmlFile << " <img src=\"HistRatio.png\" />" << std::endl;
7973  if (test == 4)
7974  htmlFile << " <img src=\"HistTmean.png\" />" << std::endl;
7975  if (test == 5)
7976  htmlFile << " <img src=\"HistTmax.png\" />" << std::endl;
7977  htmlFile << "<br>" << std::endl;
7978  htmlFile << "<h2> 3. Status of subdetectors </h2>" << std::endl;
7979  htmlFile << "<table width=\"400\">" << std::endl;
7980  htmlFile << "<tr>" << std::endl;
7981  if (test == 0) {
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_CapID.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_CapID.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_CapID.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_CapID.html\">HF</a></td>" << std::endl;
7998  }
7999  if (test == 1) {
8000  // AZ 07.11.2018
8001  htmlFile << " <td><a href=\"HB_ADCampl.html\">HB</a></td>" << std::endl;
8002  htmlFile << " <td><a href=\"HE_ADCampl.html\">HE</a></td>" << std::endl;
8003  htmlFile << " <td><a href=\"HO_ADCampl.html\">HO</a></td>" << std::endl;
8004  htmlFile << " <td><a href=\"HF_ADCampl.html\">HF</a></td>" << std::endl;
8005  /*
8006  htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HB_ADCampl.html\">HB</a></td>"<< std::endl;
8007  htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HE_ADCampl.html\">HE</a></td>"<< std::endl;
8008  htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HO_ADCampl.html\">HO</a></td>"<< std::endl;
8009  htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HF_ADCampl.html\">HF</a></td>"<< std::endl;
8010 */
8011  }
8012  if (test == 2) {
8013  htmlFile << " <td><a "
8014  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8015  "HcalRemoteMonitoring/CMT/GLOBAL_"
8016  << runnumber << "/HB_Width.html\">HB</a></td>" << std::endl;
8017  htmlFile << " <td><a "
8018  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8019  "HcalRemoteMonitoring/CMT/GLOBAL_"
8020  << runnumber << "/HE_Width.html\">HE</a></td>" << std::endl;
8021  htmlFile << " <td><a "
8022  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8023  "HcalRemoteMonitoring/CMT/GLOBAL_"
8024  << runnumber << "/HO_Width.html\">HO</a></td>" << std::endl;
8025  htmlFile << " <td><a "
8026  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8027  "HcalRemoteMonitoring/CMT/GLOBAL_"
8028  << runnumber << "/HF_Width.html\">HF</a></td>" << std::endl;
8029  }
8030  if (test == 3) {
8031  htmlFile << " <td><a "
8032  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8033  "HcalRemoteMonitoring/CMT/GLOBAL_"
8034  << runnumber << "/HB_Ratio.html\">HB</a></td>" << std::endl;
8035  htmlFile << " <td><a "
8036  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8037  "HcalRemoteMonitoring/CMT/GLOBAL_"
8038  << runnumber << "/HE_Ratio.html\">HE</a></td>" << std::endl;
8039  htmlFile << " <td><a "
8040  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8041  "HcalRemoteMonitoring/CMT/GLOBAL_"
8042  << runnumber << "/HO_Ratio.html\">HO</a></td>" << std::endl;
8043  htmlFile << " <td><a "
8044  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8045  "HcalRemoteMonitoring/CMT/GLOBAL_"
8046  << runnumber << "/HF_Ratio.html\">HF</a></td>" << std::endl;
8047  }
8048  if (test == 4) {
8049  htmlFile << " <td><a "
8050  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8051  "HcalRemoteMonitoring/CMT/GLOBAL_"
8052  << runnumber << "/HB_Tmean.html\">HB</a></td>" << std::endl;
8053  htmlFile << " <td><a "
8054  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8055  "HcalRemoteMonitoring/CMT/GLOBAL_"
8056  << runnumber << "/HE_Tmean.html\">HE</a></td>" << std::endl;
8057  htmlFile << " <td><a "
8058  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8059  "HcalRemoteMonitoring/CMT/GLOBAL_"
8060  << runnumber << "/HO_Tmean.html\">HO</a></td>" << std::endl;
8061  htmlFile << " <td><a "
8062  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8063  "HcalRemoteMonitoring/CMT/GLOBAL_"
8064  << runnumber << "/HF_Tmean.html\">HF</a></td>" << std::endl;
8065  }
8066  if (test == 5) {
8067  htmlFile << " <td><a "
8068  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8069  "HcalRemoteMonitoring/CMT/GLOBAL_"
8070  << runnumber << "/HB_Tmax.html\">HB</a></td>" << std::endl;
8071  htmlFile << " <td><a "
8072  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8073  "HcalRemoteMonitoring/CMT/GLOBAL_"
8074  << runnumber << "/HE_Tmax.html\">HE</a></td>" << std::endl;
8075  htmlFile << " <td><a "
8076  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8077  "HcalRemoteMonitoring/CMT/GLOBAL_"
8078  << runnumber << "/HO_Tmax.html\">HO</a></td>" << std::endl;
8079  htmlFile << " <td><a "
8080  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8081  "HcalRemoteMonitoring/CMT/GLOBAL_"
8082  << runnumber << "/HF_Tmax.html\">HF</a></td>" << std::endl;
8083  }
8084 
8085  htmlFile << "</tr>" << std::endl;
8086  htmlFile << "</table>" << std::endl;
8087  htmlFile << "<br>" << std::endl;
8088  // cout<<"Creating tests html pages: 111111" << endl;
8089 
8090  if (test != 0)
8091  htmlFile << "<h2> 4. Table of estimator-values in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8092  if (test == 0)
8093  htmlFile << "<h2> 4. Table of average Nbcs in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8094  htmlFile << "<table>" << std::endl;
8095  htmlFile << "<tr>";
8096  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8097  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8098  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
8100  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
8101 
8102  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
8103  int kkkkkkmax = k_max[sub];
8104  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8105  kkkkkkmax = k_maxupgrade[sub];
8106  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8107  // if (test==1 && sub==4) kkkkkkmax = k_maxupgrade[sub];
8108  if (sub == 1) {
8109  if (test == 0)
8110  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8111  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HBdep " << k << " </td>" << std::endl;
8112  if (test == 1)
8113  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8114  htmlFile << "<td class=\"s1\" align=\"center\">< A > HBdepth " << k << " </td>" << std::endl;
8115  if (test == 2)
8116  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8117  htmlFile << "<td class=\"s1\" align=\"center\">< W > HBdepth " << k << " </td>" << std::endl;
8118  if (test == 3)
8119  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8120  htmlFile << "<td class=\"s1\" align=\"center\">< R > HBdepth " << k << " </td>" << std::endl;
8121  if (test == 4)
8122  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8123  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HBdep " << k << " </td>" << std::endl;
8124  if (test == 5)
8125  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8126  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HBdep " << k << " </td>" << std::endl;
8127  } //
8128  if (sub == 2) {
8129  if (test == 0)
8130  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8131  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HEdep " << k << " </td>" << std::endl;
8132  if (test == 1)
8133  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8134  htmlFile << "<td class=\"s1\" align=\"center\">< A > HEdepth " << k << " </td>" << std::endl;
8135  if (test == 2)
8136  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8137  htmlFile << "<td class=\"s1\" align=\"center\">< W > HEdepth " << k << " </td>" << std::endl;
8138  if (test == 3)
8139  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8140  htmlFile << "<td class=\"s1\" align=\"center\">< R > HEdepth " << k << " </td>" << std::endl;
8141  if (test == 4)
8142  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8143  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HEdep " << k << " </td>" << std::endl;
8144  if (test == 5)
8145  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8146  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HEdep " << k << " </td>" << std::endl;
8147  } //
8148  if (sub == 3) {
8149  if (test == 0)
8150  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8151  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HOdep " << k << " </td>" << std::endl;
8152  if (test == 1)
8153  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8154  htmlFile << "<td class=\"s1\" align=\"center\">< A > HOdepth " << k << " </td>" << std::endl;
8155  if (test == 2)
8156  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8157  htmlFile << "<td class=\"s1\" align=\"center\">< W > HOdepth " << k << " </td>" << std::endl;
8158  if (test == 3)
8159  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8160  htmlFile << "<td class=\"s1\" align=\"center\">< R > HOdepth " << k << " </td>" << std::endl;
8161  if (test == 4)
8162  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8163  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HOdep " << k << " </td>" << std::endl;
8164  if (test == 5)
8165  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8166  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HOdep " << k << " </td>" << std::endl;
8167  } //
8168  if (sub == 4) {
8169  if (test == 0)
8170  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8171  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HFdep " << k << " </td>" << std::endl;
8172  if (test == 1)
8173  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8174  htmlFile << "<td class=\"s1\" align=\"center\">< A > HFdepth " << k << " </td>" << std::endl;
8175  if (test == 2)
8176  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8177  htmlFile << "<td class=\"s1\" align=\"center\">< W > HFdepth " << k << " </td>" << std::endl;
8178  if (test == 3)
8179  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8180  htmlFile << "<td class=\"s1\" align=\"center\">< R > HFdepth " << k << " </td>" << std::endl;
8181  if (test == 4)
8182  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8183  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HFdep " << k << " </td>" << std::endl;
8184  if (test == 5)
8185  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8186  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HFdep " << k << " </td>" << std::endl;
8187  } //
8188  } // sub
8189  htmlFile << "</tr>" << std::endl;
8190 
8191  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 1</td>"<< std::endl;
8192  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 2</td>" << std::endl;
8193  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 1</td>" << std::endl;
8194  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 2</td>" << std::endl;
8195  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 3</td>" << std::endl;
8196  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 4</td>" << std::endl;
8197  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 5</td>" << std::endl;
8198  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 6</td>" << std::endl;
8199  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 7</td>" << std::endl;
8200  // htmlFile << "<td class=\"s1\" align=\"center\">HO Depth 4</td>" << std::endl;
8201  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 1</td>" << std::endl;
8202  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 2</td>" << std::endl;
8203  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 3</td>" << std::endl;
8204  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 4</td>" << std::endl;
8205  // htmlFile << "</tr>" << std::endl;
8206 
8207  ind = 0;
8208  // cout<<"Creating tests html pages: 222222" << endl;
8209  for (int i = 1; i <= MaxLum; i++) {
8210  // define al least one exceed in any sub-detector
8211  int met = 0;
8212  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8213  int kkkkkkmax = k_max[sub];
8214  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8215  kkkkkkmax = k_maxupgrade[sub];
8216  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8217  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8218  // 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
8219  if (sub == 2 && k > 3) {
8220  } else {
8221  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8222  met = 1;
8223  }
8224  } //depth
8225  } //sub
8226  // if exceed then plot the line for all sub-detectors
8227  if (met == 1) {
8228  if ((ind % 2) == 1)
8229  raw_class = "<td class=\"s2\" align=\"center\">";
8230  else
8231  raw_class = "<td class=\"s3\" align=\"center\">";
8232  htmlFile << "<tr>" << std::endl;
8233  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8234  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8235  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8236  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8237  int kkkkkkmax = k_max[sub];
8238  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8239  kkkkkkmax = k_maxupgrade[sub];
8240  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8241  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8242  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8243  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8244  << "</td>" << std::endl;
8245  else
8246  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8247  // htmlFile << "</tr>" << std::endl;
8248  /*
8249  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;
8250  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][1]->GetBinContent(i)<<"</td>"<< std::endl;
8251  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;
8252  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][2]->GetBinContent(i)<<"</td>"<< std::endl;
8253  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;
8254  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][1]->GetBinContent(i)<<"</td>"<< std::endl;
8255  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;
8256  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][2]->GetBinContent(i)<<"</td>"<< std::endl;
8257  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;
8258  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][3]->GetBinContent(i)<<"</td>"<< std::endl;
8259  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;
8260  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][4]->GetBinContent(i)<<"</td>"<< std::endl;
8261  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;
8262  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][5]->GetBinContent(i)<<"</td>"<< std::endl;
8263  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;
8264  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][6]->GetBinContent(i)<<"</td>"<< std::endl;
8265  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;
8266  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][7]->GetBinContent(i)<<"</td>"<< std::endl;
8267  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;
8268  else htmlFile <<raw_class<<HistNumBadChanDepth[test][3][4]->GetBinContent(i)<<"</td>"<< std::endl;
8269  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;
8270  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][1]->GetBinContent(i)<<"</td>"<< std::endl;
8271  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;
8272  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][2]->GetBinContent(i)<<"</td>"<< std::endl;
8273  */
8274  } //k depthes
8275  } //sub
8276  htmlFile << "</tr>" << std::endl;
8277  ind += 1;
8278  } // met=1
8279  } //i bin lines
8280  // cout<<"Creating tests html pages: 333333" << endl;
8281  htmlFile << "</table>" << std::endl;
8282  htmlFile << "<br>" << std::endl;
8283  htmlFile << "</body> " << std::endl;
8284  htmlFile << "</html> " << std::endl;
8285  htmlFile.close();
8286  } //test
8287  //======================================================================
8288  // cout<<"for summed Amplitudes of each sub-detector" << endl;
8289 
8290  // for summed Amplitudes of each sub-detector
8291  htmlFile.open("SummedAmplitudes_GL.html");
8292  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8293  htmlFile << "<head>" << std::endl;
8294  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8295  htmlFile << "<title> for summed Amplitudes of each sub-detector </title>" << std::endl;
8296  htmlFile << "<style type=\"text/css\">" << std::endl;
8297  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8298  << std::endl;
8299  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8300  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8301  "text-align: center;}"
8302  << std::endl;
8303  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8304  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8305  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8306  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8307  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8308 
8309  htmlFile << "</style>" << std::endl;
8310  htmlFile << "<body>" << std::endl;
8311  htmlFile << "<h1> Averaged Summed Amplitudes & corresponding occupancy of each sub-detector in Global Run = "
8312  << runnumber << " </h1>" << std::endl;
8313  htmlFile << "<a name=\"Top\"></a>\n";
8314  htmlFile << "<b>Contents:<br>\n";
8315  htmlFile << "1. <a href=\"#SAhigh\">average SA&Occupancy for Signal </a><br>\n";
8316  htmlFile << "2. <a href=\"#SAlow\">average SA&Occupancy for NoSignal </a><br>\n";
8317  htmlFile << "3. <a href=\"#SAmax\"> maxSA & maxOccupancy; SA & Occupancy; </a><br>\n";
8318  htmlFile << "4. <a href=\"#FullTable\">Table(avA; avSA; avOccupancy; maxSA; maxOccupancy;) </a><br>\n";
8319 
8320  htmlFile << "<h2> Clarifying on averaged Summed Amplitude (avSA) : </h2>" << std::endl;
8321  htmlFile << "<h3> Summed Amplitudes (SA) are averaged over all events of each LS: avSA_LS = SUM (SA_eventsInLS) / "
8322  "N_eventsInLS ,</h3>"
8323  << std::endl;
8324  htmlFile << "<h3> where SA = SUM(A_i) ,and means that Amplitude is summed over all sub-detector channels, </h3>"
8325  << std::endl;
8326  htmlFile << "<h3> where A_i = SUM(A_depth) denotes channel amplitude summed over depths; </h3>" << std::endl;
8327  // 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;
8328  htmlFile << " <td><a "
8329  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8330  "HcalRemoteMonitoring/CMT/SAwriteup.html\"> see more details for SummedAmplitudes</a></td>"
8331  << std::endl;
8332  htmlFile << "<h2> Apply cuts on A_i to take into account channels with or/and without a'la Signal: </h2>"
8333  << std::endl;
8334  htmlFile << " <img src=\"ChannelDepthsummedAmplitudes.png\" />" << std::endl;
8335  htmlFile << "<br>" << std::endl;
8336  htmlFile << "<br>" << std::endl;
8337  htmlFile << "<a name=\"SAhigh\"></a>\n";
8338  htmlFile << "<h1> 1. for channels with signal </h1>" << std::endl;
8339  htmlFile << "<br>" << std::endl;
8340  htmlFile << "<h2> for HB: A_i> 80; </h2>" << std::endl;
8341  htmlFile << " <img src=\"SummedAmplitudesSignal_HB.png\" />" << std::endl;
8342  htmlFile << "<br>" << std::endl;
8343  htmlFile << "<h2> for HE: A_i> 200;</h2>" << std::endl;
8344  htmlFile << " <img src=\"SummedAmplitudesSignal_HE.png\" />" << std::endl;
8345  htmlFile << "<br>" << std::endl;
8346  htmlFile << "<h2> for HO: A_i> 1200;</h2>" << std::endl;
8347  htmlFile << " <img src=\"SummedAmplitudesSignal_HO.png\" />" << std::endl;
8348  htmlFile << "<br>" << std::endl;
8349  htmlFile << "<h2> for HF: A_i> 600;</h2>" << std::endl;
8350  htmlFile << " <img src=\"SummedAmplitudesSignal_HF.png\" />" << std::endl;
8351  htmlFile << "<br>" << std::endl;
8352  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8353 
8354  htmlFile << "<a name=\"SAlow\"></a>\n";
8355  htmlFile << "<h1> 2. for channels w/o signal </h1>" << std::endl;
8356  htmlFile << "<br>" << std::endl;
8357  htmlFile << "<h2> for HB: A_i< 80;</h2>" << std::endl;
8358  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HB.png\" />" << std::endl;
8359  htmlFile << "<br>" << std::endl;
8360  htmlFile << "<h2> for HE: A_i< 200;</h2>" << std::endl;
8361  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HE.png\" />" << std::endl;
8362  htmlFile << "<br>" << std::endl;
8363  htmlFile << "<h2> for HO: A_i< 1200;</h2>" << std::endl;
8364  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HO.png\" />" << std::endl;
8365  htmlFile << "<br>" << std::endl;
8366  htmlFile << "<h2> for HF: A_i< 600;</h2>" << std::endl;
8367  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HF.png\" />" << std::endl;
8368  htmlFile << "<br>" << std::endl;
8369  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8370 
8371  htmlFile << "<br>" << std::endl;
8372  htmlFile << "<br>" << std::endl;
8373  htmlFile << "<a name=\"SAmax\"></a>\n";
8374  htmlFile << "<h1> 3. four plots: ---1---> max SA ---2---> max Occupancy ---3---> SA ---4---> Occupancy over all "
8375  "events of LS </h1>"
8376  << std::endl;
8377  htmlFile << "<br>" << std::endl;
8378 
8379  htmlFile << "<h2> for HB: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8380  htmlFile << " <img src=\"MaxxSummedAmplitudes_HB.png\" />" << std::endl;
8381  htmlFile << "<h2>"
8382  " ......(forCut:SAmax>60000) N= "
8383  << countamplmaxHB << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHB << " </h2>" << std::endl;
8384  htmlFile << "<h2>"
8385  " ......(forCut:SA>60000) N= "
8386  << countamplHB << " ...... (forCut:OCCUP>2000) N= " << countoccuHB << " </h2>" << std::endl;
8387  htmlFile << "<br>" << std::endl;
8388  htmlFile << "<h3> ONLY for HB (cross-check): channel Amplitudes for events in the Tail (averaged): </h3>"
8389  << std::endl;
8390  htmlFile << " <img src=\"AtaildepthHB.png\" />" << std::endl;
8391  htmlFile << "<br>" << std::endl;
8392 
8393  htmlFile << "<h2> for HE: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8394  htmlFile << " <img src=\"MaxxSummedAmplitudes_HE.png\" />" << std::endl;
8395  htmlFile << "<h2>"
8396  " ......(forCut:SAmax>60000) N= "
8397  << countamplmaxHE << " ...... (forCut:OCCUPmax>1200) N= " << countoccumaxHE << " </h2>" << std::endl;
8398  htmlFile << "<h2>"
8399  " ......(forCut:SA>60000) N= "
8400  << countamplHE << " ...... (forCut:OCCUP>1200) N= " << countoccuHE << " </h2>" << std::endl;
8401  htmlFile << "<br>" << std::endl;
8402 
8403  htmlFile << "<h2> for HO: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8404  htmlFile << " <img src=\"MaxxSummedAmplitudes_HO.png\" />" << std::endl;
8405  htmlFile << "<h2>"
8406  " ......(forCut:SAmax>150000) N= "
8407  << countamplmaxHO << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHO << " </h2>" << std::endl;
8408  htmlFile << "<h2>"
8409  " ......(forCut:SA>150000) N= "
8410  << countamplHO << " ...... (forCut:OCCUP>2000) N= " << countoccuHO << " </h2>" << std::endl;
8411  htmlFile << "<br>" << std::endl;
8412 
8413  htmlFile << "<h2> for HF: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8414  htmlFile << " <img src=\"MaxxSummedAmplitudes_HF.png\" />" << std::endl;
8415  htmlFile << "<h2>"
8416  " ......(forCut:SAmax>22000) N= "
8417  << countamplmaxHF << " ...... (forCut:OCCUPmax>860) N= " << countoccumaxHF << " </h2>" << std::endl;
8418  htmlFile << "<h2>"
8419  " ......(forCut:SA>22000) N= "
8420  << countamplHF << " ...... (forCut:OCCUP>860) N= " << countoccuHF << " </h2>" << std::endl;
8421  htmlFile << "<br>" << std::endl;
8422  htmlFile << "<h2> Occupancy HF (ONLY) vs LS </h2>" << std::endl;
8423  htmlFile << " <img src=\"sumOccupancyHF.png\" />" << std::endl;
8424  htmlFile << "<br>" << std::endl;
8425  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8426 
8427  htmlFile << "<a name=\"FullTable\"></a>\n";
8428  htmlFile << "<h2> 4.Lumisection Status: </h2>" << std::endl;
8429  htmlFile << "<h3> Legends: HBdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8430  << Cut0[1][1][1] << std::endl;
8431  htmlFile << "<h3> Legends: HEdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8432  << Cut0[1][2][1] << std::endl;
8433  htmlFile << "<h3> Legends: HOdepth4 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8434  << Cut0[1][3][4] << std::endl;
8435  htmlFile << "<h3> Legends: HFdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8436  << Cut0[1][4][1] << std::endl;
8437  htmlFile << "<br>" << std::endl;
8438  // SummedAmplitudeHisto[i] SummedAmplitudeOccupancyHisto[i] NoSignalSummedAmplitudeHisto[i] NoSignalSummedAmplitudeOccupancyHisto[i]; i=0-3;(HF:i=3)
8439  htmlFile << "<br>" << std::endl;
8440  htmlFile << "<table>" << std::endl;
8441  htmlFile << "<tr>";
8442  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8443  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8444  htmlFile << "<td class=\"s1\" align=\"center\"> Num.of ev.</td>" << std::endl;
8445 
8446  // for (int k=k_min[sub];k<=k_max[sub]; k++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth "<< k <<" </td>" << std::endl;
8447  // for (int sub=1;sub<=4;sub++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth1, sub "<< sub <<" </td>" << std::endl;
8448 
8449  htmlFile << "<td class=\"s1\" align=\"center\">< A >HB Depth1</td>" << std::endl;
8450  htmlFile << "<td class=\"s1\" align=\"center\">< A >HE Depth1</td>" << std::endl;
8451  htmlFile << "<td class=\"s1\" align=\"center\">< A >HO Depth4</td>" << std::endl;
8452  htmlFile << "<td class=\"s1\" align=\"center\">< A >HF Depth1</td>" << std::endl;
8453 
8454  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (Signal) </td>" << std::endl;
8455  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (Signal) </td>" << std::endl;
8456  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (Signal) </td>" << std::endl;
8457  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (Signal) </td>" << std::endl;
8458 
8459  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (NoSignal) </td>" << std::endl;
8460  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (NoSignal) </td>" << std::endl;
8461  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (NoSignal) </td>" << std::endl;
8462  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (NoSignal) </td>" << std::endl;
8463 
8464  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HB </td>" << std::endl;
8465  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HB </td>" << std::endl;
8466  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HF </td>" << std::endl;
8467  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HF </td>" << std::endl;
8468 
8469  htmlFile << "</tr>" << std::endl;
8470 
8471  ind = 0;
8472  for (int i = 1; i <= MaxLum; i++) {
8473  if ((ind % 2) == 1)
8474  raw_class = "<td class=\"s2\" align=\"center\">";
8475  else
8476  raw_class = "<td class=\"s3\" align=\"center\">";
8477  htmlFile << "<tr>" << std::endl;
8478 
8479  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8480 
8481  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8482  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8483 
8484  // (test==1) <Amplitude>
8485  int test = 1;
8486  // for (int k=k_min[sub];k<=k_max[sub]; k++) {
8487  for (int sub = 1; sub <= 4; sub++) {
8488  for (int k = k_min[sub]; k <= k_min[sub]; k++) {
8489  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8490  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8491  << "</td>" << std::endl;
8492 
8493  else
8494  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8495  }
8496  }
8497  if (SummedAmplitudeHisto[0]) {
8498  htmlFile << raw_class << SummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8499  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8500  htmlFile << raw_class << SummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8501  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8502 
8503  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8504  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8505  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8506  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8507 
8508  htmlFile << raw_class << MaxxSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8509  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8510  htmlFile << raw_class << MaxxSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8511  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8512  }
8513  htmlFile << "</tr>" << std::endl;
8514  ind += 1;
8515  }
8516  htmlFile << "</table>" << std::endl;
8517  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8518 
8519  htmlFile << "<br>" << std::endl;
8520  htmlFile << "</body> " << std::endl;
8521  htmlFile << "</html> " << std::endl;
8522  htmlFile.close();
8523 
8524  //====================================================================== // Creating description of html-files
8525 
8526  /*
8527  //======================================================================
8528  // Creating description HELP.html file:
8529  htmlFile.open("HELP.html");
8530  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">"<< std::endl;
8531  htmlFile << "<head>"<< std::endl;
8532  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>"<< std::endl;
8533  htmlFile << "<title> Certification Monitoring Tool </title>"<< std::endl;
8534  htmlFile << "<style type=\"text/css\">"<< std::endl;
8535  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"<< std::endl;
8536  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }"<< std::endl;
8537  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; text-align: center;}"<< std::endl;
8538  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }"<< std::endl;
8539  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }"<< std::endl;
8540  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }"<< std::endl;
8541  htmlFile << "</style>"<< std::endl;
8542  htmlFile << "<body>"<< std::endl;
8543  htmlFile << "<h1> Description of Remote Monitoring Tool criteria for bad channel selection</h1>"<< std::endl;
8544  htmlFile << "<br>"<< std::endl;
8545  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;
8546  htmlFile << "<br>"<< std::endl;
8547  htmlFile << "<h3> - Amplitude is full amplitude collected over all time slices </h3> "<< std::endl;
8548  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;
8549  htmlFile << "<br>"<< std::endl;
8550  htmlFile << "<h3> - Width of shape distribution. Width is defined as square root from dispersion. </h3> "<< std::endl;
8551  htmlFile << "<br>"<< std::endl;
8552  htmlFile << "<h3> - Mean TS time slice position of adc signal. </h3> "<< std::endl;
8553  htmlFile << "<br>"<< std::endl;
8554  htmlFile << "<h3> - TS number of maximum signal </h3> "<< std::endl;
8555  htmlFile << "<br>"<< std::endl;
8556  htmlFile << "<h3> For more details see https://twiki.cern.ch/twiki/bin/viewauth/CMS/HcalRemoteCertificationMonitoring </h3> "<< std::endl;
8557  htmlFile << "</body> " << std::endl;
8558  htmlFile << "</html> " << std::endl;
8559  htmlFile.close();
8560 */
8561  //======================================================================
8562  // Creating description CMTresults.html file:
8563  htmlFile.open("CMTresults.html");
8564  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8565  htmlFile << "<head>" << std::endl;
8566  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8567  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8568  htmlFile << "<style type=\"text/css\">" << std::endl;
8569  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8570  << std::endl;
8571  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8572  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8573  "text-align: center;}"
8574  << std::endl;
8575  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8576  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8577  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8578  htmlFile << "</style>" << std::endl;
8579  htmlFile << "<body>" << std::endl;
8580  htmlFile << "<h1> LS-certification (recommendation) from analysis of CMT-dependencies of THIS run </h1>"
8581  << std::endl;
8582  htmlFile << "<br>" << std::endl;
8583  htmlFile << "<br>" << std::endl;
8584  htmlFile << "<h2> - List of suspicious LSs: </h2> " << std::endl;
8585  htmlFile << "<br>" << std::endl;
8586  htmlFile << "<h3> to be added </h3> " << std::endl;
8587  htmlFile << "<br>" << std::endl;
8588  htmlFile << "<br>" << std::endl;
8589  htmlFile << "<br>" << std::endl;
8590  htmlFile << "<h2> - Comments: </h2> " << std::endl;
8591  htmlFile << "<br>" << std::endl;
8592  htmlFile << "<h3> to be added </h3> " << std::endl;
8593  htmlFile << "<br>" << std::endl;
8594  htmlFile << "<br>" << std::endl;
8595  htmlFile << "<br>" << std::endl;
8596  htmlFile << "</body> " << std::endl;
8597  htmlFile << "</html> " << std::endl;
8598  htmlFile.close();
8599 
8600  //======================================================================
8601  // Creating main html file:
8602 
8603  htmlFile.open("LumiList.html");
8604  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8605  htmlFile << "<head>" << std::endl;
8606  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8607  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8608  htmlFile << "<style type=\"text/css\">" << std::endl;
8609  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8610  << std::endl;
8611  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8612  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8613  "text-align: center;}"
8614  << std::endl;
8615  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8616  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8617  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8618  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8619  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8620 
8621  htmlFile << "</style>" << std::endl;
8622  htmlFile << "<body>" << std::endl;
8623 
8624  htmlFile << "<h1> Certification Monitoring Tool, GLOBAL RUN = " << runnumber << ". </h1>" << std::endl;
8625  htmlFile << "<br>" << std::endl;
8626  htmlFile << " <td><a "
8627  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8628  "HcalRemoteMonitoring/CMT/GLOBAL_"
8629  << runnumber << "/CMTresults.html\"> CMT-analysis RESULTS (for this run) </a></td>" << std::endl;
8630  htmlFile << "<br>" << std::endl;
8631  htmlFile << "<br>" << std::endl;
8632 
8633  // htmlFile << "<h2> 1. General information </h2>"<< std::endl;
8634  htmlFile << "<h2> 1. General information (Full number of LS = " << MaxLum << " ). </h2>" << std::endl;
8635  htmlFile << " <img src=\"LumiEvent.png\" />" << std::endl;
8636  htmlFile << "<br>" << std::endl;
8637 
8638  htmlFile << "<h2> 2. HCAL status for different criteria </h2>" << std::endl;
8639  // 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;
8640  htmlFile << " <td><a "
8641  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8642  "HcalRemoteMonitoring/CMT/HELP.html\"> Description of criteria for bad channel selection</a></td>"
8643  << std::endl;
8644  htmlFile << "<br>" << std::endl;
8645  htmlFile << "<table width=\"600\">" << std::endl;
8646  htmlFile << "<tr>" << std::endl;
8647  htmlFile << " <td><a "
8648  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8649  "HcalRemoteMonitoring/CMT/GLOBAL_"
8650  << runnumber << "/CapID_GL.html\">Cap ID errors</a></td>" << std::endl;
8651  // AZ 18.03.2018
8652  // htmlFile << " <td><a href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/ADCampl_GL.html\">Amplitude</a></td>"<< std::endl;
8653  htmlFile << " <td><a href=\"ADCampl_GL.html\">Amplitude</a></td>" << std::endl;
8654  htmlFile << " <td><a "
8655  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8656  "HcalRemoteMonitoring/CMT/GLOBAL_"
8657  << runnumber << "/Width_GL.html\">Width</a></td>" << std::endl;
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 << "/Ratio_GL.html\">Ratio</a></td>" << std::endl;
8662  htmlFile << " <td><a "
8663  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8664  "HcalRemoteMonitoring/CMT/GLOBAL_"
8665  << runnumber << "/Tmean_GL.html\">TS mean</a></td>" << std::endl;
8666  htmlFile << " <td><a "
8667  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8668  "HcalRemoteMonitoring/CMT/GLOBAL_"
8669  << runnumber << "/Tmax_GL.html\">TS max</a></td>" << std::endl;
8670 
8671  htmlFile << " <td><a "
8672  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
8673  "HcalRemoteMonitoring/CMT/GLOBAL_"
8674  << runnumber << "/SummedAmplitudes_GL.html\">SummedAmplitudes</a></td>" << std::endl;
8675 
8676  htmlFile << "</tr>" << std::endl;
8677  htmlFile << "</table>" << std::endl;
8678  htmlFile << "<br>" << std::endl;
8679  htmlFile << "</body> " << std::endl;
8680  htmlFile << "</html> " << std::endl;
8681  htmlFile.close();
8682  //======================================================================
8683 
8684  //======================================================================
8685  // Close and delete all possible things:
8686  hfile->Close();
8687  // hfile->Delete();
8688  // Exit Root
8689  gSystem->Exit(0);
8690  //======================================================================
8691 }
8692 
8693 // ------------------------------------------------------------
8694 
8695 int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin) {
8696  if (lastBin > hSrc->GetNbinsX()) {
8697  std::cout << "copyContents from " << hSrc->GetName() << ": histo has " << hSrc->GetNbinsX()
8698  << " bins, when lastBin=" << lastBin << " was requested\n";
8699  return 0;
8700  }
8701 
8702  (*hDest) = new TH1F(hname, htitle, lastBin, 0, lastBin);
8703  (*hDest)->SetDirectory(0);
8704  (*hDest)->SetStats(0);
8705 
8706  for (int ibin = 1; ibin <= lastBin; ibin++) {
8707  (*hDest)->SetBinContent(ibin, hSrc->GetBinContent(ibin));
8708  (*hDest)->SetBinError(ibin, hSrc->GetBinError(ibin));
8709  }
8710  return 1;
8711 }
8712 
8713 // ------------------------------------------------------------
mps_fire.i
i
Definition: mps_fire.py:428
remoteMonitoring_LASER_era2018_cfg.lsmax
lsmax
Definition: remoteMonitoring_LASER_era2018_cfg.py:278
NULL
#define NULL
Definition: scimark2.h:8
copyContents
int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin)
Definition: RemoteMonitoringGLOBALTest.cc:8695
isum
double isum
Definition: MuScleFitUtils.cc:77
METSignificanceParams_cfi.jeta
jeta
Definition: METSignificanceParams_cfi.py:12
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
DeadROC_duringRun.dir
dir
Definition: DeadROC_duringRun.py:23
dumpMFGeometry_cfg.delta
delta
Definition: dumpMFGeometry_cfg.py:25
hi
Definition: EPCuts.h:4
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
main
int main(int argc, char *argv[])
Definition: RemoteMonitoringGLOBALTest.cc:32
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
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