CMS 3D CMS Logo
RemoteMonitoringGLOBAL.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 //
6 //
7 #include "LogEleMapdb.h"
8 
9 #include <iostream>
10 #include <fstream>
11 
12 #include "TH1.h"
13 #include "TH2.h"
14 #include "TCanvas.h"
15 #include "TROOT.h"
16 #include <TMath.h>
17 #include "TStyle.h"
18 #include "TSystem.h"
19 #include "TLegend.h"
20 #include "TText.h"
21 #include "TAxis.h"
22 #include "TFile.h"
23 #include "TLine.h"
24 #include "TGraph.h"
25 #include <THStack.h>
26 #include <TPaveText.h>
27 
28 // https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT
29 // https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/HcalRemoteMonitoring/CMT
30 
31 using namespace std;
32 //inline void HERE(const char *msg) { std::cout << msg << std::endl; } kfitq
33 int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin);
34 
35 // -----------------------------------------------------
36 
37 int main(int argc, char *argv[]) {
38  std::string dirnm = "Analyzer";
39  gROOT->Reset();
40  gROOT->SetStyle("Plain");
41  gStyle->SetOptStat(0);
42  gStyle->SetOptTitle(1);
43 
44  if (argc < 1)
45  return 1;
46  char fname[300];
47  sprintf(fname, "%s", argv[1]);
48  std::cout << fname << std::endl;
49 
50  //======================================================================
51  // Connect the input files, parameters and get the 2-d histogram in memory
52  // TFile *hfile= new TFile("GlobalHist.root", "READ");
53  string promt = (string)fname;
54  string runnumber = "";
55  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
56  runnumber += fname[i];
57 
58  TFile *hfile = new TFile(fname, "READ");
59  hfile->ls();
60  TDirectory *dir = (TDirectory *)hfile->FindObjectAny(dirnm.c_str());
61  // Cut [test][sub][depth]
62  // Empty HB HE HO HF
63  double Cut0[7][5][8] = {
64  {{0., 0., 0., 0., 0., 0., 0., 0.},
65  {0., 1.0, 1.0, 0., 0., 0., 0., 0.},
66  {0., 1., 1., 1., 0., 0., 0., 0.},
67  {0., 0., 0., 0., 1., 0., 0., 0.},
68  {0., 1., 1., 0., 0., 0., 0., 0.}}, //CapID 0,HB,HE,HO,HF
69  // {{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
70  //
71  // {{0., 0., 0., 0., 0., 0., 0., 0.},
72  // {0., 10., 10., 10., 10., 0., 0., 0.},
73  // {0., 10., 10., 10., 10., 10., 10., 10.},
74  // {0., 0., 0., 0., 10., 0., 0., 0.},
75  // {0., 10., 10., 10., 10., 0., 0., 0.}}, //Amplitude 0,HB,HE,HO,HF
76  {{0., 0., 0., 0., 0., 0., 0., 0.},
77  {0., 3500., 3500., 3500., 3500., 0., 0., 0.},
78  {0., 12000., 4500., 3500., 3500., 4000., 4500., 5500.},
79  {0., 0., 0., 0., 200., 0., 0., 0.},
80  {0., 4500., 4500., 4500., 4500., 0., 0., 0.}}, //Amplitude 0,HB,HE,HO,HF
81  {{0., 0., 0., 0., 0., 0., 0., 0.},
82  {0., 3., 3., 0., 0., 0., 0., 0.},
83  {0., 3., 3., 3., 0., 0., 0., 0.},
84  {0., 0., 0., 0., 3., 0., 0., 0.},
85  {0., 2., 2., 0., 0., 0., 0., 0.}}, //Width 0,HB,HE,HO,HF
86  {{0., 0., 0., 0., 0., 0., 0., 0.},
87  {0., 0.4, 0.4, 0., 0., 0., 0., 0.},
88  {0., 0.4, 0.4, 0.4, 0., 0., 0., 0.},
89  {0., 0., 0., 0., 0.4, 0., 0., 0.},
90  {0., 0.8, 0.8, 0., 0., 0., 0., 0.}}, //Ratio 0,HB,HE,HO,HF
91  {{0., 0., 0., 0., 0., 0., 0., 0.},
92  {0., 4.7, 4.7, 0., 0., 0., 0., 0.},
93  {0., 4.8, 4.8, 5.0, 0., 0., 0., 0.},
94  {0., 0., 0., 0., 4.8, 0., 0., 0.},
95  {0., 4.0, 4.0, 0., 0., 0., 0., 0.}}, //TSn 0,HB,HE,HO,HF
96  {{0., 0., 0., 0., 0., 0., 0., 0.},
97  {0., 3.5, 3.5, 0., 0., 0., 0., 0.},
98  {0., 4.0, 4.0, 4.0, 0., 0., 0., 0.},
99  {0., 0., 0., 0., 3., 0., 0., 0.},
100  {0., 3.5, 3.5, 0., 0., 0., 0., 0.}}, //TSx 0,HB,HE,HO,HF
101  {{0., 0., 0., 0., 0., 0., 0., 0.},
102  {0., 0., 0., 0., 0., 0., 0., 0.},
103  {0., 0., 0., 0., 0., 0., 0., 0.},
104  {0., 0., 0., 0., 0., 0., 0., 0.},
105  {0., 0., 0., 0., 0., 0., 0., 0.}}}; //Empty
106 
107  double CutAb[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
108  {0., 20., 7., 0., 0., 0., 0., 0.},
109  {0., 16., 13., 4., 0., 0., 0., 0.},
110  {0., 0., 0., 0., 45., 0., 0., 0.},
111  {0., 10., 5., 0., 0., 0., 0., 0.}}; // cut 1 for CapIdErrors 0,HB,HE,HO,HF
112 
113  double CutPo[5][8] = {{0., 0., 0., 0., 0., 0., 0., 0.},
114  {0., 9., 3., 0., 0., 0., 0., 0.},
115  {0., 8., 6., 2., 0., 0., 0., 0.},
116  {0., 0., 0., 0., 20., 0., 0., 0.},
117  {0., 5., 3., 0., 0., 0., 0., 0.}}; //cut 3 for CapIdErrors (portions) 0,HB,HE,HO,HF
118 
119  //======================================================================
120 
121  // CUTs FOR IPHI RBX:
122  int cutA_HB = 100;
123  int cutA_HE = 6000;
124  int cutA_HO = 150;
125  int cutA_HF = 500;
126  // CUTs FOR IETA RBX:
127  int cutB_HB = 100;
128  int cutB_HE = 10000;
129  int cutB_HO = 150;
130  int cutB_HF = 500;
131 
132  //======================================================================
133  // Prepare histograms and plot them to .png files
134  // TCanvas *cHB = new TCanvas("cHB", "cHB", 200, 10, 700, 900);
135  TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 500);
136  TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 500);
137  TCanvas *cONE = new TCanvas("cONE", "cONE", 500, 500);
138  TCanvas *cFour = new TCanvas("cFour", "cFour", 1500, 1000);
139  TCanvas *cFour1 = new TCanvas("cFour1", "cFour1", 1200, 800);
140  TCanvas *cNine = new TCanvas("cNine", "cNine", 1500, 1500);
141 
142  // RBX:
143  // TCanvas *c4x6 = new TCanvas("c4x6","c4x6",1500,3000);
144  TCanvas *c4x6 = new TCanvas("c4x6", "c4x6", 1200, 2400);
145  //TCanvas *c5x6 = new TCanvas("c5x6","c5x6",2000,3000);
146  TCanvas *c5x6 = new TCanvas("c5x6", "c5x6", 1500, 2400);
147  // TCanvas *cRBX1 = new TCanvas("cRBX1","cRBX1",200,10,1300,1110);
148  TCanvas *cRBX1 = new TCanvas("cRBX1", "cRBX1", 1200, 1000);
149  //
150  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",1800,600);
151  TCanvas *cRBX31 = new TCanvas("cRBX31", "cRBX31", 1860, 600);
152  // TCanvas *cRBX31 = new TCanvas("cRBX31","cRBX31",200,10,,1800,600);
153 
154  // char *str = (char*)alloca(10000);
155 
156  int k_min[5] = {0, 1, 1, 4, 1}; // minimum depth for each subdet HB HE HO HF
157 
158  int k_max[5] = {0, 2, 3, 4, 2}; // maximum depth for each subdet HB HE HO HF
159  // int k_maxupgrade[5]={0,2,3,4,4}; // maximum depth for each subdet HB HE HO HF
160  int k_maxupgrade[5] = {0, 4, 7, 4, 4}; // maximum depth for each subdet HB HE HO HF
161 
162  //+++++++++++++++++++++++++++++
163  // Lumi iLumi and number of events
164  //+++++++++++++++++++++++++++++
165  // with TfileService implementation, change everywhere below: hfile->Get to dir->FindObjectAny
166  cHB->Divide(2, 1);
167  cHB->cd(1);
168  TH1F *LumLum = (TH1F *)dir->FindObjectAny("h_lsnumber_per_eachLS");
169  int MaxLumDanila = LumLum->GetBinContent(LumLum->GetMaximumBin()); // old variant of Danila
170  cout << " MaxLumDanila= " << MaxLumDanila << endl;
171  gStyle->SetOptStat(110000);
172  gPad->SetGridy();
173  gPad->SetGridx();
174  LumLum->SetMarkerStyle(21);
175  LumLum->SetMarkerSize(0.8);
176  LumLum->GetYaxis()->SetLabelSize(0.04);
177  LumLum->SetTitle("Cont. number per LS \b");
178  LumLum->SetXTitle("Cont.number \b");
179  LumLum->SetYTitle("Ls \b");
180  LumLum->SetMarkerColor(4);
181  LumLum->SetLineColor(0);
182  LumLum->SetMinimum(0.8);
183  LumLum->GetXaxis()->SetRangeUser(0, MaxLumDanila + 5.);
184  LumLum->Draw("Error");
185 
186  cHB->cd(2);
187  TH1F *LumiEv = (TH1F *)dir->FindObjectAny("h_nevents_per_eachRealLS");
188  int MaxLum0 = LumiEv->GetBinContent(LumiEv->GetMaximumBin());
189  int MaxLum = 0;
190  for (int i = 1; i <= LumiEv->GetXaxis()->GetNbins(); i++) {
191  if (LumiEv->GetBinContent(i)) {
192  MaxLum = i;
193  }
194  }
195  cout << " Nev in bin of MaxLum = " << MaxLum0 << " MaxLum= " << MaxLum << endl;
196 
197  gStyle->SetOptStat(110000);
198  gPad->SetGridy();
199  gPad->SetGridx();
200  gPad->SetLogy();
201  // gPad->SetLogx();
202  LumiEv->GetYaxis()->SetLabelSize(0.04);
203  LumiEv->SetTitle("Number of events per LS");
204  LumiEv->SetXTitle("LS");
205  LumiEv->SetYTitle("Number of events ");
206  LumiEv->SetMarkerStyle(21);
207  LumiEv->SetMarkerSize(0.8);
208  LumiEv->SetMarkerColor(4);
209  LumiEv->SetLineColor(0);
210  // LumiEv->SetMinimum(0.8);
211  LumiEv->GetXaxis()->SetRangeUser(0, MaxLum + 5.);
212  LumiEv->Draw("Error");
213 
214  cHB->Print("LumiEvent.png");
215  cHB->Clear();
216 
217  //=======================================================================================================
218  // Shape criteria: 1d histogram first definition
219  //=======================================================================================================
220  TH1F *H_NumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
221 
222  //+++++++++++++++++++++++++++++
223  // ADC Amplitude
224  //+++++++++++++++++++++++++++++
225 
226  H_NumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS1");
227  H_NumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS2");
228 
229  H_NumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS3");
230  H_NumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS4");
231  H_NumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS5");
232 
233  H_NumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS8");
234 
235  H_NumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS6");
236  H_NumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplLS7");
237 
238  //+++++++++++++++++++++++++++++
239  // Width
240  //+++++++++++++++++++++++++++++
241 
242  H_NumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS1");
243  H_NumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS2");
244 
245  H_NumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS3");
246  H_NumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS4");
247  H_NumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS5");
248 
249  H_NumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS8");
250 
251  H_NumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS6");
252  H_NumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeLS7");
253 
254  //+++++++++++++++++++++++++++++
255  // Ratio
256  //+++++++++++++++++++++++++++++
257 
258  H_NumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS1");
259  H_NumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS2");
260 
261  H_NumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS3");
262  H_NumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS4");
263  H_NumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplLS5");
264 
265  H_NumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplLS8");
266 
267  H_NumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplLS6");
268  H_NumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplLS7");
269 
270  //+++++++++++++++++++++++++++++
271  // Tmean
272  //+++++++++++++++++++++++++++++
273 
274  H_NumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS1");
275  H_NumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS2");
276 
277  H_NumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS3");
278  H_NumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS4");
279  H_NumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS5");
280 
281  H_NumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS8");
282 
283  H_NumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS6");
284  H_NumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanALS7");
285 
286  //+++++++++++++++++++++++++++++
287  // Tmax
288  //+++++++++++++++++++++++++++++
289 
290  H_NumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS1");
291  H_NumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS2");
292 
293  H_NumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS3");
294  H_NumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS4");
295  H_NumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS5");
296 
297  H_NumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS8");
298 
299  H_NumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS6");
300  H_NumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxALS7");
301 
302  gStyle->SetOptStat(110000);
303 
304  for (int test = 1; test <= 5; test++) { //Test: 0,
305  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
306  if (sub == 1)
307  cHB->Divide(2, 1);
308  if (sub == 2)
309  cHE->Divide(3, 1);
310  if (sub == 3)
311  cONE->Divide(1, 1);
312  if (sub == 4)
313  cHB->Divide(2, 1);
314  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
315  if (sub == 1)
316  cHB->cd(k);
317  if (sub == 2)
318  cHE->cd(k);
319  if (sub == 3)
320  cONE->cd(k - 3);
321  if (sub == 4)
322  cHB->cd(k);
323  gPad->SetGridy();
324  gPad->SetGridx();
325  gPad->SetLogy();
326  H_NumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
327  H_NumBadChanDepth[test][sub][k]->SetMarkerSize(0.8);
328  if (k == 1)
329  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
330  if (k == 2)
331  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
332  if (k == 3)
333  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
334  if (k == 4)
335  H_NumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
336  if (test == 1)
337  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Amplitude> \b");
338  if (test == 2)
339  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Width> \b");
340  if (test == 3)
341  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <Ratio> \b");
342  if (test == 4)
343  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS mean> \b");
344  if (test == 5)
345  H_NumBadChanDepth[test][sub][k]->SetXTitle(" <TS max> \b");
346  H_NumBadChanDepth[test][sub][k]->SetYTitle("Number of channel-LSs\b");
347  H_NumBadChanDepth[test][sub][k]->SetMarkerColor(4);
348  H_NumBadChanDepth[test][sub][k]->SetLineColor(0);
349  // H_NumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
350  H_NumBadChanDepth[test][sub][k]->SetMinimum(0.8);
351  H_NumBadChanDepth[test][sub][k]->Draw("Error");
352  }
353  if (test == 0) {
354  if (sub == 1) {
355  cHB->Print("H_NBCMNHB.png");
356  cHB->Clear();
357  }
358  if (sub == 2) {
359  cHE->Print("H_NBCMNHE.png");
360  cHE->Clear();
361  }
362  if (sub == 3) {
363  cONE->Print("H_NBCMNHO.png");
364  cONE->Clear();
365  }
366  if (sub == 4) {
367  cHB->Print("H_NBCMNHF.png");
368  cHB->Clear();
369  }
370  }
371 
372  if (test == 1) {
373  if (sub == 1) {
374  cHB->Print("H_ADCamplHB.png");
375  cHB->Clear();
376  }
377  if (sub == 2) {
378  cHE->Print("H_ADCamplHE.png");
379  cHE->Clear();
380  }
381  if (sub == 3) {
382  cONE->Print("H_ADCamplHO.png");
383  cONE->Clear();
384  }
385  if (sub == 4) {
386  cHB->Print("H_ADCamplHF.png");
387  cHB->Clear();
388  }
389  }
390  if (test == 2) {
391  if (sub == 1) {
392  cHB->Print("H_WidthHB.png");
393  cHB->Clear();
394  }
395  if (sub == 2) {
396  cHE->Print("H_WidthHE.png");
397  cHE->Clear();
398  }
399  if (sub == 3) {
400  cONE->Print("H_WidthHO.png");
401  cONE->Clear();
402  }
403  if (sub == 4) {
404  cHB->Print("H_WidthHF.png");
405  cHB->Clear();
406  }
407  }
408  if (test == 3) {
409  if (sub == 1) {
410  cHB->Print("H_RatioHB.png");
411  cHB->Clear();
412  }
413  if (sub == 2) {
414  cHE->Print("H_RatioHE.png");
415  cHE->Clear();
416  }
417  if (sub == 3) {
418  cONE->Print("H_RatioHO.png");
419  cONE->Clear();
420  }
421  if (sub == 4) {
422  cHB->Print("H_RatioHF.png");
423  cHB->Clear();
424  }
425  }
426  if (test == 4) {
427  if (sub == 1) {
428  cHB->Print("H_TmeanHB.png");
429  cHB->Clear();
430  }
431  if (sub == 2) {
432  cHE->Print("H_TmeanHE.png");
433  cHE->Clear();
434  }
435  if (sub == 3) {
436  cONE->Print("H_TmeanHO.png");
437  cONE->Clear();
438  }
439  if (sub == 4) {
440  cHB->Print("H_TmeanHF.png");
441  cHB->Clear();
442  }
443  }
444  if (test == 5) {
445  if (sub == 1) {
446  cHB->Print("H_TmaxHB.png");
447  cHB->Clear();
448  }
449  if (sub == 2) {
450  cHE->Print("H_TmaxHE.png");
451  cHE->Clear();
452  }
453  if (sub == 3) {
454  cONE->Print("H_TmaxHO.png");
455  cONE->Clear();
456  }
457  if (sub == 4) {
458  cHB->Print("H_TmaxHF.png");
459  cHB->Clear();
460  }
461  }
462  } // end sub
463  } //end test
464 
465  gStyle->SetOptStat(0);
466  //================================================================================================================================
467 
468  //=======================================================================================================
469  // 2-d histograms second definition
470  //=========================================================
471  TH2F *MapNumBadChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
472  TH2F *MapNumChanDepth[7][5][5]; // 1d Mapogramm for test,subdet, depth
473  TH2F *MapNumBadChanFull[7]; // 1d Mapogramm for test
474  TH2F *MapNumChanFull[7]; // 1d Mapogramm for test
475 
476  //+++++++++++++++++++++++++++++
477  // CapID
478  //+++++++++++++++++++++++++++++
479 
480  MapNumBadChanDepth[0][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HB");
481  MapNumBadChanDepth[0][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HB");
482 
483  MapNumBadChanDepth[0][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HE");
484  MapNumBadChanDepth[0][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HE");
485  MapNumBadChanDepth[0][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HE");
486 
487  MapNumBadChanDepth[0][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HO");
488 
489  MapNumBadChanDepth[0][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HF");
490  MapNumBadChanDepth[0][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HF");
491 
492  MapNumBadChanFull[0] = (TH2F *)MapNumBadChanDepth[0][1][1]->Clone();
493 
494  MapNumChanDepth[0][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HB");
495  MapNumChanDepth[0][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HB");
496 
497  MapNumChanDepth[0][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HE");
498  MapNumChanDepth[0][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HE");
499  MapNumChanDepth[0][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HE");
500 
501  MapNumChanDepth[0][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HO");
502 
503  MapNumChanDepth[0][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HF");
504  MapNumChanDepth[0][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HF");
505 
506  MapNumChanFull[0] = (TH2F *)MapNumChanDepth[0][1][1]->Clone();
507 
508  //+++++++++++++++++++++++++++++
509  // ADC Amplitude
510  //+++++++++++++++++++++++++++++
511 
512  MapNumBadChanDepth[1][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS1");
513  MapNumBadChanDepth[1][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS2");
514 
515  MapNumBadChanDepth[1][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS3");
516  MapNumBadChanDepth[1][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS4");
517  MapNumBadChanDepth[1][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS5");
518 
519  MapNumBadChanDepth[1][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS8");
520 
521  MapNumBadChanDepth[1][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS6");
522  MapNumBadChanDepth[1][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplLS7");
523 
524  MapNumBadChanFull[1] = (TH2F *)MapNumBadChanDepth[1][1][1]->Clone();
525 
526  MapNumChanDepth[1][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS1");
527  MapNumChanDepth[1][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS2");
528 
529  MapNumChanDepth[1][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS3");
530  MapNumChanDepth[1][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS4");
531  MapNumChanDepth[1][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS5");
532 
533  MapNumChanDepth[1][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS8");
534 
535  MapNumChanDepth[1][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS6");
536  MapNumChanDepth[1][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumADCAmplLS7");
537 
538  MapNumChanFull[1] = (TH2F *)MapNumChanDepth[1][1][1]->Clone();
539 
540  //+++++++++++++++++++++++++++++
541  // Width
542  //+++++++++++++++++++++++++++++
543 
544  MapNumBadChanDepth[2][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS1");
545  MapNumBadChanDepth[2][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS2");
546 
547  MapNumBadChanDepth[2][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS3");
548  MapNumBadChanDepth[2][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS4");
549  MapNumBadChanDepth[2][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS5");
550 
551  MapNumBadChanDepth[2][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS8");
552 
553  MapNumBadChanDepth[2][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS6");
554  MapNumBadChanDepth[2][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplitudeLS7");
555 
556  MapNumBadChanFull[2] = (TH2F *)MapNumBadChanDepth[2][1][1]->Clone();
557 
558  MapNumChanDepth[2][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS1");
559  MapNumChanDepth[2][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS2");
560 
561  MapNumChanDepth[2][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS3");
562  MapNumChanDepth[2][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS4");
563  MapNumChanDepth[2][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS5");
564 
565  MapNumChanDepth[2][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS8");
566 
567  MapNumChanDepth[2][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS6");
568  MapNumChanDepth[2][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplitudeLS7");
569 
570  MapNumChanFull[2] = (TH2F *)MapNumChanDepth[2][1][1]->Clone();
571 
572  //+++++++++++++++++++++++++++++
573  // Ratio
574  //+++++++++++++++++++++++++++++
575 
576  MapNumBadChanDepth[3][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS1");
577  MapNumBadChanDepth[3][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS2");
578 
579  MapNumBadChanDepth[3][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS3");
580  MapNumBadChanDepth[3][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS4");
581  MapNumBadChanDepth[3][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS5");
582 
583  MapNumBadChanDepth[3][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS8");
584 
585  MapNumBadChanDepth[3][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS6");
586  MapNumBadChanDepth[3][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumAmplLS7");
587 
588  MapNumBadChanFull[3] = (TH2F *)MapNumBadChanDepth[3][1][1]->Clone();
589 
590  MapNumChanDepth[3][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS1");
591  MapNumChanDepth[3][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS2");
592 
593  MapNumChanDepth[3][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS3");
594  MapNumChanDepth[3][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS4");
595  MapNumChanDepth[3][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS5");
596 
597  MapNumChanDepth[3][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS8");
598 
599  MapNumChanDepth[3][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS6");
600  MapNumChanDepth[3][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumAmplLS7");
601 
602  MapNumChanFull[3] = (TH2F *)MapNumChanDepth[3][1][1]->Clone();
603 
604  //+++++++++++++++++++++++++++++
605  // Tmean
606  //+++++++++++++++++++++++++++++
607 
608  MapNumBadChanDepth[4][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS1");
609  MapNumBadChanDepth[4][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS2");
610 
611  MapNumBadChanDepth[4][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS3");
612  MapNumBadChanDepth[4][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS4");
613  MapNumBadChanDepth[4][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS5");
614 
615  MapNumBadChanDepth[4][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS8");
616 
617  MapNumBadChanDepth[4][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS6");
618  MapNumBadChanDepth[4][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmeanALS7");
619 
620  MapNumBadChanFull[4] = (TH2F *)MapNumBadChanDepth[4][1][1]->Clone();
621 
622  MapNumChanDepth[4][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS1");
623  MapNumChanDepth[4][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS2");
624 
625  MapNumChanDepth[4][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS3");
626  MapNumChanDepth[4][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS4");
627  MapNumChanDepth[4][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS5");
628 
629  MapNumChanDepth[4][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS8");
630 
631  MapNumChanDepth[4][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS6");
632  MapNumChanDepth[4][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmeanALS7");
633 
634  MapNumChanFull[4] = (TH2F *)MapNumChanDepth[4][1][1]->Clone();
635 
636  //+++++++++++++++++++++++++++++
637  // Tmax
638  //+++++++++++++++++++++++++++++
639 
640  MapNumBadChanDepth[5][1][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS1");
641  MapNumBadChanDepth[5][1][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS2");
642 
643  MapNumBadChanDepth[5][2][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS3");
644  MapNumBadChanDepth[5][2][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS4");
645  MapNumBadChanDepth[5][2][3] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS5");
646 
647  MapNumBadChanDepth[5][3][4] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS8");
648 
649  MapNumBadChanDepth[5][4][1] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS6");
650  MapNumBadChanDepth[5][4][2] = (TH2F *)dir->FindObjectAny("h_2DsumTSmaxALS7");
651 
652  MapNumBadChanFull[5] = (TH2F *)MapNumBadChanDepth[5][1][1]->Clone();
653 
654  MapNumChanDepth[5][1][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS1");
655  MapNumChanDepth[5][1][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS2");
656 
657  MapNumChanDepth[5][2][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS3");
658  MapNumChanDepth[5][2][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS4");
659  MapNumChanDepth[5][2][3] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS5");
660 
661  MapNumChanDepth[5][3][4] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS8");
662 
663  MapNumChanDepth[5][4][1] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS6");
664  MapNumChanDepth[5][4][2] = (TH2F *)dir->FindObjectAny("h_2D0sumTSmaxALS7");
665 
666  MapNumChanFull[5] = (TH2F *)MapNumChanDepth[5][1][1]->Clone();
667 
668  for (int test = 0; test <= 5; test++) { //Test: 0,
669  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
670  if (sub == 1)
671  cHB->Divide(2, 1);
672  if (sub == 2)
673  cHE->Divide(3, 1);
674  if (sub == 3)
675  cONE->Divide(1, 1);
676  if (sub == 4)
677  cHB->Divide(2, 1);
678  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
679  if (sub == 1)
680  cHB->cd(k);
681  if (sub == 2)
682  cHE->cd(k);
683  if (sub == 3)
684  cONE->cd(k - 3);
685  if (sub == 4)
686  cHB->cd(k);
687  MapNumBadChanDepth[test][sub][k]->Divide(
688  MapNumBadChanDepth[test][sub][k], MapNumChanDepth[test][sub][k], 1, 1, "B");
689 
690  for (int x = 1; x <= MapNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
691  for (int y = 1; y <= MapNumBadChanFull[test]->GetYaxis()->GetNbins(); y++) {
692  double ccc1 = MapNumBadChanDepth[test][sub][k]->GetBinContent(x, y);
693  MapNumBadChanFull[test]->SetBinContent(x, y, MapNumBadChanFull[test]->GetBinContent(x, y) + ccc1);
694  } //end y
695  } //end x
696 
697  if (k == 1)
698  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
699  if (k == 2)
700  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
701  if (k == 3)
702  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
703  if (k == 4)
704  MapNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
705  gPad->SetGridy();
706  gPad->SetGridx();
707  gPad->SetLogz();
708  //
709  // gPad->DrawFrame(0.0, 0.0001, 1.0, 1000);
710  // gPad->DrawFrame(0.2, 0.0002, 0.8, 10000);
711  MapNumBadChanDepth[test][sub][k]->SetXTitle("#eta \b");
712  MapNumBadChanDepth[test][sub][k]->SetYTitle("#phi \b");
713  MapNumBadChanDepth[test][sub][k]->SetZTitle("Average estimator \b");
715  // MapNumBadChanDepth[test][sub][k]->SetTitleOffset(0.75, "Z");
716  MapNumBadChanDepth[test][sub][k]->Draw("COLZ");
717  // MapNumBadChanDepth[test][sub][k]->Draw("same");
718  MapNumBadChanDepth[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
719  MapNumBadChanDepth[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
720  }
721  if (test == 0) {
722  if (sub == 1) {
723  cHB->Print("MapCapIdErrorHB.png");
724  cHB->Clear();
725  }
726  if (sub == 2) {
727  cHE->Print("MapCapIdErrorHE.png");
728  cHE->Clear();
729  }
730  if (sub == 3) {
731  cONE->Print("MapCapIdErrorHO.png");
732  cONE->Clear();
733  }
734  if (sub == 4) {
735  cHB->Print("MapCapIdErrorHF.png");
736  cHB->Clear();
737  }
738  }
739  if (test == 1) {
740  if (sub == 1) {
741  cHB->Print("MapADCamplHB.png");
742  cHB->Clear();
743  }
744  if (sub == 2) {
745  cHE->Print("MapADCamplHE.png");
746  cHE->Clear();
747  }
748  if (sub == 3) {
749  cONE->Print("MapADCamplHO.png");
750  cONE->Clear();
751  }
752  if (sub == 4) {
753  cHB->Print("MapADCamplHF.png");
754  cHB->Clear();
755  }
756  }
757  if (test == 2) {
758  if (sub == 1) {
759  cHB->Print("MapWidthHB.png");
760  cHB->Clear();
761  }
762  if (sub == 2) {
763  cHE->Print("MapWidthHE.png");
764  cHE->Clear();
765  }
766  if (sub == 3) {
767  cONE->Print("MapWidthHO.png");
768  cONE->Clear();
769  }
770  if (sub == 4) {
771  cHB->Print("MapWidthHF.png");
772  cHB->Clear();
773  }
774  }
775  if (test == 3) {
776  if (sub == 1) {
777  cHB->Print("MapRatioHB.png");
778  cHB->Clear();
779  }
780  if (sub == 2) {
781  cHE->Print("MapRatioHE.png");
782  cHE->Clear();
783  }
784  if (sub == 3) {
785  cONE->Print("MapRatioHO.png");
786  cONE->Clear();
787  }
788  if (sub == 4) {
789  cHB->Print("MapRatioHF.png");
790  cHB->Clear();
791  }
792  }
793  if (test == 4) {
794  if (sub == 1) {
795  cHB->Print("MapTmeanHB.png");
796  cHB->Clear();
797  }
798  if (sub == 2) {
799  cHE->Print("MapTmeanHE.png");
800  cHE->Clear();
801  }
802  if (sub == 3) {
803  cONE->Print("MapTmeanHO.png");
804  cONE->Clear();
805  }
806  if (sub == 4) {
807  cHB->Print("MapTmeanHF.png");
808  cHB->Clear();
809  }
810  }
811  if (test == 5) {
812  if (sub == 1) {
813  cHB->Print("MapTmaxHB.png");
814  cHB->Clear();
815  }
816  if (sub == 2) {
817  cHE->Print("MapTmaxHE.png");
818  cHE->Clear();
819  }
820  if (sub == 3) {
821  cONE->Print("MapTmaxHO.png");
822  cONE->Clear();
823  }
824  if (sub == 4) {
825  cHB->Print("MapTmaxHF.png");
826  cHB->Clear();
827  }
828  }
829  } // end sub
830  cONE->Divide(1, 1);
831  cONE->cd(1);
832  gPad->SetGridy();
833  gPad->SetGridx();
834  gPad->SetLogz();
835  MapNumBadChanFull[test]->SetTitle("All subdetectors\b");
836  MapNumBadChanFull[test]->SetXTitle("#eta \b");
837  MapNumBadChanFull[test]->SetYTitle("#phi \b");
838  if (test == 0)
839  MapNumBadChanFull[test]->SetZTitle("Average Nbcs \b");
840  if (test != 0)
841  MapNumBadChanFull[test]->SetZTitle("Average estimator \b");
842  // MapNumBadChanFull[test]->GetZaxis()->SetLabelSize(0.008);
843  MapNumBadChanFull[test]->SetTitleOffset(0.75, "Z");
844  MapNumBadChanFull[test]->Draw("COLZ");
845  MapNumBadChanFull[test]->GetYaxis()->SetRangeUser(0, 72.);
846  // MapNumBadChanFull[test]->GetZaxis()->SetRangeUser(0.0001, 1.);
847  if (test == 0) {
848  cONE->Print("MapCapIdError.png");
849  cONE->Clear();
850  }
851  if (test == 1) {
852  cONE->Print("MapADCAmpl.png");
853  cONE->Clear();
854  }
855  if (test == 2) {
856  cONE->Print("MapWidth.png");
857  cONE->Clear();
858  }
859  if (test == 3) {
860  cONE->Print("MapRatio.png");
861  cONE->Clear();
862  }
863  if (test == 4) {
864  cONE->Print("MapTmean.png");
865  cONE->Clear();
866  }
867  if (test == 5) {
868  cONE->Print("MapTmax.png");
869  cONE->Clear();
870  }
871  } //end test
872 
873  //================================================================================================================================
874 
875  //=======================================================================================================
876  // 1-d histograms third definition
877 
878  TH1F *HistNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
879  TH1F *HistCutNumBadChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
880  TH1F *HistNumChanDepth[7][5][8]; // 1d histogramm for test,subdet, depth
881 
882  // TH1F *HistNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
883  // TH1F *HistCutNumBadChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
884  // TH1F *HistNumChanDepth[7][5][5]; // 1d histogramm for test,subdet, depth
885 
886  TH1F *HistNumBadChanFull[7]; // 1d histogramm for test
887  TH1F *HistNumChanFull[7]; // 1d histogramm for test
888 
889  //+++++++++++++++++++++++++++++
890  // Rate of Cap ID errors
891  //+++++++++++++++++++++++++++++
892 
893  HistNumBadChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HB");
894  HistNumBadChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HB");
895 
896  HistNumBadChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HE");
897  HistNumBadChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HE");
898  HistNumBadChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth3_HE");
899 
900  HistNumBadChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth4_HO");
901 
902  HistNumBadChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HF");
903  HistNumBadChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HF");
904 
905  HistNumBadChanFull[0] = (TH1F *)HistNumBadChanDepth[0][1][1]->Clone();
906 
907  HistCutNumBadChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HB");
908  HistCutNumBadChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HB");
909 
910  HistCutNumBadChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HE");
911  HistCutNumBadChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HE");
912  HistCutNumBadChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth3_HE");
913 
914  HistCutNumBadChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth4_HO");
915 
916  HistCutNumBadChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth1_HF");
917  HistCutNumBadChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannels_depth2_HF");
918 
919  HistNumChanDepth[0][1][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HB");
920  HistNumChanDepth[0][1][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HB");
921 
922  HistNumChanDepth[0][2][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HE");
923  HistNumChanDepth[0][2][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HE");
924  HistNumChanDepth[0][2][3] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth3_HE");
925 
926  HistNumChanDepth[0][3][4] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth4_HO");
927 
928  HistNumChanDepth[0][4][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HF");
929  HistNumChanDepth[0][4][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HF");
930 
931  HistNumChanFull[0] = (TH1F *)HistNumChanDepth[0][1][1]->Clone();
932 
933  //+++++++++++++++++++++++++++++
934  // ADC Amplitude
935  //+++++++++++++++++++++++++++++
936 
938  // HB:
939  HistNumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS1");
940  HistNumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS2");
941  // HB upgrade:
942  HistNumBadChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth3HBu");
943  HistNumBadChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth4HBu");
944 
945  // HE:
946  HistNumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS3");
947  HistNumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS4");
948  HistNumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS5");
949  // HE upgrade:
950  HistNumBadChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth4HEu");
951  HistNumBadChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth5HEu");
952  HistNumBadChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth6HEu");
953  HistNumBadChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLSdepth7HEu");
954 
955  // HO:
956  HistNumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS8");
957 
958  // HF:
959  HistNumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS6");
960  HistNumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS7");
961  // HF upgrade:
962  HistNumBadChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS6u");
963  HistNumBadChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sumADCAmplperLS7u");
964 
965  // other cases:
966  HistNumBadChanFull[1] = (TH1F *)HistNumBadChanDepth[1][1][1]->Clone();
967 
969  // HB:
970  HistCutNumBadChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS1");
971  HistCutNumBadChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS2");
972  // HB upgrade:
973  HistCutNumBadChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth3HBu");
974  HistCutNumBadChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth4HBu");
975 
976  // HE:
977  HistCutNumBadChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS3");
978  HistCutNumBadChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS4");
979  HistCutNumBadChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS5");
980  // HE upgrade:
981  HistCutNumBadChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth4HEu");
982  HistCutNumBadChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth5HEu");
983  HistCutNumBadChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth6HEu");
984  HistCutNumBadChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLSdepth7HEu");
985 
986  // HO:
987  HistCutNumBadChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS8");
988 
989  // HF:
990  HistCutNumBadChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS6");
991  HistCutNumBadChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS7");
992  // HF upgrade:
993  HistCutNumBadChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS6u");
994  HistCutNumBadChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sumCutADCAmplperLS7u");
995 
997  // HB:
998  HistNumChanDepth[1][1][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS1");
999  HistNumChanDepth[1][1][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS2");
1000  // HB upgrade:
1001  HistNumChanDepth[1][1][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth3HBu");
1002  HistNumChanDepth[1][1][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth4HBu");
1003 
1004  // HE:
1005  HistNumChanDepth[1][2][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS3");
1006  HistNumChanDepth[1][2][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS4");
1007  HistNumChanDepth[1][2][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS5");
1008  // HE upgrade:
1009  HistNumChanDepth[1][2][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth4HEu");
1010  HistNumChanDepth[1][2][5] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth5HEu");
1011  HistNumChanDepth[1][2][6] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth6HEu");
1012  HistNumChanDepth[1][2][7] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLSdepth7HEu");
1013 
1014  // HO:
1015  HistNumChanDepth[1][3][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS8");
1016 
1017  // HF:
1018  HistNumChanDepth[1][4][1] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS6");
1019  HistNumChanDepth[1][4][2] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS7");
1020  // HF upgrade:
1021  HistNumChanDepth[1][4][3] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS6u");
1022  HistNumChanDepth[1][4][4] = (TH1F *)dir->FindObjectAny("h_sum0ADCAmplperLS7u");
1023 
1024  // other cases:
1025  HistNumChanFull[1] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
1026  // just initialization of [6] massive for alternative <A> calculation
1027  HistNumChanFull[6] = (TH1F *)HistNumChanDepth[1][1][1]->Clone();
1028 
1029  //+++++++++++++++++++++++++++++
1030  // Width
1031  //+++++++++++++++++++++++++++++
1032 
1033  HistNumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS1");
1034  HistNumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS2");
1035 
1036  HistNumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS3");
1037  HistNumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS4");
1038  HistNumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS5");
1039 
1040  HistNumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS8");
1041 
1042  HistNumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS6");
1043  HistNumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplitudeperLS7");
1044 
1045  HistNumBadChanFull[2] = (TH1F *)HistNumBadChanDepth[2][1][1]->Clone();
1046 
1047  HistCutNumBadChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS1");
1048  HistCutNumBadChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS2");
1049 
1050  HistCutNumBadChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS3");
1051  HistCutNumBadChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS4");
1052  HistCutNumBadChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS5");
1053 
1054  HistCutNumBadChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS8");
1055 
1056  HistCutNumBadChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS6");
1057  HistCutNumBadChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplitudeperLS7");
1058 
1059  HistNumChanDepth[2][1][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS1");
1060  HistNumChanDepth[2][1][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS2");
1061 
1062  HistNumChanDepth[2][2][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS3");
1063  HistNumChanDepth[2][2][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS4");
1064  HistNumChanDepth[2][2][3] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS5");
1065 
1066  HistNumChanDepth[2][3][4] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS8");
1067 
1068  HistNumChanDepth[2][4][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS6");
1069  HistNumChanDepth[2][4][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplitudeperLS7");
1070 
1071  HistNumChanFull[2] = (TH1F *)HistNumChanDepth[2][1][1]->Clone();
1072  //+++++++++++++++++++++++++++++
1073  // Ratio
1074  //+++++++++++++++++++++++++++++
1075 
1076  HistNumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS1");
1077  HistNumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS2");
1078 
1079  HistNumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS3");
1080  HistNumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS4");
1081  HistNumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS5");
1082 
1083  HistNumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS8");
1084 
1085  HistNumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS6");
1086  HistNumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumAmplperLS7");
1087 
1088  HistNumBadChanFull[3] = (TH1F *)HistNumBadChanDepth[3][1][1]->Clone();
1089 
1090  HistCutNumBadChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS1");
1091  HistCutNumBadChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS2");
1092 
1093  HistCutNumBadChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS3");
1094  HistCutNumBadChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS4");
1095  HistCutNumBadChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS5");
1096 
1097  HistCutNumBadChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS8");
1098 
1099  HistCutNumBadChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS6");
1100  HistCutNumBadChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutAmplperLS7");
1101 
1102  HistNumChanDepth[3][1][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS1");
1103  HistNumChanDepth[3][1][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS2");
1104 
1105  HistNumChanDepth[3][2][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS3");
1106  HistNumChanDepth[3][2][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS4");
1107  HistNumChanDepth[3][2][3] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS5");
1108 
1109  HistNumChanDepth[3][3][4] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS8");
1110 
1111  HistNumChanDepth[3][4][1] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS6");
1112  HistNumChanDepth[3][4][2] = (TH1F *)dir->FindObjectAny("h_sum0AmplperLS7");
1113 
1114  HistNumChanFull[3] = (TH1F *)HistNumChanDepth[3][1][1]->Clone();
1115  //+++++++++++++++++++++++++++++
1116  // Tmean
1117  //+++++++++++++++++++++++++++++
1118 
1119  HistNumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS1");
1120  HistNumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS2");
1121 
1122  HistNumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS3");
1123  HistNumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS4");
1124  HistNumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS5");
1125 
1126  HistNumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS8");
1127 
1128  HistNumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS6");
1129  HistNumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmeanAperLS7");
1130 
1131  HistNumBadChanFull[4] = (TH1F *)HistNumBadChanDepth[4][1][1]->Clone();
1132 
1133  HistCutNumBadChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS1");
1134  HistCutNumBadChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS2");
1135 
1136  HistCutNumBadChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS3");
1137  HistCutNumBadChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS4");
1138  HistCutNumBadChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS5");
1139 
1140  HistCutNumBadChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS8");
1141 
1142  HistCutNumBadChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS6");
1143  HistCutNumBadChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmeanAperLS7");
1144 
1145  HistNumChanDepth[4][1][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS1");
1146  HistNumChanDepth[4][1][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS2");
1147 
1148  HistNumChanDepth[4][2][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS3");
1149  HistNumChanDepth[4][2][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS4");
1150  HistNumChanDepth[4][2][3] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS5");
1151 
1152  HistNumChanDepth[4][3][4] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS8");
1153 
1154  HistNumChanDepth[4][4][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS6");
1155  HistNumChanDepth[4][4][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmeanAperLS7");
1156 
1157  HistNumChanFull[4] = (TH1F *)HistNumChanDepth[4][1][1]->Clone();
1158  //+++++++++++++++++++++++++++++
1159  // Tmax
1160  //+++++++++++++++++++++++++++++
1161 
1162  HistNumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS1");
1163  HistNumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS2");
1164 
1165  HistNumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS3");
1166  HistNumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS4");
1167  HistNumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS5");
1168 
1169  HistNumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS8");
1170 
1171  HistNumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS6");
1172  HistNumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumTSmaxAperLS7");
1173 
1174  HistNumBadChanFull[5] = (TH1F *)HistNumBadChanDepth[5][1][1]->Clone();
1175 
1176  HistCutNumBadChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS1");
1177  HistCutNumBadChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS2");
1178 
1179  HistCutNumBadChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS3");
1180  HistCutNumBadChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS4");
1181  HistCutNumBadChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS5");
1182 
1183  HistCutNumBadChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS8");
1184 
1185  HistCutNumBadChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS6");
1186  HistCutNumBadChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sumCutTSmaxAperLS7");
1187 
1188  HistNumChanDepth[5][1][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS1");
1189  HistNumChanDepth[5][1][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS2");
1190 
1191  HistNumChanDepth[5][2][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS3");
1192  HistNumChanDepth[5][2][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS4");
1193  HistNumChanDepth[5][2][3] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS5");
1194 
1195  HistNumChanDepth[5][3][4] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS8");
1196 
1197  HistNumChanDepth[5][4][1] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS6");
1198  HistNumChanDepth[5][4][2] = (TH1F *)dir->FindObjectAny("h_sum0TSmaxAperLS7");
1199 
1200  HistNumChanFull[5] = (TH1F *)HistNumChanDepth[5][1][1]->Clone();
1201 
1202  for (int test = 0; test <= 5; test++) { //Test: =0(CapIdErrors), =1(Amplitude), =2...
1203  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1204  if (sub == 1 && test != 1)
1205  cHE->Divide(2, 1); //HB
1206  if (sub == 1 && test == 1) {
1207  cFour1->Clear();
1208  cFour1->Divide(2, 2);
1209  } //HB upgrade with new depthes 3,4 for Amplitude test only
1210  if (sub == 2 && test != 1)
1211  cHE->Divide(3, 1); //HE
1212  if (sub == 2 && test == 1) {
1213  cNine->Clear();
1214  cNine->Divide(3, 3);
1215  } //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1216  if (sub == 3)
1217  cHB->Divide(1, 1); //HO
1218  if (sub == 4 && test != 1)
1219  cHE->Divide(2, 1); //HF
1220  if (sub == 4 && test == 1) {
1221  cFour1->Clear();
1222  cFour1->Divide(2, 2);
1223  } // HF upgrade with new depthes 3 and 4 for Amplitude test only
1224 
1225  int kkkkkkmax = k_max[sub];
1226  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
1227  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
1228  kkkkkkmax = k_maxupgrade[sub];
1229  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1230  if (sub == 1 && test != 1)
1231  cHE->cd(k); //HB
1232  if (sub == 1 && test == 1)
1233  cFour1->cd(k); //HB
1234  if (sub == 2 && test != 1)
1235  cHE->cd(k); //HE
1236  if (sub == 2 && test == 1)
1237  cNine->cd(k); //HE upgrade with new depthes 4,5,6,7 for Amplitude test only
1238  if (sub == 3)
1239  cHB->cd(k - 3); //HO
1240  if (sub == 4 && test != 1)
1241  cHE->cd(k); //HF
1242  if (sub == 4 && test == 1)
1243  cFour1->cd(k); // HF upgrade with new depthes 3 and 4 for Amplitude test only
1244  gPad->SetGridy();
1245  gPad->SetGridx();
1246  // gPad->SetLogy();
1247 
1248  if (sub == 1 && k == 1) {
1249  } else {
1250  // use "else" because ...Full[test] are filled by estimastor for sub==1 && k== 1 at initialization of ...Full[test] variables
1251  for (int x = 1; x <= HistNumBadChanFull[test]->GetXaxis()->GetNbins(); x++) {
1252  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1253  HistNumBadChanFull[test]->SetBinContent(x, HistNumBadChanFull[test]->GetBinContent(x) + ccc1);
1254  double ccc2 = HistNumChanDepth[test][sub][k]->GetBinContent(x);
1255  HistNumChanFull[test]->SetBinContent(x, HistNumChanFull[test]->GetBinContent(x) + ccc2);
1256  }
1257  } //end x
1258 
1259  // !!!!!! change the sense of HistNumBadChanDepth: now it's averaged values(estimators)
1260  HistNumBadChanDepth[test][sub][k]->Divide(
1261  HistNumBadChanDepth[test][sub][k], HistNumChanDepth[test][sub][k], 1, 1, "B");
1262  // errors abnulling:
1263  for (int x = 1; x <= HistNumBadChanDepth[test][sub][k]->GetXaxis()->GetNbins(); x++) {
1264  HistNumBadChanDepth[test][sub][k]->SetBinError(float(x), 0.01);
1265  }
1266 
1267  // int myMaxLum= HistNumBadChanDepth[test][sub][k]->GetBinContent(HistNumBadChanDepth[test][sub][k]->GetMaximumBin());
1268  // cout<<"********************>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> myMaxLum = "<<myMaxLum<<" MaxLum = "<<MaxLum<<endl;
1269  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1270 
1271  // // // // // // // // // // // // // // // // // //
1272  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1273  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.4);
1274  HistNumBadChanDepth[test][sub][k]->GetYaxis()->SetLabelSize(0.04);
1275  if (k == 1)
1276  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1277  if (k == 2)
1278  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1279  if (k == 3)
1280  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1281  if (k == 4)
1282  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1283  if (k == 5)
1284  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 5\b");
1285  if (k == 6)
1286  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 6\b");
1287  if (k == 7)
1288  HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 7\b");
1289  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1290  if (test == 0)
1291  HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1292  if (test != 0)
1293  HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1294  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1295  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1296  // gPad->SetGridx();
1297  gPad->SetLogy();
1298  gPad->SetGridy();
1299  gPad->SetGridx();
1300  // if (test == 1) HistNumBadChanDepth[test][sub][k]->SetMinimum(0.1);
1301  HistNumBadChanDepth[test][sub][k]->Draw("Error");
1302  /*
1303  if (k == 1) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 1\b");
1304  if (k == 2) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 2\b");
1305  if (k == 3) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 3\b");
1306  if (k == 4) HistNumBadChanDepth[test][sub][k]->SetTitle("Depth 4\b");
1307  HistNumBadChanDepth[test][sub][k]->SetXTitle("LS \b");
1308  if (test == 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("<Number of bad channels> \b");
1309  if (test != 0) HistNumBadChanDepth[test][sub][k]->SetYTitle("Averaged estimator \b");
1310 
1311  if (MaxLum<=1000){
1312  HistNumBadChanDepth[test][sub][k]->SetMarkerStyle(20);
1313  HistNumBadChanDepth[test][sub][k]->SetMarkerSize(0.5);
1314  HistNumBadChanDepth[test][sub][k]->SetMarkerColor(2);
1315  HistNumBadChanDepth[test][sub][k]->SetLineColor(0);
1316  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1317  HistNumBadChanDepth[test][sub][k]->Draw("P");
1318  }
1319  else{
1320  HistNumBadChanDepth[test][sub][k]->SetLineColor(2);
1321  HistNumBadChanDepth[test][sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1322  HistNumBadChanDepth[test][sub][k]->Draw("L");
1323  }
1324  */
1325  /*
1326  float min_x[] = {0,10000};
1327  float min_y[] = {(float)(Cut0[test][sub][k]),(float)(Cut0[test][sub][k])};
1328  TGraph* MIN = new TGraph(2, min_x, min_y);
1329  MIN->SetLineStyle(2);
1330  MIN->SetLineColor(5);
1331  MIN->SetLineWidth(2 + 100*100);
1332  MIN->SetFillStyle(3005);
1333  MIN->SetFillColor(5);
1334  gPad->SetGridy();
1335  gPad->SetGridx();
1336  MIN->Draw("L");
1337 */
1338 
1339  if (sub == 1 && test != 1) {
1340  cHE->Modified();
1341  }
1342  if (sub == 1 && test == 1) {
1343  cFour1->Modified();
1344  } // HB upgrade
1345  if (sub == 2 && test != 1) {
1346  cHE->Modified();
1347  }
1348  if (sub == 2 && test == 1) {
1349  cNine->Modified();
1350  } // HE upgrade
1351  if (sub == 3) {
1352  cHB->Modified();
1353  }
1354  if (sub == 4 && test != 1) {
1355  cHE->Modified();
1356  }
1357  if (sub == 4 && test == 1) {
1358  cFour1->Modified();
1359  } // HF upgrade
1360 
1361  } // k loop
1362 
1363  if (test == 0) {
1364  if (sub == 1) {
1365  cHE->Print("HistNBCMNHB.png");
1366  cHE->Clear();
1367  }
1368  if (sub == 2) {
1369  cHE->Print("HistNBCMNHE.png");
1370  cHE->Clear();
1371  }
1372  if (sub == 3) {
1373  cHB->Print("HistNBCMNHO.png");
1374  cHB->Clear();
1375  }
1376  if (sub == 4) {
1377  cHE->Print("HistNBCMNHF.png");
1378  cHE->Clear();
1379  }
1380  }
1381  // Amplitude:
1382  if (test == 1) {
1383  if (sub == 1) {
1384  cFour1->Print("HistADCamplHB.png");
1385  cFour1->Clear();
1386  } // HB upgrade
1387  if (sub == 2) {
1388  cNine->Print("HistADCamplHE.png");
1389  cNine->Clear();
1390  } // HE upgrade
1391  if (sub == 3) {
1392  cHB->Print("HistADCamplHO.png");
1393  cHB->Clear();
1394  }
1395  if (sub == 4) {
1396  cFour1->Print("HistADCamplHF.png");
1397  cFour1->Clear();
1398  } // HF upgrade
1399  }
1400  if (test == 2) {
1401  if (sub == 1) {
1402  cHE->Print("HistWidthHB.png");
1403  cHE->Clear();
1404  }
1405  if (sub == 2) {
1406  cHE->Print("HistWidthHE.png");
1407  cHE->Clear();
1408  }
1409  if (sub == 3) {
1410  cHB->Print("HistWidthHO.png");
1411  cHB->Clear();
1412  }
1413  if (sub == 4) {
1414  cHE->Print("HistWidthHF.png");
1415  cHE->Clear();
1416  }
1417  }
1418  if (test == 3) {
1419  if (sub == 1) {
1420  cHE->Print("HistRatioHB.png");
1421  cHE->Clear();
1422  }
1423  if (sub == 2) {
1424  cHE->Print("HistRatioHE.png");
1425  cHE->Clear();
1426  }
1427  if (sub == 3) {
1428  cHB->Print("HistRatioHO.png");
1429  cHB->Clear();
1430  }
1431  if (sub == 4) {
1432  cHE->Print("HistRatioHF.png");
1433  cHE->Clear();
1434  }
1435  }
1436  if (test == 4) {
1437  if (sub == 1) {
1438  cHE->Print("HistTmeanHB.png");
1439  cHE->Clear();
1440  }
1441  if (sub == 2) {
1442  cHE->Print("HistTmeanHE.png");
1443  cHE->Clear();
1444  }
1445  if (sub == 3) {
1446  cHB->Print("HistTmeanHO.png");
1447  cHB->Clear();
1448  }
1449  if (sub == 4) {
1450  cHE->Print("HistTmeanHF.png");
1451  cHE->Clear();
1452  }
1453  }
1454  if (test == 5) {
1455  if (sub == 1) {
1456  cHE->Print("HistTmaxHB.png");
1457  cHE->Clear();
1458  }
1459  if (sub == 2) {
1460  cHE->Print("HistTmaxHE.png");
1461  cHE->Clear();
1462  }
1463  if (sub == 3) {
1464  cHB->Print("HistTmaxHO.png");
1465  cHB->Clear();
1466  }
1467  if (sub == 4) {
1468  cHE->Print("HistTmaxHF.png");
1469  cHE->Clear();
1470  }
1471  }
1472  } // end sub
1474  if (test == 1) {
1475  for (int x = 1; x <= HistNumChanFull[6]->GetXaxis()->GetNbins(); x++) {
1476  HistNumChanFull[6]->SetBinContent(x, 0.0);
1477  int depthsubcount = 0.;
1478  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1479  int kkkkkkmax = k_max[sub];
1480  if (sub == 4 || sub == 2 || sub == 1)
1481  kkkkkkmax = k_maxupgrade[sub];
1482  // if ( sub==4 || sub==2) kkkkkkmax = k_maxupgrade[sub];
1483  for (int k = k_min[sub]; k <= kkkkkkmax; k++) { //Depth
1484  // 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
1485  // if(sub==2 && k>3 ) break;
1486  depthsubcount++;
1487  double ccc1 = HistNumBadChanDepth[test][sub][k]->GetBinContent(x);
1488  HistNumChanFull[6]->SetBinContent(x, HistNumChanFull[6]->GetBinContent(x) + ccc1);
1489  } //depth
1490  } //sub
1491  if (depthsubcount > 0.) {
1492  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / depthsubcount);
1493  } else {
1494  HistNumChanFull[6]->SetBinContent(x, (HistNumChanFull[6]->GetBinContent(x)) / 8.);
1495  }
1496  } //x
1497  } //test=1
1499  if (test != 1) {
1500  cHB->Divide(1, 1);
1501  cHB->cd(1);
1502  } else {
1503  cHE->Divide(2, 1);
1504  cHE->cd(1);
1505  }
1506  HistNumBadChanFull[test]->Divide(HistNumBadChanFull[test], HistNumChanFull[test], 1, 1, "B");
1507  TH1F *kfitq = new TH1F("kfitq", "", MaxLum, 1., MaxLum + 1.);
1508  int nx = kfitq->GetXaxis()->GetNbins();
1509  for (int i = 1; i <= nx; i++) {
1510  double ccc1 = HistNumBadChanFull[test]->GetBinContent(i);
1511  if (ccc1 > 0.) {
1512  kfitq->Fill(float(i), ccc1);
1513  kfitq->SetBinError(float(i), 0.01);
1514  }
1515  }
1516  kfitq->SetMarkerStyle(20);
1517  kfitq->SetMarkerSize(0.4);
1518  kfitq->GetYaxis()->SetLabelSize(0.04);
1519  if (test == 0)
1520  kfitq->SetTitle("Average Nbch for whole Hcal \b");
1521  if (test != 0)
1522  kfitq->SetTitle("Averaged estimator for whole Hcal \b");
1523  kfitq->SetXTitle("LS \b");
1524  if (test == 0)
1525  kfitq->SetYTitle("<Number of bad channels> \b");
1526  if (test != 0)
1527  kfitq->SetYTitle("Averaged estimator \b");
1528  kfitq->SetMarkerColor(2);
1529  kfitq->SetLineColor(0);
1530  gPad->SetGridx();
1531  kfitq->Draw("Error");
1532  /*
1533  HistNumBadChanFull[test]->SetMarkerStyle(20);
1534  HistNumBadChanFull[test]->SetMarkerSize(0.8);
1535  HistNumBadChanFull[test]->SetTitle("Averaged estimator for whole Hcal \b");
1536  HistNumBadChanFull[test]->SetXTitle("LS \b");
1537  if (test == 0) HistNumBadChanFull[test]->SetYTitle("<Number of bad channels> \b");
1538  if (test != 0) HistNumBadChanFull[test]->SetYTitle("Averaged estimator \b");
1539  if (MaxLum<=1000){
1540  HistNumBadChanFull[test]->SetMarkerColor(1);
1541  HistNumBadChanFull[test]->SetLineColor(0);
1542  HistNumBadChanFull[test]->Draw("P");
1543  }
1544  else {
1545  HistNumBadChanFull[test]->SetLineColor(1);
1546  HistNumBadChanFull[test]->Draw("L");
1547  }
1548  */
1549  if (test == 1) {
1550  cHE->cd(2);
1551  TH1F *lpuio = new TH1F("lpuio", "", MaxLum, 1., MaxLum + 1.);
1552  int nx = lpuio->GetXaxis()->GetNbins();
1553  for (int i = 1; i <= nx; i++) {
1554  double ccc1 = HistNumChanFull[6]->GetBinContent(i);
1555  if (ccc1 > 0.) {
1556  lpuio->Fill(float(i), ccc1);
1557  lpuio->SetBinError(float(i), 0.01);
1558  }
1559  }
1560  lpuio->SetMarkerStyle(20);
1561  lpuio->SetMarkerSize(0.4);
1562  lpuio->GetYaxis()->SetLabelSize(0.04);
1563  lpuio->SetTitle("Mean of Averaged Amplitudes over all Hcal sub-detectors \b");
1564  lpuio->SetXTitle("LS \b");
1565  lpuio->SetYTitle("Mean of Averaged estimator \b");
1566  lpuio->SetMarkerColor(2);
1567  lpuio->SetLineColor(0);
1568  gPad->SetGridx();
1569  lpuio->Draw("Error");
1570  }
1571  if (test == 0) {
1572  cHB->Print("HistCapID.png");
1573  cHB->Clear();
1574  }
1575  if (test == 1) {
1576  cHE->Print("HistADCAmpl.png");
1577  cHE->Clear();
1578  }
1579  if (test == 2) {
1580  cHB->Print("HistWidth.png");
1581  cHB->Clear();
1582  }
1583  if (test == 3) {
1584  cHB->Print("HistRatio.png");
1585  cHB->Clear();
1586  }
1587  if (test == 4) {
1588  cHB->Print("HistTmean.png");
1589  cHB->Clear();
1590  }
1591  if (test == 5) {
1592  cHB->Print("HistTmax.png");
1593  cHB->Clear();
1594  }
1595 
1596  // clean-up
1597  if (kfitq)
1598  delete kfitq;
1599  } //end test
1600 
1601  //================================================================================================================================
1602 
1603  //=======================================================================================================333
1604  //CapID 1-d histograms
1605 
1606  TH1F *HistAbnormNumBadChanDepth[5][5]; // 1d histogramm for subdet, depth
1607 
1608  //+++++++++++++++++++++++++++++
1609  // Abnormal Bad Channels Rate of Cap ID errors first set of histograms
1610  //+++++++++++++++++++++++++++++
1611 
1612  HistAbnormNumBadChanDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HB");
1613  HistAbnormNumBadChanDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HB");
1614  HistAbnormNumBadChanDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HE");
1615  HistAbnormNumBadChanDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HE");
1616  HistAbnormNumBadChanDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth3_HE");
1617  HistAbnormNumBadChanDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth4_HO");
1618  HistAbnormNumBadChanDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth1_HF");
1619  HistAbnormNumBadChanDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runnbadchannelsC_depth2_HF");
1620 
1621  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1622  if (sub == 1)
1623  cHB->Divide(2, 1);
1624  if (sub == 2)
1625  cHE->Divide(3, 1);
1626  if (sub == 3)
1627  cONE->Divide(1, 1);
1628  if (sub == 4)
1629  cHB->Divide(2, 1);
1630  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1631  if (sub == 1)
1632  cHB->cd(k);
1633  if (sub == 2)
1634  cHE->cd(k);
1635  if (sub == 3)
1636  cONE->cd(k - 3);
1637  if (sub == 4)
1638  cHB->cd(k);
1639  gPad->SetGridy();
1640  gPad->SetGridx();
1641  // gPad->SetLogy();
1642  HistAbnormNumBadChanDepth[sub][k]->Divide(
1643  HistAbnormNumBadChanDepth[sub][k], HistNumChanDepth[0][sub][k], 1, 1, "B");
1644  if (k == 1)
1645  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 1\b");
1646  if (k == 2)
1647  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 2\b");
1648  if (k == 3)
1649  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 3\b");
1650  if (k == 4)
1651  HistAbnormNumBadChanDepth[sub][k]->SetTitle("Depth 4\b");
1652  HistAbnormNumBadChanDepth[sub][k]->SetXTitle("LS \b");
1653  HistAbnormNumBadChanDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1654  if (MaxLum <= 1000) {
1655  HistAbnormNumBadChanDepth[sub][k]->SetMarkerStyle(20);
1656  HistAbnormNumBadChanDepth[sub][k]->SetMarkerSize(0.5);
1657  HistAbnormNumBadChanDepth[sub][k]->SetMarkerColor(1);
1658  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(0);
1659  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1660  HistAbnormNumBadChanDepth[sub][k]->Draw("P");
1661  } else {
1662  HistAbnormNumBadChanDepth[sub][k]->SetLineColor(1);
1663  HistAbnormNumBadChanDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1664  HistAbnormNumBadChanDepth[sub][k]->Draw("L");
1665  }
1666  }
1667  if (sub == 1) {
1668  cHB->Print("Hist_CAPID_Abnorm_HB.png");
1669  cHB->Clear();
1670  }
1671  if (sub == 2) {
1672  cHE->Print("Hist_CAPID_Abnorm_HE.png");
1673  cHE->Clear();
1674  }
1675  if (sub == 3) {
1676  cONE->Print("Hist_CAPID_Abnorm_HO.png");
1677  cONE->Clear();
1678  }
1679  if (sub == 4) {
1680  cHB->Print("Hist_CAPID_Abnorm_HF.png");
1681  cHB->Clear();
1682  }
1683  } // end sub
1684 
1685  //+++++++++++++++++++++++++++++
1686  // Portions of bad channels events identified by Cap ID errors third set of histograms
1687  //+++++++++++++++++++++++++++++
1688 
1689  TH1F *HistPortBadEventsDepth[5][5]; // 1d histogramm for subdet, depth
1690 
1691  HistPortBadEventsDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HB");
1692  HistPortBadEventsDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HB");
1693  HistPortBadEventsDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HE");
1694  HistPortBadEventsDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HE");
1695  HistPortBadEventsDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth3_HE");
1696  HistPortBadEventsDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth4_HO");
1697  HistPortBadEventsDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth1_HF");
1698  HistPortBadEventsDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runbadrateC_depth2_HF");
1699 
1700  TH1F *HistNumRateDepth[5][5];
1701  HistNumRateDepth[1][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HB");
1702  HistNumRateDepth[1][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HB");
1703  HistNumRateDepth[2][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HE");
1704  HistNumRateDepth[2][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HE");
1705  HistNumRateDepth[2][3] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth3_HE");
1706  HistNumRateDepth[3][4] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth4_HO");
1707  HistNumRateDepth[4][1] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth1_HF");
1708  HistNumRateDepth[4][2] = (TH1F *)dir->FindObjectAny("h_runbadrate0_depth2_HF");
1709 
1710  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1711  if (sub == 1)
1712  cHB->Divide(2, 1);
1713  if (sub == 2)
1714  cHE->Divide(3, 1);
1715  if (sub == 3)
1716  cONE->Divide(1, 1);
1717  if (sub == 4)
1718  cHB->Divide(2, 1);
1719  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1720  if (sub == 1)
1721  cHB->cd(k);
1722  if (sub == 2)
1723  cHE->cd(k);
1724  if (sub == 3)
1725  cONE->cd(k - 3);
1726  if (sub == 4)
1727  cHB->cd(k);
1728  gPad->SetGridy();
1729  gPad->SetGridx();
1730  // gPad->SetLogy();
1731  HistPortBadEventsDepth[sub][k]->Divide(HistPortBadEventsDepth[sub][k], HistNumRateDepth[sub][k], 1, 1, "B");
1732 
1733  if (k == 1)
1734  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 1\b");
1735  if (k == 2)
1736  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 2\b");
1737  if (k == 3)
1738  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 3\b");
1739  if (k == 4)
1740  HistPortBadEventsDepth[sub][k]->SetTitle("Depth 4\b");
1741  HistPortBadEventsDepth[sub][k]->SetXTitle("LS \b");
1742  HistPortBadEventsDepth[sub][k]->SetYTitle("< Number of bad channels > \b");
1743  if (MaxLum <= 1000) {
1744  HistPortBadEventsDepth[sub][k]->SetMarkerStyle(20);
1745  HistPortBadEventsDepth[sub][k]->SetMarkerSize(0.5);
1746  HistPortBadEventsDepth[sub][k]->SetMarkerColor(1);
1747  HistPortBadEventsDepth[sub][k]->SetLineColor(0);
1748  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1749  HistPortBadEventsDepth[sub][k]->Draw("P");
1750  } else {
1751  HistPortBadEventsDepth[sub][k]->SetLineColor(1);
1752  HistPortBadEventsDepth[sub][k]->GetXaxis()->SetRangeUser(0, MaxLum);
1753  HistPortBadEventsDepth[sub][k]->Draw("L");
1754  }
1755  }
1756  if (sub == 1) {
1757  cHB->Print("HistPortHB.png");
1758  cHB->Clear();
1759  }
1760  if (sub == 2) {
1761  cHE->Print("HistPortHE.png");
1762  cHE->Clear();
1763  }
1764  if (sub == 3) {
1765  cONE->Print("HistPortHO.png");
1766  cONE->Clear();
1767  }
1768  if (sub == 4) {
1769  cHB->Print("HistPortHF.png");
1770  cHB->Clear();
1771  }
1772  } // end sub
1773 
1774  //================================================================================================================================
1775 
1776  //+++++++++++++++++++++++++++++
1777  // Number of bad channels events identified by Cap ID errors third set of histograms
1778  //+++++++++++++++++++++++++++++
1779 
1780  TH1F *HistNBadChsDepth[5][5]; // 1d histogramm for subdet, depth
1781 
1782  HistNBadChsDepth[1][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HB");
1783  HistNBadChsDepth[1][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HB");
1784  HistNBadChsDepth[2][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HE");
1785  HistNBadChsDepth[2][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HE");
1786  HistNBadChsDepth[2][3] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth3_HE");
1787  HistNBadChsDepth[3][4] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth4_HO");
1788  HistNBadChsDepth[4][1] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth1_HF");
1789  HistNBadChsDepth[4][2] = (TH1F *)dir->FindObjectAny("h_nbadchannels_depth2_HF");
1790 
1791  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1792  if (sub == 1)
1793  cHB->Divide(2, 1);
1794  if (sub == 2)
1795  cHE->Divide(3, 1);
1796  if (sub == 3)
1797  cONE->Divide(1, 1);
1798  if (sub == 4)
1799  cHB->Divide(2, 1);
1800  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1801  if (sub == 1)
1802  cHB->cd(k);
1803  if (sub == 2)
1804  cHE->cd(k);
1805  if (sub == 3)
1806  cONE->cd(k - 3);
1807  if (sub == 4)
1808  cHB->cd(k);
1809  gPad->SetGridy();
1810  gPad->SetGridx();
1811  gPad->SetLogy();
1812 
1813  if (k == 1)
1814  HistNBadChsDepth[sub][k]->SetTitle("Depth 1\b");
1815  if (k == 2)
1816  HistNBadChsDepth[sub][k]->SetTitle("Depth 2\b");
1817  if (k == 3)
1818  HistNBadChsDepth[sub][k]->SetTitle("Depth 3\b");
1819  if (k == 4)
1820  HistNBadChsDepth[sub][k]->SetTitle("Depth 4\b");
1821  HistNBadChsDepth[sub][k]->SetXTitle("Number of bad channels\b");
1822  HistNBadChsDepth[sub][k]->SetYTitle("Number of events\b");
1823  // HistNBadChsDepth[sub][k]->SetMarkerStyle(20);
1824  // HistNBadChsDepth[sub][k]->SetMarkerSize(0.5);
1825  // HistNBadChsDepth[sub][k]->SetMarkerColor(1);
1826  // HistNBadChsDepth[sub][k]->SetLineColor(0);
1827  HistNBadChsDepth[sub][k]->Draw("");
1828  }
1829  if (sub == 1) {
1830  cHB->Print("HistNBadChsHB.png");
1831  cHB->Clear();
1832  }
1833  if (sub == 2) {
1834  cHE->Print("HistNBadChsHE.png");
1835  cHE->Clear();
1836  }
1837  if (sub == 3) {
1838  cONE->Print("HistNBadChsHO.png");
1839  cONE->Clear();
1840  }
1841  if (sub == 4) {
1842  cHB->Print("HistNBadChsHF.png");
1843  cHB->Clear();
1844  }
1845  } // end sub
1846 
1847  //====================================================================== HB :
1848  //====================================================================== HB :
1849  //====================================================================== HB :
1850  // Special test of errors type A and B in HB
1851  // AZ 08.02.2016
1852 
1853  int flagErrAB_HB[2];
1854  flagErrAB_HB[0] = -1;
1855  flagErrAB_HB[1] = -1;
1856  double avedelta_HB = 0.;
1857  int lastLumiBin_HB = -1;
1858  int LSofFirstErrB_HB = -1;
1859  {
1860  const int specCountA = 4;
1861  const int specColors[specCountA] = {1, 2, 3, 4};
1862  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS1_P1", "h_sum0ADCAmplperLS1_P1"},
1863  {"h_sumADCAmplperLS1_P2", "h_sum0ADCAmplperLS1_P2"},
1864  {"h_sumADCAmplperLS1_M1", "h_sum0ADCAmplperLS1_M1"},
1865  {"h_sumADCAmplperLS1_M2", "h_sum0ADCAmplperLS1_M2"}};
1866 
1867  std::vector<TH1F *> hV;
1868  THStack *hs = new THStack("hs", "ADCAmplerLS1");
1869  cHB->Clear();
1870  // cHB->cd();
1871  cHB->Divide(2, 1);
1872  cHB->cd(1);
1873 
1875  for (int i = 0; i < specCountA; i++) {
1876  if (1)
1877  std::cout << "debugger: errA_HB : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
1878  << "\n";
1879  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
1880  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
1881  if (!h1 || !h0) {
1882  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
1883  ptext->AddText("Missing histo");
1884  if (!h1) {
1885  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
1886  ptext->AddText(hnames[i][0]);
1887  }
1888  if (!h0) {
1889  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
1890  ptext->AddText(hnames[i][1]);
1891  }
1892  ptext->Draw();
1893  continue;
1894  }
1895  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
1896  hERT1orig->Divide(h1, h0, 1, 1, "B");
1897 
1898  if ((lastLumiBin_HB < 0) && (i == 0)) {
1899  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
1900  if (hERT1orig->GetBinContent(ibin) == 0)
1901  lastLumiBin_HB = ibin;
1902  else
1903  break;
1904  }
1905  lastLumiBin_HB += 3; // show more bins
1906  if (lastLumiBin_HB >= hERT1orig->GetNbinsX())
1907  lastLumiBin_HB = -1;
1908  }
1909  TH1F *hERT1 = NULL;
1910  if (lastLumiBin_HB > 1) {
1911  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HB)) {
1912  std::cout << "code failed" << std::endl;
1913  gSystem->Exit(1);
1914  }
1915  } else
1916  hERT1 = hERT1orig;
1917 
1918  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HB: black-P1, red-P2,green-M1,blue-M2");
1919  hV.push_back(hERT1);
1920  hERT1->SetMarkerStyle(20);
1921  hERT1->SetMarkerSize(0.4);
1922  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HB P1 - iLS \b");
1923  hERT1->SetMarkerColor(specColors[i]);
1924  hERT1->SetLineColor(0);
1925  hs->Add(hERT1);
1926  delete h1;
1927  delete h0;
1928  if (hERT1 != hERT1orig)
1929  delete hERT1orig;
1930  }
1931  hs->Draw("LPE1 nostack");
1932  cHB->Update(); // activate the axes
1933  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
1934  hs->Draw("LPE1 nostack");
1935  gPad->SetGridy();
1937 
1938  // AZ corrections 08.02.2016
1939  cHB->cd(2);
1940  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
1941 
1942  if (int(hV.size()) == specCountA) {
1943  flagErrAB_HB[0] = 0; // If we have the expected number of histograms, set the flag
1944  double sumdelta = 0.;
1945  int nnndelta = 0;
1946  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
1947  double delta = 0.;
1948  double maxdelta = 0.;
1949  for (unsigned int i = 0; i < hV.size(); i++) {
1950  const TH1F *hi = hV[i];
1951  for (unsigned int j = 1; j < hV.size(); j++) {
1952  const TH1F *hj = hV[j];
1953  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
1954  if (delta > maxdelta)
1955  maxdelta = delta;
1956  } //for
1957  } //for
1958  if (maxdelta > 0.) {
1959  diff->Fill(maxdelta);
1960  sumdelta += maxdelta;
1961  nnndelta++;
1962  }
1963  } //for ibin
1964  // avedelta_HB = sumdelta/hV[0]->GetNbinsX();
1965  avedelta_HB = sumdelta / nnndelta;
1966  std::cout << "******************>>>>>> ErrA_HB: avedelta_HB = " << avedelta_HB << std::endl;
1967  if (avedelta_HB > 0.24 || (avedelta_HB < 0.14 && avedelta_HB > 0.)) {
1968  flagErrAB_HB[0] = 1;
1969  } //if
1970  } //hV.size
1971  diff->SetMarkerStyle(20);
1972  diff->SetMarkerSize(0.8);
1973  diff->SetXTitle("max difference \b");
1974  diff->SetMarkerColor(2);
1975  diff->SetLineColor(0);
1976  gPad->SetGridx();
1977  gPad->SetLogy();
1978  diff->Draw("Error");
1980  cHB->Update();
1981  cHB->Print("HistErrA_HB.png");
1982  cHB->Clear();
1984 
1985  // clean-up
1986  if (diff)
1987  delete diff;
1988  for (unsigned int i = 0; i < hV.size(); i++)
1989  delete hV[i];
1990  } // ErrorA in HB
1991 
1993 
1994  { // errors type B
1995  const int specCountB = 4;
1996  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS1", "h_2D0sumErrorBLS1"},
1997  {"h_sumErrorBperLS1", "h_sum0ErrorBperLS1"},
1998  {"h_2DsumErrorBLS2", "h_2D0sumErrorBLS2"},
1999  {"h_sumErrorBperLS2", "h_sum0ErrorBperLS2"}};
2000 
2001  for (int depth = 1; depth <= 2; depth++) {
2002  cHB->Clear();
2003  cHB->Divide(2, 1);
2004  cHB->cd(1);
2005 
2006  TH1F *hRate2orig = NULL;
2007  TH2F *h2Cefz6 = NULL;
2008  TString hname1 = hnames[2 * depth - 2][0];
2009  TString hname0 = hnames[2 * depth - 2][1];
2010  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2011  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2012  if (1)
2013  std::cout << "debugger: errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2014  if (!twod1 || !twod0) {
2015  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2016  ptext->AddText("Missing histos");
2017  if (!twod1) {
2018  std::cout << "\tfailed to get " << hname1 << "\n";
2019  ptext->AddText(hname1);
2020  }
2021  if (!twod0) {
2022  std::cout << "\tfailed to get " << hname0 << "\n";
2023  ptext->AddText(hname0);
2024  }
2025  ptext->Draw();
2026  } else {
2027  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2028  h2Cefz6->SetTitle(Form("HB Depth %d \b", depth));
2029  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2030 
2031  gPad->SetGridy();
2032  gPad->SetGridx();
2033  gPad->SetLogz();
2034  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2035  h2Cefz6->SetMarkerStyle(20);
2036  h2Cefz6->SetMarkerSize(0.4);
2037  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2038  h2Cefz6->SetXTitle("#eta \b");
2039  h2Cefz6->SetYTitle("#phi \b");
2040  h2Cefz6->SetZTitle(Form("<ErrorB> - HB Depth%d \b", depth));
2041  h2Cefz6->SetMarkerColor(2);
2042  h2Cefz6->SetLineColor(2);
2043  h2Cefz6->Draw("COLZ");
2044 
2045  delete twod1;
2046  delete twod0;
2047  } // histos ok
2048 
2049  cHB->cd(2);
2050  hname1 = hnames[2 * depth - 1][0];
2051  hname0 = hnames[2 * depth - 1][1];
2052  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2053  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2054  if (1)
2055  std::cout << "errB_HB depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2056  if (!h1 || !h0) {
2057  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2058  ptext->AddText("Missing histo");
2059  if (!h1) {
2060  std::cout << "\tfailed to get " << hname1 << "\n";
2061  ptext->AddText(hname1);
2062  }
2063  if (!h0) {
2064  std::cout << "\tfailed to get " << hname0 << "\n";
2065  ptext->AddText(hname0);
2066  }
2067  ptext->Draw();
2068  } else {
2069  gPad->SetGridx();
2070  gPad->SetGridy();
2071  // gPad->SetLogy();
2072  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2073  hRate2orig->Divide(h1, h0, 1, 1, "B");
2074 
2075  TH1F *hRate2 = NULL;
2076  if (lastLumiBin_HB > 1) {
2077  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HB)) {
2078  std::cout << "code failed" << std::endl;
2079  gSystem->Exit(1);
2080  }
2081  } else
2082  hRate2 = hRate2orig;
2083 
2084  hRate2->SetTitle(Form("Depth %d \b", depth));
2085  hRate2->SetMarkerStyle(20);
2086  hRate2->SetMarkerSize(0.8);
2087  // hRate2->GetZaxis()->SetLabelSize(0.04);
2088  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HB depth%d - iLS \b", depth));
2089  hRate2->SetMarkerColor(2);
2090  hRate2->SetLineColor(0);
2091  hRate2->Draw("Error");
2092 
2093  if (LSofFirstErrB_HB == -1) {
2094  int nx = hRate2->GetXaxis()->GetNbins();
2095  for (int i = 1; i <= nx; i++) {
2096  double ccc1 = hRate2->GetBinContent(i);
2097  if (ccc1 > 0.) {
2098  cout << "****************>>>>>>>>>>> ErrB_HB bad LS start at iLS = " << i << " with rate = " << ccc1
2099  << endl;
2100  LSofFirstErrB_HB = i;
2101  break;
2102  }
2103  }
2104  }
2105 
2106  delete h1;
2107  delete h0;
2108  if (hRate2 != hRate2orig) {
2109  delete hRate2orig;
2110  hRate2orig = hRate2;
2111  }
2112  }
2113 
2114  cHB->Update();
2115  cHB->Print(Form("HistErrB_HB_%d.png", depth));
2116  cHB->Clear();
2117  if (h2Cefz6)
2118  delete h2Cefz6;
2119  if (hRate2orig)
2120  delete hRate2orig;
2121  }
2122  } // ErrorsB in HB
2123 
2124  //====================================================================== HE :
2125  //====================================================================== HE :
2126  //====================================================================== HE :
2127  // Special test of errors type A and B in HE
2128  // AZ 08.02.2016
2129 
2130  int flagErrAB_HE[2];
2131  flagErrAB_HE[0] = -1;
2132  flagErrAB_HE[1] = -1;
2133  double avedelta_HE = 0.;
2134  int lastLumiBin_HE = -1;
2135  int LSofFirstErrB_HE = -1;
2136  {
2137  const int specCountA = 4;
2138  const int specColors[specCountA] = {1, 2, 3, 4};
2139  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS3_P1", "h_sum0ADCAmplperLS3_P1"},
2140  {"h_sumADCAmplperLS3_P2", "h_sum0ADCAmplperLS3_P2"},
2141  {"h_sumADCAmplperLS3_M1", "h_sum0ADCAmplperLS3_M1"},
2142  {"h_sumADCAmplperLS3_M2", "h_sum0ADCAmplperLS3_M2"}};
2143 
2144  std::vector<TH1F *> hV;
2145  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2146  cHB->Clear();
2147  // cHB->cd();
2148  cHB->Divide(2, 1);
2149  cHB->cd(1);
2150 
2152  for (int i = 0; i < specCountA; i++) {
2153  if (1)
2154  std::cout << "debugger: errA_HE : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2155  << "\n";
2156  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2157  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2158  if (!h1 || !h0) {
2159  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2160  ptext->AddText("Missing histo");
2161  if (!h1) {
2162  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2163  ptext->AddText(hnames[i][0]);
2164  }
2165  if (!h0) {
2166  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2167  ptext->AddText(hnames[i][1]);
2168  }
2169  ptext->Draw();
2170  continue;
2171  }
2172  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2173  hERT1orig->Divide(h1, h0, 1, 1, "B");
2174 
2175  if ((lastLumiBin_HE < 0) && (i == 0)) {
2176  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2177  if (hERT1orig->GetBinContent(ibin) == 0)
2178  lastLumiBin_HE = ibin;
2179  else
2180  break;
2181  }
2182  lastLumiBin_HE += 3; // show more bins
2183  if (lastLumiBin_HE >= hERT1orig->GetNbinsX())
2184  lastLumiBin_HE = -1;
2185  }
2186  TH1F *hERT1 = NULL;
2187  if (lastLumiBin_HE > 1) {
2188  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HE)) {
2189  std::cout << "code failed" << std::endl;
2190  gSystem->Exit(1);
2191  }
2192  } else
2193  hERT1 = hERT1orig;
2194 
2195  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HE: black-P1, red-P2,green-M1,blue-M2");
2196  hV.push_back(hERT1);
2197  hERT1->SetMarkerStyle(20);
2198  hERT1->SetMarkerSize(0.4);
2199  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HE P1 - iLS \b");
2200  hERT1->SetMarkerColor(specColors[i]);
2201  hERT1->SetLineColor(0);
2202  hs->Add(hERT1);
2203  delete h1;
2204  delete h0;
2205  if (hERT1 != hERT1orig)
2206  delete hERT1orig;
2207  }
2208  hs->Draw("LPE1 nostack");
2209  cHB->Update(); // activate the axes
2210  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2211  hs->Draw("LPE1 nostack");
2212  gPad->SetGridy();
2214 
2215  // AZ corrections 08.02.2016
2216  cHB->cd(2);
2217  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2218 
2219  if (int(hV.size()) == specCountA) {
2220  flagErrAB_HE[0] = 0; // If we have the expected number of histograms, set the flag
2221  double sumdelta = 0.;
2222  int nnndelta = 0;
2223  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2224  double delta = 0.;
2225  double maxdelta = 0.;
2226  for (unsigned int i = 0; i < hV.size(); i++) {
2227  const TH1F *hi = hV[i];
2228  for (unsigned int j = 1; j < hV.size(); j++) {
2229  const TH1F *hj = hV[j];
2230  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2231  if (delta > maxdelta)
2232  maxdelta = delta;
2233  } //for
2234  } //for
2235  if (maxdelta > 0.) {
2236  diff->Fill(maxdelta);
2237  sumdelta += maxdelta;
2238  nnndelta++;
2239  }
2240  } //for ibin
2241  // avedelta_HE = sumdelta/hV[0]->GetNbinsX();
2242  avedelta_HE = sumdelta / nnndelta;
2243  std::cout << "******************>>>>>> ErrA_HE: avedelta_HE = " << avedelta_HE << std::endl;
2244  if (avedelta_HE > 1.1 || (avedelta_HE < 0.5 && avedelta_HE > 0.)) {
2245  flagErrAB_HE[0] = 1;
2246  } //if
2247  } //hV.size
2248  diff->SetMarkerStyle(20);
2249  diff->SetMarkerSize(0.8);
2250  diff->SetXTitle("max difference \b");
2251  diff->SetMarkerColor(2);
2252  diff->SetLineColor(0);
2253  gPad->SetGridx();
2254  gPad->SetLogy();
2255  diff->Draw("Error");
2257  cHB->Update();
2258  cHB->Print("HistErrA_HE.png");
2259  cHB->Clear();
2261 
2262  // clean-up
2263  if (diff)
2264  delete diff;
2265  for (unsigned int i = 0; i < hV.size(); i++)
2266  delete hV[i];
2267  } // ErrorA in HE
2268 
2270 
2271  { // errors type B
2272  const int specCountB = 6;
2273  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS3", "h_2D0sumErrorBLS3"},
2274  {"h_sumErrorBperLS3", "h_sum0ErrorBperLS3"},
2275  {"h_2DsumErrorBLS4", "h_2D0sumErrorBLS4"},
2276  {"h_sumErrorBperLS4", "h_sum0ErrorBperLS4"},
2277  {"h_2DsumErrorBLS5", "h_2D0sumErrorBLS5"},
2278  {"h_sumErrorBperLS5", "h_sum0ErrorBperLS5"}};
2279 
2280  for (int depth = 1; depth <= 3; depth++) {
2281  cHB->Clear();
2282  cHB->Divide(2, 1);
2283  cHB->cd(1);
2284 
2285  TH1F *hRate2orig = NULL;
2286  TH2F *h2Cefz6 = NULL;
2287  TString hname1 = hnames[2 * depth - 2][0];
2288  TString hname0 = hnames[2 * depth - 2][1];
2289  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2290  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2291  if (1)
2292  std::cout << "debugger: errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2293  if (!twod1 || !twod0) {
2294  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2295  ptext->AddText("Missing histos");
2296  if (!twod1) {
2297  std::cout << "\tfailed to get " << hname1 << "\n";
2298  ptext->AddText(hname1);
2299  }
2300  if (!twod0) {
2301  std::cout << "\tfailed to get " << hname0 << "\n";
2302  ptext->AddText(hname0);
2303  }
2304  ptext->Draw();
2305  } else {
2306  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2307  h2Cefz6->SetTitle(Form("HE Depth %d \b", depth));
2308  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2309 
2310  gPad->SetGridy();
2311  gPad->SetGridx();
2312  gPad->SetLogz();
2313  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2314  h2Cefz6->SetMarkerStyle(20);
2315  h2Cefz6->SetMarkerSize(0.4);
2316  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2317  h2Cefz6->SetXTitle("#eta \b");
2318  h2Cefz6->SetYTitle("#phi \b");
2319  h2Cefz6->SetZTitle(Form("<ErrorB> - HE Depth%d \b", depth));
2320  h2Cefz6->SetMarkerColor(2);
2321  h2Cefz6->SetLineColor(2);
2322  h2Cefz6->Draw("COLZ");
2323 
2324  delete twod1;
2325  delete twod0;
2326  } // histos ok
2327 
2328  cHB->cd(2);
2329  hname1 = hnames[2 * depth - 1][0];
2330  hname0 = hnames[2 * depth - 1][1];
2331  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2332  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2333  if (1)
2334  std::cout << "errB_HE depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2335  if (!h1 || !h0) {
2336  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2337  ptext->AddText("Missing histo");
2338  if (!h1) {
2339  std::cout << "\tfailed to get " << hname1 << "\n";
2340  ptext->AddText(hname1);
2341  }
2342  if (!h0) {
2343  std::cout << "\tfailed to get " << hname0 << "\n";
2344  ptext->AddText(hname0);
2345  }
2346  ptext->Draw();
2347  } else {
2348  gPad->SetGridx();
2349  gPad->SetGridy();
2350  // gPad->SetLogy();
2351  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2352  hRate2orig->Divide(h1, h0, 1, 1, "B");
2353 
2354  TH1F *hRate2 = NULL;
2355  if (lastLumiBin_HE > 1) {
2356  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HE)) {
2357  std::cout << "code failed" << std::endl;
2358  gSystem->Exit(1);
2359  }
2360  } else
2361  hRate2 = hRate2orig;
2362 
2363  hRate2->SetTitle(Form("Depth %d \b", depth));
2364  hRate2->SetMarkerStyle(20);
2365  hRate2->SetMarkerSize(0.8);
2366  // hRate2->GetZaxis()->SetLabelSize(0.04);
2367  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HE depth%d - iLS \b", depth));
2368  hRate2->SetMarkerColor(2);
2369  hRate2->SetLineColor(0);
2370  hRate2->Draw("Error");
2371 
2372  if (LSofFirstErrB_HE == -1) {
2373  int nx = hRate2->GetXaxis()->GetNbins();
2374  for (int i = 1; i <= nx; i++) {
2375  double ccc1 = hRate2->GetBinContent(i);
2376  if (ccc1 > 0.) {
2377  cout << "****************>>>>>>>>>>> ErrB_HE bad LS start at iLS = " << i << " with rate = " << ccc1
2378  << endl;
2379  LSofFirstErrB_HE = i;
2380  break;
2381  }
2382  }
2383  }
2384 
2385  delete h1;
2386  delete h0;
2387  if (hRate2 != hRate2orig) {
2388  delete hRate2orig;
2389  hRate2orig = hRate2;
2390  }
2391  }
2392 
2393  cHB->Update();
2394  cHB->Print(Form("HistErrB_HE_%d.png", depth));
2395  cHB->Clear();
2396  if (h2Cefz6)
2397  delete h2Cefz6;
2398  if (hRate2orig)
2399  delete hRate2orig;
2400  }
2401  } // ErrorsB in HE
2402 
2403  //====================================================================== HO :
2404  //====================================================================== HO :
2405  //====================================================================== HO :
2406  // Special test of errors type A and B in HO
2407  // AZ 08.02.2016
2408 
2409  int flagErrAB_HO[2];
2410  flagErrAB_HO[0] = -1;
2411  flagErrAB_HO[1] = -1;
2412  double avedelta_HO = 0.;
2413  int lastLumiBin_HO = -1;
2414  int LSofFirstErrB_HO = -1;
2415  {
2416  const int specCountA = 4;
2417  const int specColors[specCountA] = {1, 2, 3, 4};
2418  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS8_P1", "h_sum0ADCAmplperLS8_P1"},
2419  {"h_sumADCAmplperLS8_P2", "h_sum0ADCAmplperLS8_P2"},
2420  {"h_sumADCAmplperLS8_M1", "h_sum0ADCAmplperLS8_M1"},
2421  {"h_sumADCAmplperLS8_M2", "h_sum0ADCAmplperLS8_M2"}};
2422 
2423  std::vector<TH1F *> hV;
2424  THStack *hs = new THStack("hs", "ADCAmplerLS1");
2425  cHB->Clear();
2426  // cHB->cd();
2427  cHB->Divide(2, 1);
2428  cHB->cd(1);
2429 
2431  for (int i = 0; i < specCountA; i++) {
2432  if (1)
2433  std::cout << "debugger: errA_HO : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2434  << "\n";
2435  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2436  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2437  if (!h1 || !h0) {
2438  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2439  ptext->AddText("Missing histo");
2440  if (!h1) {
2441  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2442  ptext->AddText(hnames[i][0]);
2443  }
2444  if (!h0) {
2445  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2446  ptext->AddText(hnames[i][1]);
2447  }
2448  ptext->Draw();
2449  continue;
2450  }
2451  TH1F *hoRT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2452  hoRT1orig->Divide(h1, h0, 1, 1, "B");
2453 
2454  if ((lastLumiBin_HO < 0) && (i == 0)) {
2455  for (int ibin = hoRT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2456  if (hoRT1orig->GetBinContent(ibin) == 0)
2457  lastLumiBin_HO = ibin;
2458  else
2459  break;
2460  }
2461  lastLumiBin_HO += 3; // show more bins
2462  if (lastLumiBin_HO >= hoRT1orig->GetNbinsX())
2463  lastLumiBin_HO = -1;
2464  }
2465  TH1F *hoRT1 = NULL;
2466  if (lastLumiBin_HO > 1) {
2467  if (!copyContents(&hoRT1, Form("ERT1_%d", i), "", hoRT1orig, lastLumiBin_HO)) {
2468  std::cout << "code failed" << std::endl;
2469  gSystem->Exit(1);
2470  }
2471  } else
2472  hoRT1 = hoRT1orig;
2473 
2474  hoRT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HO: black-P1, red-P2,green-M1,blue-M2");
2475  hV.push_back(hoRT1);
2476  hoRT1->SetMarkerStyle(20);
2477  hoRT1->SetMarkerSize(0.4);
2478  hoRT1->SetXTitle("<A>(ev.in LS & ch.) - HO P1 - iLS \b");
2479  hoRT1->SetMarkerColor(specColors[i]);
2480  hoRT1->SetLineColor(0);
2481  hs->Add(hoRT1);
2482  delete h1;
2483  delete h0;
2484  if (hoRT1 != hoRT1orig)
2485  delete hoRT1orig;
2486  }
2487  hs->Draw("LPE1 nostack");
2488  cHB->Update(); // activate tho axes
2489  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2490  hs->Draw("LPE1 nostack");
2491  gPad->SetGridy();
2493 
2494  // AZ corrections 08.02.2016
2495  cHB->cd(2);
2496  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2497 
2498  if (int(hV.size()) == specCountA) {
2499  flagErrAB_HO[0] = 0; // If we have tho expected number of histograms, set tho flag
2500  double sumdelta = 0.;
2501  int nnndelta = 0;
2502  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2503  double delta = 0.;
2504  double maxdelta = 0.;
2505  for (unsigned int i = 0; i < hV.size(); i++) {
2506  const TH1F *hi = hV[i];
2507  for (unsigned int j = 1; j < hV.size(); j++) {
2508  const TH1F *hj = hV[j];
2509  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2510  if (delta > maxdelta)
2511  maxdelta = delta;
2512  } //for
2513  } //for
2514  if (maxdelta > 0.) {
2515  diff->Fill(maxdelta);
2516  sumdelta += maxdelta;
2517  nnndelta++;
2518  }
2519  } //for ibin
2520  // avedelta_HO = sumdelta/hV[0]->GetNbinsX();
2521  avedelta_HO = sumdelta / nnndelta;
2522  std::cout << "******************>>>>>> ErrA_HO: avedelta_HO = " << avedelta_HO << std::endl;
2523  if (avedelta_HO > 0.8 || (avedelta_HO < 0.2 && avedelta_HO > 0.)) {
2524  flagErrAB_HO[0] = 1;
2525  } //if
2526  } //hV.size
2527  diff->SetMarkerStyle(20);
2528  diff->SetMarkerSize(0.8);
2529  diff->SetXTitle("max difference \b");
2530  diff->SetMarkerColor(2);
2531  diff->SetLineColor(0);
2532  gPad->SetGridx();
2533  gPad->SetLogy();
2534  diff->Draw("Error");
2536  cHB->Update();
2537  cHB->Print("HistErrA_HO.png");
2538  cHB->Clear();
2540 
2541  // clean-up
2542  if (diff)
2543  delete diff;
2544  for (unsigned int i = 0; i < hV.size(); i++)
2545  delete hV[i];
2546  } // ErrorA in HO
2547 
2549 
2550  { // errors type B
2551  const int specCountB = 2;
2552  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS8", "h_2D0sumErrorBLS8"},
2553  {"h_sumErrorBperLS8", "h_sum0ErrorBperLS8"}};
2554 
2555  for (int depth = 4; depth <= 4; depth++) {
2556  cHB->Clear();
2557  cHB->Divide(2, 1);
2558  cHB->cd(1);
2559 
2560  TH1F *hRate2orig = NULL;
2561  TH2F *h2Cefz6 = NULL;
2562  TString hname1 = hnames[2 * depth - 8][0];
2563  TString hname0 = hnames[2 * depth - 8][1];
2564  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2565  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2566  if (1)
2567  std::cout << "debugger: errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2568  if (!twod1 || !twod0) {
2569  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2570  ptext->AddText("Missing histos");
2571  if (!twod1) {
2572  std::cout << "\tfailed to get " << hname1 << "\n";
2573  ptext->AddText(hname1);
2574  }
2575  if (!twod0) {
2576  std::cout << "\tfailed to get " << hname0 << "\n";
2577  ptext->AddText(hname0);
2578  }
2579  ptext->Draw();
2580  } else {
2581  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2582  h2Cefz6->SetTitle(Form("HO Depth %d \b", depth));
2583  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2584 
2585  gPad->SetGridy();
2586  gPad->SetGridx();
2587  gPad->SetLogz();
2588  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2589  h2Cefz6->SetMarkerStyle(20);
2590  h2Cefz6->SetMarkerSize(0.4);
2591  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2592  h2Cefz6->SetXTitle("#eta \b");
2593  h2Cefz6->SetYTitle("#phi \b");
2594  h2Cefz6->SetZTitle(Form("<ErrorB> - HO Depth%d \b", depth));
2595  h2Cefz6->SetMarkerColor(2);
2596  h2Cefz6->SetLineColor(2);
2597  h2Cefz6->Draw("COLZ");
2598 
2599  delete twod1;
2600  delete twod0;
2601  } // histos ok
2602 
2603  cHB->cd(2);
2604  hname1 = hnames[2 * depth - 7][0];
2605  hname0 = hnames[2 * depth - 7][1];
2606  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2607  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2608  if (1)
2609  std::cout << "errB_HO depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2610  if (!h1 || !h0) {
2611  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2612  ptext->AddText("Missing histo");
2613  if (!h1) {
2614  std::cout << "\tfailed to get " << hname1 << "\n";
2615  ptext->AddText(hname1);
2616  }
2617  if (!h0) {
2618  std::cout << "\tfailed to get " << hname0 << "\n";
2619  ptext->AddText(hname0);
2620  }
2621  ptext->Draw();
2622  } else {
2623  gPad->SetGridx();
2624  gPad->SetGridy();
2625  // gPad->SetLogy();
2626  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2627  hRate2orig->Divide(h1, h0, 1, 1, "B");
2628 
2629  TH1F *hRate2 = NULL;
2630  if (lastLumiBin_HO > 1) {
2631  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HO)) {
2632  std::cout << "code failed" << std::endl;
2633  gSystem->Exit(1);
2634  }
2635  } else
2636  hRate2 = hRate2orig;
2637 
2638  hRate2->SetTitle(Form("Depth %d \b", depth));
2639  hRate2->SetMarkerStyle(20);
2640  hRate2->SetMarkerSize(0.8);
2641  // hRate2->GetZaxis()->SetLabelSize(0.04);
2642  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HO depth%d - iLS \b", depth));
2643  hRate2->SetMarkerColor(2);
2644  hRate2->SetLineColor(0);
2645  hRate2->Draw("Error");
2646 
2647  if (LSofFirstErrB_HO == -1) {
2648  int nx = hRate2->GetXaxis()->GetNbins();
2649  for (int i = 1; i <= nx; i++) {
2650  double ccc1 = hRate2->GetBinContent(i);
2651  if (ccc1 > 0.) {
2652  cout << "****************>>>>>>>>>>> ErrB_HO bad LS start at iLS = " << i << " with rate = " << ccc1
2653  << endl;
2654  LSofFirstErrB_HO = i;
2655  break;
2656  }
2657  }
2658  }
2659 
2660  delete h1;
2661  delete h0;
2662  if (hRate2 != hRate2orig) {
2663  delete hRate2orig;
2664  hRate2orig = hRate2;
2665  }
2666  }
2667 
2668  cHB->Update();
2669  cHB->Print(Form("HistErrB_HO_%d.png", depth));
2670  cHB->Clear();
2671  if (h2Cefz6)
2672  delete h2Cefz6;
2673  if (hRate2orig)
2674  delete hRate2orig;
2675  }
2676  } // ErrorsB in HO
2677 
2678  //====================================================================== done by Andrius for HF:
2679  //====================================================================== done by Andrius for HF:
2680  //====================================================================== done by Andrius for HF:
2681  // Special test of errors type A and B in HF
2682 
2683  int flagErrAB_HF[2];
2684  flagErrAB_HF[0] = -1;
2685  flagErrAB_HF[1] = -1;
2686  double avedelta_HF = 0.;
2687  int lastLumiBin_HF = -1;
2688  int LSofFirstErrB_HF = -1;
2689  {
2690  const int specCountA = 4;
2691  const int specColors[specCountA] = {1, 2, 3, 4};
2692  const TString hnames[specCountA][2] = {{"h_sumADCAmplperLS6_P1", "h_sum0ADCAmplperLS6_P1"},
2693  {"h_sumADCAmplperLS6_P2", "h_sum0ADCAmplperLS6_P2"},
2694  {"h_sumADCAmplperLS6_M1", "h_sum0ADCAmplperLS6_M1"},
2695  {"h_sumADCAmplperLS6_M2", "h_sum0ADCAmplperLS6_M2"}};
2696 
2697  std::vector<TH1F *> hV;
2698  THStack *hs = new THStack("hs", "ADCAmplerLS6");
2699  cHB->Clear();
2700  // cHB->cd();
2701  cHB->Divide(2, 1);
2702  cHB->cd(1);
2703 
2705  for (int i = 0; i < specCountA; i++) {
2706  if (1)
2707  std::cout << "debugger: errA_HF : get histos for i=" << i << " " << hnames[i][0] << " and " << hnames[i][1]
2708  << "\n";
2709  TH1F *h1 = (TH1F *)dir->FindObjectAny(hnames[i][0]);
2710  TH1F *h0 = (TH1F *)dir->FindObjectAny(hnames[i][1]);
2711  if (!h1 || !h0) {
2712  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2713  ptext->AddText("Missing histo");
2714  if (!h1) {
2715  std::cout << "\tfailed to get " << hnames[i][0] << "\n";
2716  ptext->AddText(hnames[i][0]);
2717  }
2718  if (!h0) {
2719  std::cout << "\tfailed to get " << hnames[i][1] << "\n";
2720  ptext->AddText(hnames[i][1]);
2721  }
2722  ptext->Draw();
2723  continue;
2724  }
2725  TH1F *hERT1orig = (TH1F *)h1->Clone(Form("ERT1orig_%d", i));
2726  hERT1orig->Divide(h1, h0, 1, 1, "B");
2727 
2728  if ((lastLumiBin_HF < 0) && (i == 0)) {
2729  for (int ibin = hERT1orig->GetNbinsX(); ibin >= 1; ibin--) {
2730  if (hERT1orig->GetBinContent(ibin) == 0)
2731  lastLumiBin_HF = ibin;
2732  else
2733  break;
2734  }
2735  lastLumiBin_HF += 3; // show more bins
2736  if (lastLumiBin_HF >= hERT1orig->GetNbinsX())
2737  lastLumiBin_HF = -1;
2738  }
2739  TH1F *hERT1 = NULL;
2740  if (lastLumiBin_HF > 1) {
2741  if (!copyContents(&hERT1, Form("ERT1_%d", i), "", hERT1orig, lastLumiBin_HF)) {
2742  std::cout << "code failed" << std::endl;
2743  gSystem->Exit(1);
2744  }
2745  } else
2746  hERT1 = hERT1orig;
2747 
2748  hERT1->GetXaxis()->SetTitle("<ADCAmpl> per LS HF: black-P1, red-P2,green-M1,blue-M2");
2749  hV.push_back(hERT1);
2750  hERT1->SetMarkerStyle(20);
2751  hERT1->SetMarkerSize(0.4);
2752  hERT1->SetXTitle("<A>(ev.in LS & ch.) - HF P1 - iLS \b");
2753  hERT1->SetMarkerColor(specColors[i]);
2754  hERT1->SetLineColor(0);
2755  hs->Add(hERT1);
2756  delete h1;
2757  delete h0;
2758  if (hERT1 != hERT1orig)
2759  delete hERT1orig;
2760  }
2761  hs->Draw("LPE1 nostack");
2762  cHB->Update(); // activate the axes
2763  hs->GetXaxis()->SetTitle("<A> per LS: black-P1, red-P2,green-M1,blue-M2");
2764  hs->Draw("LPE1 nostack");
2765  gPad->SetGridy();
2767 
2768  // AZ corrections 04.02.2016
2769  cHB->cd(2);
2770  TH1F *diff = new TH1F("diff", "", 100, 0., 4.);
2771 
2772  if (int(hV.size()) == specCountA) {
2773  flagErrAB_HF[0] = 0; // If we have the expected number of histograms, set the flag
2774  double sumdelta = 0.;
2775  int nnndelta = 0;
2776  std::cout << "******** GetNbinsX = " << hV[0]->GetNbinsX() << std::endl;
2777  for (int ibin = 1; ibin <= hV[0]->GetNbinsX(); ibin++) {
2778  double delta = 0.;
2779  double maxdelta = 0.;
2780  for (unsigned int i = 0; i < hV.size(); i++) {
2781  const TH1F *hi = hV[i];
2782  for (unsigned int j = 1; j < hV.size(); j++) {
2783  const TH1F *hj = hV[j];
2784  delta = fabs(hi->GetBinContent(ibin) - hj->GetBinContent(ibin));
2785  if (delta > maxdelta)
2786  maxdelta = delta;
2787  } //for
2788  } //for
2789  // std::cout << "***** ibin = " << ibin << " nnndelta= " << nnndelta << " maxdelta= " << maxdelta <<std::endl;
2790  if (maxdelta > 0.) {
2791  diff->Fill(maxdelta);
2792  sumdelta += maxdelta;
2793  nnndelta++;
2794  }
2795  } //for ibin
2796  // avedelta_HF = sumdelta/hV[0]->GetNbinsX();
2797  avedelta_HF = sumdelta / nnndelta;
2798  // std::cout << "******************>>>>>> ErrA_HF: avedelta_HF = " << avedelta_HF << " Npoints for comparison= " << nnndelta <<std::endl;
2799  if (avedelta_HF > 2.4 || (avedelta_HF < 0.8 && avedelta_HF > 0.)) {
2800  flagErrAB_HF[0] = 1;
2801  } //if
2802  } //hV.size
2803  diff->SetMarkerStyle(20);
2804  diff->SetMarkerSize(0.8);
2805  diff->SetXTitle("max difference \b");
2806  diff->SetMarkerColor(2);
2807  diff->SetLineColor(0);
2808  gPad->SetGridx();
2809  gPad->SetLogy();
2810  diff->Draw("Error");
2812  cHB->Update();
2813  cHB->Print("HistErrA_HF.png");
2814  cHB->Clear();
2816  // clean-up
2817  if (diff)
2818  delete diff;
2819  for (unsigned int i = 0; i < hV.size(); i++)
2820  delete hV[i];
2821  } // ErrorA in HF
2824  { // errors type B
2825  const int specCountB = 4;
2826  const TString hnames[specCountB][2] = {{"h_2DsumErrorBLS6", "h_2D0sumErrorBLS6"},
2827  {"h_sumErrorBperLS6", "h_sum0ErrorBperLS6"},
2828  {"h_2DsumErrorBLS7", "h_2D0sumErrorBLS7"},
2829  {"h_sumErrorBperLS7", "h_sum0ErrorBperLS7"}};
2830 
2831  for (int depth = 1; depth <= 2; depth++) {
2832  cHB->Clear();
2833  cHB->Divide(2, 1);
2834  cHB->cd(1);
2835  TH1F *hRate2orig = NULL;
2836  TH2F *h2Cefz6 = NULL;
2837  TString hname1 = hnames[2 * depth - 2][0];
2838  TString hname0 = hnames[2 * depth - 2][1];
2839  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2840  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2841  if (1)
2842  std::cout << "debugger: errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2843  if (!twod1 || !twod0) {
2844  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2845  ptext->AddText("Missing histos");
2846  if (!twod1) {
2847  std::cout << "\tfailed to get " << hname1 << "\n";
2848  ptext->AddText(hname1);
2849  }
2850  if (!twod0) {
2851  std::cout << "\tfailed to get " << hname0 << "\n";
2852  ptext->AddText(hname0);
2853  }
2854  ptext->Draw();
2855  } else {
2856  h2Cefz6 = (TH2F *)twod1->Clone(Form("Cefz6_%d", depth));
2857  h2Cefz6->SetTitle(Form("HF Depth %d \b", depth));
2858  h2Cefz6->Divide(twod1, twod0, 1, 1, "B");
2859 
2860  gPad->SetGridy();
2861  gPad->SetGridx();
2862  gPad->SetLogz();
2863  h2Cefz6->SetTitle(Form("Depth %d \b", depth));
2864  h2Cefz6->SetMarkerStyle(20);
2865  h2Cefz6->SetMarkerSize(0.4);
2866  // h2Cefz6->GetZaxis()->SetLabelSize(0.04);
2867  h2Cefz6->SetXTitle("#eta \b");
2868  h2Cefz6->SetYTitle("#phi \b");
2869  h2Cefz6->SetZTitle(Form("<ErrorB> - HF Depth%d \b", depth));
2870  h2Cefz6->SetMarkerColor(2);
2871  h2Cefz6->SetLineColor(2);
2872  h2Cefz6->Draw("COLZ");
2873  delete twod1;
2874  delete twod0;
2875  } // histos ok
2876  cHB->cd(2);
2877  hname1 = hnames[2 * depth - 1][0];
2878  hname0 = hnames[2 * depth - 1][1];
2879  TH1F *h1 = (TH1F *)dir->FindObjectAny(hname1);
2880  TH1F *h0 = (TH1F *)dir->FindObjectAny(hname0);
2881  if (1)
2882  std::cout << "errB_HF depth=" << depth << ". get 2D histos " << hname1 << " and " << hname0 << "\n";
2883  if (!h1 || !h0) {
2884  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2885  ptext->AddText("Missing histo");
2886  if (!h1) {
2887  std::cout << "\tfailed to get " << hname1 << "\n";
2888  ptext->AddText(hname1);
2889  }
2890  if (!h0) {
2891  std::cout << "\tfailed to get " << hname0 << "\n";
2892  ptext->AddText(hname0);
2893  }
2894  ptext->Draw();
2895  } else {
2896  gPad->SetGridx();
2897  gPad->SetGridy();
2898  // gPad->SetLogy();
2899  hRate2orig = (TH1F *)h1->Clone(Form("Rate2orig_%d", depth));
2900  hRate2orig->Divide(h1, h0, 1, 1, "B");
2901 
2902  TH1F *hRate2 = NULL;
2903  if (lastLumiBin_HF > 1) {
2904  if (!copyContents(&hRate2, Form("Rate2_%d", depth), "", hRate2orig, lastLumiBin_HF)) {
2905  std::cout << "code failed" << std::endl;
2906  gSystem->Exit(1);
2907  }
2908  } else
2909  hRate2 = hRate2orig;
2910  hRate2->SetTitle(Form("Depth %d \b", depth));
2911  hRate2->SetMarkerStyle(20);
2912  hRate2->SetMarkerSize(0.8);
2913  // hRate2->GetZaxis()->SetLabelSize(0.04);
2914  hRate2->SetXTitle(Form("<ErrorB>(ev.in LS & ch.) - HF depth%d - iLS \b", depth));
2915  hRate2->SetMarkerColor(2);
2916  hRate2->SetLineColor(0);
2917  hRate2->Draw("Error");
2918  if (LSofFirstErrB_HF == -1) {
2919  int nx = hRate2->GetXaxis()->GetNbins();
2920  for (int i = 1; i <= nx; i++) {
2921  double ccc1 = hRate2->GetBinContent(i);
2922  if (ccc1 > 0.) {
2923  cout << "****************>>>>>>>>>>> ErrB_HF bad LS start at iLS = " << i << " with rate = " << ccc1
2924  << endl;
2925  LSofFirstErrB_HF = i;
2926  break;
2927  }
2928  }
2929  }
2930  delete h1;
2931  delete h0;
2932  if (hRate2 != hRate2orig) {
2933  delete hRate2orig;
2934  hRate2orig = hRate2;
2935  }
2936  }
2937  cHB->Update();
2938  cHB->Print(Form("HistErrB_HF_%d.png", depth));
2939  cHB->Clear();
2940  if (h2Cefz6)
2941  delete h2Cefz6;
2942  if (hRate2orig)
2943  delete hRate2orig;
2944  }
2945  } // ErrorsB in HF
2946 
2948 
2949  //=============================================================================== err A HB
2951  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HBx.png
2952 
2953  for (int depth = 1; depth <= 2; depth++) {
2954  TH2F *h2Ceff = NULL;
2955  TH2F *h2Diffe = NULL;
2956  // TH1F* h1diffADCAmpl= NULL;
2957  TH2F *h3Ceff = NULL;
2958 
2959  cHE->Clear();
2960  cHE->Divide(3, 1);
2961 
2962  cHE->cd(1);
2963  // h_mapDepth1ADCAmpl_HB div h_mapDepth1_HB
2964  TString hname1 = Form("h_mapDepth%dADCAmpl_HB", depth);
2965  TString hname0 = Form("h_mapDepth%d_HB", depth);
2966  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
2967  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
2968  if (!twod1 || !twod0) {
2969  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
2970  ptext->AddText("Missing histo");
2971  std::cout << "specHB test: failed to load " << hname1 << " and/or " << hname0 << "\n";
2972  if (!twod1)
2973  ptext->AddText(hname1);
2974  if (!twod0)
2975  ptext->AddText(hname0);
2976  ptext->Draw();
2977  continue;
2978  } else {
2979  // To IDENTIFY: see color different bins in eta-phi space
2980  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HB%d", depth));
2981  h2Ceff->SetTitle(Form("HB Depth %d. (No cut) \b", depth));
2982  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
2983 
2984  gPad->SetGridy();
2985  gPad->SetGridx();
2986  gPad->SetLogz();
2987  h2Ceff->SetMarkerStyle(20);
2988  h2Ceff->SetMarkerSize(0.4);
2989  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
2990  h2Ceff->SetXTitle("#eta \b");
2991  h2Ceff->SetYTitle("#phi \b");
2992  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HB \b");
2993  h2Ceff->SetMarkerColor(2);
2994  h2Ceff->SetLineColor(2);
2995  h2Ceff->Draw("COLZ");
2996  }
2997 
2998  cHE->cd(2);
3000  if (h2Ceff) {
3001  // TO IDENTIFY: see red bins in eta-phi space
3002  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HB", depth));
3003  h2Diffe->SetTitle(Form("HB Depth %d. Cut avg(ADCAmpl) > 25 \b", depth));
3004  int nx = h2Ceff->GetXaxis()->GetNbins();
3005  int ny = h2Ceff->GetYaxis()->GetNbins();
3006  for (int i = 1; i <= nx; i++) {
3007  for (int j = 1; j <= ny; j++) {
3008  double ccc1 = h2Ceff->GetBinContent(i, j);
3009  h2Diffe->SetBinContent(i, j, 0.);
3010  if (ccc1 > 25.)
3011  h2Diffe->SetBinContent(i, j, ccc1);
3012  }
3013  }
3014  gPad->SetGridy();
3015  gPad->SetGridx();
3016  gPad->SetLogz();
3017  h2Diffe->SetMarkerStyle(20);
3018  h2Diffe->SetMarkerSize(0.4);
3019  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3020  h2Diffe->SetXTitle("#eta \b");
3021  h2Diffe->SetYTitle("#phi \b");
3022  h2Diffe->SetZTitle("<ADCAmpl> bigger 25.- HB Depth1 \b");
3023  h2Diffe->SetMarkerColor(2);
3024  h2Diffe->SetLineColor(2);
3025  h2Diffe->Draw("COLZ");
3026  }
3027 
3028  cHE->cd(3);
3029  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HB", depth);
3030  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3031  if (!twod3 || !twod0) {
3032  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3033  ptext->AddText("Missing histo");
3034  std::cout << "specHB test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3035  if (!twod3)
3036  ptext->AddText(hname3);
3037  if (!twod0)
3038  ptext->AddText(hname0);
3039  ptext->Draw();
3040  continue;
3041  } else {
3042  // To IDENTIFY: see color different bins in eta-phi space
3043  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HB%d", depth));
3044  h3Ceff->SetTitle(Form("HB Depth %d. \b", depth));
3045  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3046  gPad->SetGridy();
3047  gPad->SetGridx();
3048  gPad->SetLogz();
3049  h3Ceff->SetMarkerStyle(20);
3050  h3Ceff->SetMarkerSize(0.4);
3051  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3052  h3Ceff->SetXTitle("#eta \b");
3053  h3Ceff->SetYTitle("#phi \b");
3054  h3Ceff->SetZTitle("rate for channels of HB \b");
3055  h3Ceff->SetMarkerColor(2);
3056  h3Ceff->SetLineColor(2);
3057  h3Ceff->Draw("COLZ");
3058  }
3059 
3060  cHE->Update();
3061  cHE->Print(Form("ChkErrA_HB%d.png", depth));
3062  cHE->Clear();
3063 
3064  if (h2Ceff)
3065  delete h2Ceff;
3066  if (h2Diffe)
3067  delete h2Diffe;
3068  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3069  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3070  if (twod1)
3071  delete twod1;
3072  if (twod3)
3073  delete twod3;
3074  if (h3Ceff)
3075  delete h3Ceff;
3076  } // depth
3077 
3078  //=============================================================================== err A HE
3080  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HEx.png
3081 
3082  for (int depth = 1; depth <= 3; depth++) {
3083  TH2F *h2Ceff = NULL;
3084  TH2F *h2Diffe = NULL;
3085  // TH1F* h1diffADCAmpl= NULL;
3086  TH2F *h3Ceff = NULL;
3087 
3088  cHE->Clear();
3089  cHE->Divide(3, 1);
3090 
3091  cHE->cd(1);
3092  // h_mapDepth1ADCAmpl_HE div h_mapDepth1_HE
3093  TString hname1 = Form("h_mapDepth%dADCAmpl_HE", depth);
3094  TString hname0 = Form("h_mapDepth%d_HE", depth);
3095  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3096  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3097  if (!twod1 || !twod0) {
3098  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3099  ptext->AddText("Missing histo");
3100  std::cout << "specHE test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3101  if (!twod1)
3102  ptext->AddText(hname1);
3103  if (!twod0)
3104  ptext->AddText(hname0);
3105  ptext->Draw();
3106  continue;
3107  } else {
3108  // To IDENTIFY: see color different bins in eta-phi space
3109  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HE%d", depth));
3110  h2Ceff->SetTitle(Form("HE Depth %d. (No cut) \b", depth));
3111  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3112 
3113  gPad->SetGridy();
3114  gPad->SetGridx();
3115  gPad->SetLogz();
3116  h2Ceff->SetTitleOffset(0.75, "Z");
3117  h2Ceff->SetMarkerStyle(20);
3118  h2Ceff->SetMarkerSize(0.4);
3119  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3120  h2Ceff->SetXTitle("#eta \b");
3121  h2Ceff->SetYTitle("#phi \b");
3122  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HE \b");
3123  h2Ceff->SetMarkerColor(2);
3124  h2Ceff->SetLineColor(2);
3125  h2Ceff->Draw("COLZ");
3126  }
3127 
3128  cHE->cd(2);
3130  if (h2Ceff) {
3131  // TO IDENTIFY: see red bins in eta-phi space
3132  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HE", depth));
3133  h2Diffe->SetTitle(Form("HE Depth %d. Cut avg(ADCAmpl) > 1000 fC \b", depth));
3134  int nx = h2Ceff->GetXaxis()->GetNbins();
3135  int ny = h2Ceff->GetYaxis()->GetNbins();
3136  for (int i = 1; i <= nx; i++) {
3137  for (int j = 1; j <= ny; j++) {
3138  double ccc1 = h2Ceff->GetBinContent(i, j);
3139  h2Diffe->SetBinContent(i, j, 0.);
3140  if (ccc1 > 1000.)
3141  h2Diffe->SetBinContent(i, j, ccc1);
3142  }
3143  }
3144  gPad->SetGridy();
3145  gPad->SetGridx();
3146  gPad->SetLogz();
3147  h2Diffe->SetMarkerStyle(20);
3148  h2Diffe->SetMarkerSize(0.4);
3149  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3150  h2Diffe->SetXTitle("#eta \b");
3151  h2Diffe->SetYTitle("#phi \b");
3152  h2Diffe->SetZTitle("<ADCAmpl> bigger 1000.fC - HE Depth1 \b");
3153  h2Diffe->SetMarkerColor(2);
3154  h2Diffe->SetLineColor(2);
3155  h2Diffe->Draw("COLZ");
3156  }
3157 
3158  cHE->cd(3);
3159  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HE", depth);
3160  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3161  if (!twod3 || !twod0) {
3162  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3163  ptext->AddText("Missing histo");
3164  std::cout << "specHE test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3165  if (!twod3)
3166  ptext->AddText(hname3);
3167  if (!twod0)
3168  ptext->AddText(hname0);
3169  ptext->Draw();
3170  continue;
3171  } else {
3172  // To IDENTIFY: see color different bins in eta-phi space
3173  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HE%d", depth));
3174  h3Ceff->SetTitle(Form("HE Depth %d. \b", depth));
3175  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3176  gPad->SetGridy();
3177  gPad->SetGridx();
3178  gPad->SetLogz();
3179  h3Ceff->SetMarkerStyle(20);
3180  h3Ceff->SetMarkerSize(0.4);
3181  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3182  h3Ceff->SetXTitle("#eta \b");
3183  h3Ceff->SetYTitle("#phi \b");
3184  h3Ceff->SetZTitle("rate for channels of HE \b");
3185  h3Ceff->SetMarkerColor(2);
3186  h3Ceff->SetLineColor(2);
3187  h3Ceff->Draw("COLZ");
3188  }
3189 
3190  cHE->Update();
3191  cHE->Print(Form("ChkErrA_HE%d.png", depth));
3192  cHE->Clear();
3193 
3194  if (h2Ceff)
3195  delete h2Ceff;
3196  if (h2Diffe)
3197  delete h2Diffe;
3198  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3199  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3200  if (twod1)
3201  delete twod1;
3202  if (twod3)
3203  delete twod3;
3204  if (h3Ceff)
3205  delete h3Ceff;
3206  } // depth
3207 
3208  //=============================================================================== err A HO
3210  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HOx.png
3211 
3212  for (int depth = 4; depth <= 4; depth++) {
3213  TH2F *h2Ceff = NULL;
3214  TH2F *h2Diffe = NULL;
3215  // TH1F* h1diffADCAmpl= NULL;
3216  TH2F *h3Ceff = NULL;
3217 
3218  cHE->Clear();
3219  cHE->Divide(3, 1);
3220 
3221  cHE->cd(1);
3222  // h_mapDepth1ADCAmpl_HO div h_mapDepth1_HO
3223  TString hname1 = Form("h_mapDepth%dADCAmpl_HO", depth);
3224  TString hname0 = Form("h_mapDepth%d_HO", depth);
3225  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3226  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3227  if (!twod1 || !twod0) {
3228  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3229  ptext->AddText("Missing histo");
3230  std::cout << "specHO test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3231  if (!twod1)
3232  ptext->AddText(hname1);
3233  if (!twod0)
3234  ptext->AddText(hname0);
3235  ptext->Draw();
3236  continue;
3237  } else {
3238  // To IDENTIFY: see color different bins in eta-phi space
3239  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HO%d", depth));
3240  h2Ceff->SetTitle(Form("HO Depth %d. (No cut) \b", depth));
3241  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3242 
3243  gPad->SetGridy();
3244  gPad->SetGridx();
3245  gPad->SetLogz();
3246  h2Ceff->SetMarkerStyle(20);
3247  h2Ceff->SetMarkerSize(0.4);
3248  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3249  h2Ceff->SetXTitle("#eta \b");
3250  h2Ceff->SetYTitle("#phi \b");
3251  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HO \b");
3252  h2Ceff->SetMarkerColor(2);
3253  h2Ceff->SetLineColor(2);
3254  h2Ceff->Draw("COLZ");
3255  }
3256 
3257  cHE->cd(2);
3259  if (h2Ceff) {
3260  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3261  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HO", depth));
3262  h2Diffe->SetTitle(Form("HO Depth %d. Cut avg(ADCAmpl) > 80 \b", depth));
3263  int nx = h2Ceff->GetXaxis()->GetNbins();
3264  int ny = h2Ceff->GetYaxis()->GetNbins();
3265  for (int i = 1; i <= nx; i++) {
3266  for (int j = 1; j <= ny; j++) {
3267  double ccc1 = h2Ceff->GetBinContent(i, j);
3268  h2Diffe->SetBinContent(i, j, 0.);
3269  if (ccc1 > 20.)
3270  h2Diffe->SetBinContent(i, j, ccc1);
3271  }
3272  }
3273  gPad->SetGridy();
3274  gPad->SetGridx();
3275  gPad->SetLogz();
3276  h2Diffe->SetMarkerStyle(20);
3277  h2Diffe->SetMarkerSize(0.4);
3278  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3279  h2Diffe->SetXTitle("#eta \b");
3280  h2Diffe->SetYTitle("#phi \b");
3281  h2Diffe->SetZTitle("<ADCAmpl> bigger 80.- HO Depth1 \b");
3282  h2Diffe->SetMarkerColor(2);
3283  h2Diffe->SetLineColor(2);
3284  h2Diffe->Draw("COLZ");
3285  }
3286 
3287  cHE->cd(3);
3288  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HO", depth);
3289  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3290  if (!twod3 || !twod0) {
3291  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3292  ptext->AddText("Missing histo");
3293  std::cout << "specHO test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3294  if (!twod3)
3295  ptext->AddText(hname3);
3296  if (!twod0)
3297  ptext->AddText(hname0);
3298  ptext->Draw();
3299  continue;
3300  } else {
3301  // To IDENTIFY: see color different bins in eta-phi space
3302  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HO%d", depth));
3303  h3Ceff->SetTitle(Form("HO Depth %d. \b", depth));
3304  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3305  gPad->SetGridy();
3306  gPad->SetGridx();
3307  gPad->SetLogz();
3308  h3Ceff->SetMarkerStyle(20);
3309  h3Ceff->SetMarkerSize(0.4);
3310  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3311  h3Ceff->SetXTitle("#eta \b");
3312  h3Ceff->SetYTitle("#phi \b");
3313  h3Ceff->SetZTitle("rate for channels of HO \b");
3314  h3Ceff->SetMarkerColor(2);
3315  h3Ceff->SetLineColor(2);
3316  h3Ceff->Draw("COLZ");
3317  }
3318 
3319  cHE->Update();
3320  cHE->Print(Form("ChkErrA_HO%d.png", depth));
3321  cHE->Clear();
3322 
3323  if (h2Ceff)
3324  delete h2Ceff;
3325  if (h2Diffe)
3326  delete h2Diffe;
3327  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3328  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3329  if (twod1)
3330  delete twod1;
3331  if (twod3)
3332  delete twod3;
3333  if (h3Ceff)
3334  delete h3Ceff;
3335  } // depth
3336 
3337  //=============================================================================== err A HF
3339  // For 2D and 1D plots with Amplitude. Produces ChkErrA_HFx.png
3340 
3341  for (int depth = 1; depth <= 2; depth++) {
3342  TH2F *h2Ceff = NULL;
3343  TH2F *h2Diffe = NULL;
3344  // TH1F* h1diffADCAmpl= NULL;
3345  TH2F *h3Ceff = NULL;
3346 
3347  cHE->Clear();
3348  cHE->Divide(3, 1);
3349 
3350  cHE->cd(1);
3351  // h_mapDepth1ADCAmpl_HF div h_mapDepth1_HF
3352  TString hname1 = Form("h_mapDepth%dADCAmpl_HF", depth);
3353  TString hname0 = Form("h_mapDepth%d_HF", depth);
3354  TH2F *twod1 = (TH2F *)dir->FindObjectAny(hname1);
3355  TH2F *twod0 = (TH2F *)dir->FindObjectAny(hname0);
3356  if (!twod1 || !twod0) {
3357  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3358  ptext->AddText("Missing histo");
3359  std::cout << "specHF test: failed to load " << hname1 << " and/or " << hname0 << "\n";
3360  if (!twod1)
3361  ptext->AddText(hname1);
3362  if (!twod0)
3363  ptext->AddText(hname0);
3364  ptext->Draw();
3365  continue;
3366  } else {
3367  // To IDENTIFY: see color different bins in eta-phi space
3368  h2Ceff = (TH2F *)twod1->Clone(Form("Ceff_HF%d", depth));
3369  h2Ceff->SetTitle(Form("HF Depth %d. (No cut) \b", depth));
3370  h2Ceff->Divide(twod1, twod0, 1, 1, "B");
3371 
3372  gPad->SetGridy();
3373  gPad->SetGridx();
3374  gPad->SetLogz();
3375  h2Ceff->SetMarkerStyle(20);
3376  h2Ceff->SetMarkerSize(0.4);
3377  //h2Ceff->GetZaxis()->SetLabelSize(0.08);
3378  h2Ceff->SetXTitle("#eta \b");
3379  h2Ceff->SetYTitle("#phi \b");
3380  h2Ceff->SetZTitle("h_mapDepth1ADCAmpl_HF \b");
3381  h2Ceff->SetMarkerColor(2);
3382  h2Ceff->SetLineColor(2);
3383  h2Ceff->Draw("COLZ");
3384  }
3385 
3386  cHE->cd(2);
3388  if (h2Ceff) {
3389  // TO IDENTIFY: see red bins in eta-phi space (applied cut on Aij: <20 || >3000
3390  h2Diffe = (TH2F *)h2Ceff->Clone(Form("Diffe_Depth%d_HF", depth));
3391  h2Diffe->SetTitle(Form("HF Depth %d. Cut avg(ADCAmpl) > 20 \b", depth));
3392  int nx = h2Ceff->GetXaxis()->GetNbins();
3393  int ny = h2Ceff->GetYaxis()->GetNbins();
3394  for (int i = 1; i <= nx; i++) {
3395  for (int j = 1; j <= ny; j++) {
3396  double ccc1 = h2Ceff->GetBinContent(i, j);
3397  h2Diffe->SetBinContent(i, j, 0.);
3398  if (ccc1 > 20.)
3399  h2Diffe->SetBinContent(i, j, ccc1);
3400  }
3401  }
3402  gPad->SetGridy();
3403  gPad->SetGridx();
3404  gPad->SetLogz();
3405  h2Diffe->SetMarkerStyle(20);
3406  h2Diffe->SetMarkerSize(0.4);
3407  //h2Diffe->GetZaxis()->SetLabelSize(0.08);
3408  h2Diffe->SetXTitle("#eta \b");
3409  h2Diffe->SetYTitle("#phi \b");
3410  h2Diffe->SetZTitle("<ADCAmpl> bigger 20.- HF Depth1 \b");
3411  h2Diffe->SetMarkerColor(2);
3412  h2Diffe->SetLineColor(2);
3413  h2Diffe->Draw("COLZ");
3414  }
3415 
3416  cHE->cd(3);
3417  /*
3418  if (h2Ceff) {
3419  h1diffADCAmpl = new TH1F(Form("diffADCAmpl_Depth%d_HF",depth),"",
3420  100, -20.,200.);
3421  h1diffADCAmpl->SetTitle(Form("HF Depth %d \b",depth));
3422  int nx = h2Ceff->GetXaxis()->GetNbins();
3423  int ny = h2Ceff->GetYaxis()->GetNbins();
3424  for (int i=1;i<=nx;i++) {
3425  for (int j=1;j<=ny;j++) {
3426  if(h2Ceff->GetBinContent(i,j) !=0 ) {
3427  double ccc1 = h2Ceff->GetBinContent(i,j) ;
3428  h1diffADCAmpl->Fill(ccc1);
3429  }
3430  }
3431  }
3432  gPad->SetLogy();
3433  h1diffADCAmpl->SetMarkerStyle(20);
3434  h1diffADCAmpl->SetMarkerSize(0.4);
3435  h1diffADCAmpl->GetYaxis()->SetLabelSize(0.04);
3436  h1diffADCAmpl->SetXTitle("<ADCAmpl> in each cell \b");
3437  h1diffADCAmpl->SetMarkerColor(2);
3438  h1diffADCAmpl->SetLineColor(2);
3439  h1diffADCAmpl->Draw("");
3440  }
3441  */
3442  TString hname3 = Form("h_mapDepth%dADCAmpl225Copy_HF", depth);
3443  TH2F *twod3 = (TH2F *)dir->FindObjectAny(hname3);
3444  if (!twod3 || !twod0) {
3445  TPaveText *ptext = new TPaveText(0.05, 0.85, 0.95, 0.95);
3446  ptext->AddText("Missing histo");
3447  std::cout << "specHF test: failed to load " << hname3 << " and/or " << hname0 << "\n";
3448  if (!twod3)
3449  ptext->AddText(hname3);
3450  if (!twod0)
3451  ptext->AddText(hname0);
3452  ptext->Draw();
3453  continue;
3454  } else {
3455  // To IDENTIFY: see color different bins in eta-phi space
3456  h3Ceff = (TH2F *)twod3->Clone(Form("CeffA_HF%d", depth));
3457  h3Ceff->SetTitle(Form("HF Depth %d. \b", depth));
3458  h3Ceff->Divide(twod3, twod0, 1, 1, "B");
3459  gPad->SetGridy();
3460  gPad->SetGridx();
3461  gPad->SetLogz();
3462  h3Ceff->SetMarkerStyle(20);
3463  h3Ceff->SetMarkerSize(0.4);
3464  // h3Ceff->GetZaxis()->SetLabelSize(0.08);
3465  h3Ceff->SetXTitle("#eta \b");
3466  h3Ceff->SetYTitle("#phi \b");
3467  h3Ceff->SetZTitle("rate for channels of HF \b");
3468  h3Ceff->SetMarkerColor(2);
3469  h3Ceff->SetLineColor(2);
3470  h3Ceff->Draw("COLZ");
3471  }
3472 
3473  cHE->Update();
3474  cHE->Print(Form("ChkErrA_HF%d.png", depth));
3475  cHE->Clear();
3476 
3477  if (h2Ceff)
3478  delete h2Ceff;
3479  if (h2Diffe)
3480  delete h2Diffe;
3481  // if (h1diffADCAmpl) delete h1diffADCAmpl;
3482  // if (twod0) delete twod0;// do not delete - sometimes causes trouble later
3483  if (twod1)
3484  delete twod1;
3485  if (twod3)
3486  delete twod3;
3487  if (h3Ceff)
3488  delete h3Ceff;
3489  } // depth
3490 
3491  std::cout << "************>>> average Amplitudes done" << std::endl;
3492 
3493  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3494  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3495  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3496  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3497  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3498 
3503 
3504  cout << " RBX analysis START for **************************" << endl;
3505  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3506  // int njeta = 22; int njphi = 18; int lsmax=2600;
3507  int njeta = 22;
3508  int njphi = 18;
3509  int lsmax = 1800;
3510  cout << ">>>>>>>>>>>>>>>>>>>>>>>> int njeta = 22; int njphi = 18; int lsmax=1800; "
3511  << endl;
3512 
3513  double alexall[njeta][njphi][lsmax];
3514 
3515  // for phi tables(!):
3516  double alexhb[njphi][lsmax];
3517  double alexhe[njphi][lsmax];
3518  double alexho[njphi][lsmax];
3519  double alexhf[njphi][lsmax];
3520 
3521  // for eta tables(!):
3522  double blexhb[njeta][lsmax];
3523  double blexhe[njeta][lsmax];
3524  double blexho[njeta][lsmax];
3525  double blexhf[njeta][lsmax];
3526 
3527  cout << ">>>>>>>>>>>>>>>>>>>>>>>> alexall [njeta][njphi][lsmax]; " << endl;
3528  int maxbinsRBX = MaxLum;
3529  int nx = maxbinsRBX; // # LS
3530  cout << ">>>>>>>>>>>>>>>>>>>>>>>> maxbinsRBX = MaxLum; " << endl;
3531  if (MaxLum > lsmax)
3532  cout << "*********************************** ERROR ERROR ERROR ERROR: MaxLum > 1800 " << endl;
3533  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
3534 
3535  for (int i = 0; i < nx; i++) {
3536  for (int jphi = 0; jphi < njphi; jphi++) {
3537  alexhb[jphi][i] = 0.;
3538  alexhe[jphi][i] = 0.;
3539  alexho[jphi][i] = 0.;
3540  alexhf[jphi][i] = 0.;
3541 
3542  for (int jeta = 0; jeta < njeta; jeta++) {
3543  if (jphi == 0) {
3544  blexhb[jeta][i] = 0.;
3545  blexhe[jeta][i] = 0.;
3546  blexho[jeta][i] = 0.;
3547  blexhf[jeta][i] = 0.;
3548  }
3549 
3550  alexall[jeta][jphi][i] = 0.;
3551  }
3552  }
3553  }
3554 
3556  /*
3557  // j = ietaphi = 1- 396
3558  int ietaphimax = 396;
3559  int ny = ietaphimax + 1 ;
3560  for (int j=1;j<ny;j++) {
3561  int jeta = (j-1)/znphi;
3562  int jphi = (j-1)-znphi*jeta+1;// jphi=1-18
3563  jeta += 1;// jeta = 1-22 }
3564 // Outout is jeta = 1-22 jphi=1-18
3565 HB: j = 7,8,9,10 11,12,13,14
3566 HE: j = 3,4,5, 6, 7 14,15,16,17,18
3567 HO: j = 7,8,9,10 11,12,13,14
3568 HF: j = 0,1,2, 3 18,19,20,21
3569 */
3570 
3572  //======================================================================
3573  //======================================================================
3574  //======================================================================
3575  cout << " RBX general for HB **************************" << endl;
3576  TH2F *Ghb1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs0");
3577  TH2F *Ghb1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs00");
3578  TH2F *Ghb1 = (TH2F *)Ghb1LLL->Clone("Ghb1");
3579  Ghb1->Divide(Ghb1KKK, Ghb1LLL, 1, 1, "B"); // average A
3580  // Ghb1->Sumw2();
3581  // int nx = Ghb1->GetXaxis()->GetNbins(); // # LS
3582  int ny = Ghb1->GetYaxis()->GetNbins(); // # jetaphi indexes = 396 = 18*22
3583  // cout<<"***************************************** HB 54 ny= "<< ny <<endl;
3584  for (int j = 1; j <= ny; j++) {
3585  int jeta = (j - 1) / njphi; // jeta = 0-21
3586  if (jeta > 6 && jeta < 15) {
3587  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
3588  // cout<<"HB 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
3589  // over LS:
3590  for (int i = 1; i <= nx; i++) {
3591  double ccc1 = Ghb1->GetBinContent(i, j);
3592  alexall[jeta][jphi][i - 1] = ccc1;
3593  // if( i == 1 ) cout<<"HB 54 for LS=1 ccc1= "<< ccc1 <<endl;
3594  // if( ccc1 <= 0 ) cout<<"HB 54 ccc1= "<< ccc1 <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3595  // cout<<"HB 54 ccc1= "<< ccc1 <<" j= "<< j <<" iLS= "<< i <<" eta= "<< jeta <<" phi= "<< jphi <<endl;
3596  } //i
3597  } //if
3598  } //j
3599  // clean-up
3600  if (Ghb1KKK)
3601  delete Ghb1KKK;
3602  if (Ghb1LLL)
3603  delete Ghb1LLL;
3604  // if (Ghb1) delete Ghb1;
3605 
3606  //====================================================================== alexhb[k][i]
3607  for (int jphi = 0; jphi < njphi; jphi++) {
3608  for (int i = 0; i < nx; i++) {
3609  double sumccc1 = 0.;
3610  int isum = 0;
3611  for (int jeta = 0; jeta < njeta; jeta++) {
3612  double ccc1 = alexall[jeta][jphi][i];
3613  if (ccc1 > 0.) {
3614  sumccc1 += ccc1;
3615  isum++;
3616  }
3617  } // for jeta
3618  if (isum > 0.)
3619  sumccc1 /= isum;
3620  alexhb[jphi][i] = sumccc1;
3621  }
3622  } //for for
3623 
3624  //====================================================================== blexhb[k][i]
3625  for (int keta = 0; keta < njeta; keta++) {
3626  for (int i = 0; i < nx; i++) {
3627  double sumccc1 = 0.;
3628  int isum = 0;
3629  for (int kphi = 0; kphi < njphi; kphi++) {
3630  double ccc1 = alexall[keta][kphi][i];
3631  if (ccc1 > 0.) {
3632  sumccc1 += ccc1;
3633  isum++;
3634  }
3635  } // for kphi
3636  if (isum > 0.)
3637  sumccc1 /= isum;
3638  blexhb[keta][i] = sumccc1;
3639  }
3640  } //for for
3641 
3643  //========================================================================================== 11 HB:: 2D jeta = 0 - 21 jphi =0 - 17
3644  //======================================================================
3645  //======================================================================
3646  //======================================================================
3647  //======================================================================
3648  cout << " RBX HB 2D plot *****" << endl;
3649  cRBX1->Clear();
3651  cRBX1->Divide(1, 1);
3652  cRBX1->cd(1);
3653  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
3654  // TH2F* Ghb42D = new TH2F("Ghb42D","", 22, -11., 11., 18, 0., 18. );
3655  // TH2F* Ghb42D0 = new TH2F("Ghb42D0","", 22, -11., 11., 18, 0., 18. );
3656  TH2F *Ghb42D = new TH2F("Ghb42D", "", 23, -11.5, 11.5, 18, 0., 18.);
3657  TH2F *Ghb42D0 = new TH2F("Ghb42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
3658  TH2F *Ghb42DF = (TH2F *)Ghb42D0->Clone("Ghb42DF");
3659  for (int jphi = 0; jphi < njphi; jphi++) {
3660  for (int jeta = 0; jeta < njeta; jeta++) {
3661  for (int i = 0; i < nx; i++) {
3662  double ccc1 = alexall[jeta][jphi][i];
3663  int neweta = jeta - 11 - 0.5;
3664  if (jeta >= 11)
3665  neweta = jeta - 11 + 1.5;
3666  if (ccc1 > 0.) {
3667  Ghb42D->Fill(neweta, jphi, ccc1);
3668  Ghb42D0->Fill(neweta, jphi, 1.);
3669  }
3670  // if(ccc1>0.) {Ghb42D ->Fill(jeta-11,jphi,ccc1); Ghb42D0 ->Fill(jeta-11,jphi,1.); }
3671  }
3672  }
3673  }
3674  Ghb42DF->Divide(Ghb42D, Ghb42D0, 1, 1, "B"); // average A
3675  // Ghb1->Sumw2();
3676  gPad->SetGridy();
3677  gPad->SetGridx(); // gPad->SetLogz();
3678  Ghb42DF->SetMarkerStyle(20);
3679  Ghb42DF->SetMarkerSize(0.4);
3680  Ghb42DF->GetZaxis()->SetLabelSize(0.04);
3681  Ghb42DF->SetXTitle("<A>_RBX #eta \b");
3682  Ghb42DF->SetYTitle(" #phi \b");
3683  Ghb42DF->SetZTitle("<A>_RBX - All \b");
3684  Ghb42DF->SetMarkerColor(2);
3685  Ghb42DF->SetLineColor(2); // Ghb42DF->SetMaximum(1.000); // Ghb42DF->SetMinimum(1.0);
3686  Ghb42DF->Draw("COLZ");
3687 
3689  cRBX1->Update();
3690  cRBX1->Print("RBX-HB-2Dplot.png");
3691  cRBX1->Clear();
3692  // clean-up
3693  if (Ghb42D)
3694  delete Ghb42D;
3695  if (Ghb42D0)
3696  delete Ghb42D0;
3697  if (Ghb42DF)
3698  delete Ghb42DF;
3699 
3700  //========================================================================================== 61 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3701  //======================================================================
3702  //======================================================================
3703  //======================================================================
3704  //======================================================================
3705  cout << " RBX HB 1D plot *****" << endl;
3706  cRBX1->Clear();
3708  cRBX1->Divide(1, 1);
3709  cRBX1->cd(1);
3710  TH1F *GphiHB1D = new TH1F("GphiHB1D", "", 18, 0., 18.);
3711  TH1F *GphiHB1D0 = new TH1F("GphiHB1D0", "", 18, 0., 18.);
3712  TH1F *GphiHB1DF = (TH1F *)GphiHB1D0->Clone("GphiHB1DF");
3713  for (int jphi = 0; jphi < 18; jphi++) {
3714  for (int jeta = 0; jeta < 22; jeta++) {
3715  for (int i = 0; i < nx; i++) {
3716  double ccc1 = alexall[jeta][jphi][i];
3717  if (ccc1 > 0.) {
3718  GphiHB1D->Fill(jphi, ccc1);
3719  GphiHB1D0->Fill(jphi, 1.);
3720  }
3721  }
3722  }
3723  }
3724  // GphiHB1D->Sumw2();GphiHB1D0->Sumw2();
3725  GphiHB1DF->Divide(GphiHB1D, GphiHB1D0, 1, 1, "B"); // average A
3726  // GphiHB1DF->Sumw2();
3727  for (int jphi = 1; jphi < 19; jphi++) {
3728  GphiHB1DF->SetBinError(jphi, 0.01);
3729  }
3730  gPad->SetGridy();
3731  gPad->SetGridx(); // gPad->SetLogz();
3732  GphiHB1DF->SetMarkerStyle(20);
3733  GphiHB1DF->SetMarkerSize(1.4);
3734  GphiHB1DF->GetZaxis()->SetLabelSize(0.08);
3735  GphiHB1DF->SetXTitle("PHI of RBX\b");
3736  GphiHB1DF->SetYTitle(" <Amplitude> \b");
3737  GphiHB1DF->SetZTitle("<A>_PHI - All \b");
3738  GphiHB1DF->SetMarkerColor(4);
3739  GphiHB1DF->SetLineColor(4);
3740  GphiHB1DF->SetMinimum(0.8); // GphiHB1DF->SetMaximum(1.000);
3741  GphiHB1DF->Draw("Error");
3743  cRBX1->Update();
3744  cRBX1->Print("RBX-HB-1Dplot.png");
3745  cRBX1->Clear();
3746  // clean-up
3747  if (GphiHB1D)
3748  delete GphiHB1D;
3749  if (GphiHB1D0)
3750  delete GphiHB1D0;
3751  if (GphiHB1DF)
3752  delete GphiHB1DF;
3753 
3754  //========================================================================================== 62 HB:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
3755  //======================================================================
3756  //======================================================================
3757  //======================================================================
3758  //======================================================================
3759  cout << " RBX HB 11D plot *eta*" << endl;
3760  cRBX1->Clear();
3762  cRBX1->Divide(1, 1);
3763  cRBX1->cd(1);
3764  TH1F *GetaHB11D = new TH1F("GetaHB11D", "", 23, -11.5, 11.5);
3765  TH1F *GetaHB11D0 = new TH1F("GetaHB11D0", "", 23, -11.5, 11.5);
3766  TH1F *GetaHB11DF = (TH1F *)GetaHB11D0->Clone("GetaHB11DF");
3767 
3768  for (int jeta = 0; jeta < 22; jeta++) {
3769  for (int jphi = 0; jphi < 18; jphi++) {
3770  for (int i = 0; i < nx; i++) {
3771  double ccc1 = alexall[jeta][jphi][i];
3772  int neweta = jeta - 11 - 0.5;
3773  if (jeta >= 11)
3774  neweta = jeta - 11 + 1.5;
3775  if (ccc1 > 0.) {
3776  GetaHB11D->Fill(neweta, ccc1);
3777  GetaHB11D0->Fill(neweta, 1.);
3778  // if( i == 0 ) cout<<"62 HB: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
3779  }
3780  }
3781  }
3782  }
3783  // GetaHB11D->Sumw2();GetaHB11D0->Sumw2();
3784  GetaHB11DF->Divide(GetaHB11D, GetaHB11D0, 1, 1, "B"); // average A
3785  // GetaHB11DF->Sumw2();
3786  for (int jeta = 1; jeta < 24; jeta++) {
3787  GetaHB11DF->SetBinError(jeta, 0.01);
3788  }
3789  gPad->SetGridy();
3790  gPad->SetGridx(); // gPad->SetLogz();
3791  GetaHB11DF->SetMarkerStyle(20);
3792  GetaHB11DF->SetMarkerSize(1.4);
3793  GetaHB11DF->GetZaxis()->SetLabelSize(0.08);
3794  GetaHB11DF->SetXTitle("#eta \b");
3795  GetaHB11DF->SetYTitle(" <A> \b");
3796  GetaHB11DF->SetZTitle("<A>_ETA - All \b");
3797  GetaHB11DF->SetMarkerColor(4);
3798  GetaHB11DF->SetLineColor(4);
3799  GetaHB11DF->SetMinimum(0.8); // GetaHB11DF->SetMaximum(1.000);
3800  GetaHB11DF->Draw("Error");
3801 
3803  cRBX1->Update();
3804  cRBX1->Print("RBX-HB-11Dplot.png");
3805  cRBX1->Clear();
3806  // clean-up
3807  if (GetaHB11D)
3808  delete GetaHB11D;
3809  if (GetaHB11D0)
3810  delete GetaHB11D0;
3811  if (GetaHB11DF)
3812  delete GetaHB11DF;
3813 
3814  //========================================================================================== 22 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
3815  //======================================================================
3816  //======================================================================22.11.2018
3817  //======================================================================
3818  //======================================================================
3819 
3820  gStyle->SetOptStat(1110000);
3821  cout << " RBX HB Ratio plots *****" << endl;
3822  cRBX31->Clear();
3824  // gain stabilitY:
3825  // Rij = Aij / A1j , where i-over LSs, j-channels
3826  //
3827  // nx = maxbinsRBX; // # LS
3828  //
3829  double ccc0HB = 0.;
3830  cRBX31->Divide(3, 1);
3831  //================
3832  cRBX31->cd(1);
3833  // TH1F* Ghb5 = new TH1F("Ghb5","", nx, 1., nx+1.);
3834  TH1F *Ghb51 = new TH1F("Ghb51", "", nx, 1., nx + 1.);
3835  TH1F *Ghb50 = new TH1F("Ghb50", "", nx, 1., nx + 1.);
3836  TH1F *Ghb5 = (TH1F *)Ghb50->Clone("Ghb5");
3837  // j - etaphi index:
3838  for (int j = 1; j <= ny; j++) {
3839  ccc0HB = Ghb1->GetBinContent(1, j);
3840  // 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;} }
3841  if (ccc0HB <= 0.)
3842  for (int i = 1; i <= nx; i++) {
3843  double ccc2 = Ghb1->GetBinContent(i, j);
3844  if (ccc2 > 0.) {
3845  ccc0HB = ccc2;
3846  break;
3847  }
3848  }
3849  if (ccc0HB > 0.) {
3850  // i - # LSs:
3851  for (int i = 1; i <= nx; i++) {
3852  double ccc1 = Ghb1->GetBinContent(i, j);
3853  if (ccc1 > 0.) {
3854  double Rij = ccc1 / ccc0HB;
3855  // Ghb5 ->Fill( float(i), Rij);
3856  Ghb51->Fill(float(i), Rij);
3857  Ghb50->Fill(float(i), 1.);
3858  }
3859  }
3860  }
3861  }
3862  Ghb5->Divide(Ghb51, Ghb50, 1, 1, "B"); // average A
3863  for (int i = 1; i <= nx; i++) {
3864  Ghb5->SetBinError(i, 0.0001);
3865  }
3866  Ghb5->SetMarkerStyle(20);
3867  Ghb5->SetMarkerSize(0.4);
3868  Ghb5->GetYaxis()->SetLabelSize(0.04);
3869  Ghb5->SetMarkerColor(2);
3870  Ghb5->SetLineColor(0);
3871  Ghb5->SetXTitle(" iLS \b");
3872  Ghb5->SetYTitle(" <R> \b");
3873  Ghb5->SetTitle("<Ri> vs iLS \b");
3874  Ghb5->SetMinimum(0.); //Ghb5->SetMaximum(2.5);
3875  // gPad->SetLogy();
3876  gPad->SetGridy();
3877  gPad->SetGridx();
3878  Ghb5->SetStats(0);
3879  Ghb5->GetYaxis()->SetLabelSize(0.025);
3880  Ghb5->Draw("Error");
3881  //================
3882  cRBX31->cd(2);
3883  TH2F *Ghb60 = new TH2F("Ghb60", "", 22, -11., 11., 18, 0., 18.);
3884  TH2F *Ghb61 = new TH2F("Ghb61", "", 22, -11., 11., 18, 0., 18.);
3885  TH2F *Ghb6 = new TH2F("Ghb6", "", 22, -11., 11., 18, 0., 18.);
3886 
3887  TH2F *G20hb60 = new TH2F("G20hb60", "", 22, -11., 11., 18, 0., 18.);
3888  TH2F *G20hb61 = new TH2F("G20hb61", "", 22, -11., 11., 18, 0., 18.);
3889  TH2F *G20hb6 = new TH2F("G20hb6", "", 22, -11., 11., 18, 0., 18.);
3890  TH2F *G30hb60 = new TH2F("G30hb60", "", 22, -11., 11., 18, 0., 18.);
3891  TH2F *G30hb61 = new TH2F("G30hb61", "", 22, -11., 11., 18, 0., 18.);
3892  TH2F *G30hb6 = new TH2F("G30hb6", "", 22, -11., 11., 18, 0., 18.);
3893  TH2F *G40hb60 = new TH2F("G40hb60", "", 22, -11., 11., 18, 0., 18.);
3894  TH2F *G40hb61 = new TH2F("G40hb61", "", 22, -11., 11., 18, 0., 18.);
3895  TH2F *G40hb6 = new TH2F("G40hb6", "", 22, -11., 11., 18, 0., 18.);
3896  // j - etaphi index; i - # LSs;
3897  //
3898  // define mean and RMS:
3899  double sumjHB = 0.;
3900  int njHB = 0;
3901  double meanjHB = 0.;
3902  for (int j = 1; j <= ny; j++) {
3903  ccc0HB = Ghb1->GetBinContent(1, j);
3904  if (ccc0HB <= 0.)
3905  for (int i = 1; i <= nx; i++) {
3906  double ccc2 = Ghb1->GetBinContent(i, j);
3907  if (ccc2 > 0.) {
3908  ccc0HB = ccc2;
3909  break;
3910  }
3911  }
3912  if (ccc0HB > 0.) {
3913  for (int i = 1; i <= nx; i++) {
3914  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3915  if (ccc1 > 0.) {
3916  sumjHB += ccc1;
3917  njHB++;
3918  }
3919  }
3920  meanjHB = sumjHB / njHB;
3921  }
3922  } // j
3923 
3924  double ssumjHB = 0.;
3925  njHB = 0;
3926  double sigmajHB = 0.;
3927  for (int j = 1; j <= ny; j++) {
3928  ccc0HB = Ghb1->GetBinContent(1, j);
3929  if (ccc0HB <= 0.)
3930  for (int i = 1; i <= nx; i++) {
3931  double ccc2 = Ghb1->GetBinContent(i, j);
3932  if (ccc2 > 0.) {
3933  ccc0HB = ccc2;
3934  break;
3935  }
3936  }
3937  if (ccc0HB > 0.) {
3938  for (int i = 1; i <= nx; i++) {
3939  double ccc1 = Ghb1->GetBinContent(i, j) / ccc0HB;
3940  if (ccc1 > 0.) {
3941  ssumjHB += (ccc1 - meanjHB) * (ccc1 - meanjHB);
3942  njHB++;
3943  }
3944  }
3945  sigmajHB = sqrt(ssumjHB / njHB);
3946  }
3947  } // j
3948 
3949  double dif3rmsHBMIN = meanjHB - 3 * sigmajHB;
3950  if (dif3rmsHBMIN < 0.)
3951  dif3rmsHBMIN = 0.;
3952  double dif3rmsHBMAX = meanjHB + 3 * sigmajHB;
3953  cout << "22HB-2 meanjHB= " << meanjHB << " sigmajHB= " << sigmajHB << " dif3rmsHBMIN= " << dif3rmsHBMIN
3954  << " dif3rmsHBMAX= " << dif3rmsHBMAX << endl;
3955 
3956  double MAXdif3rmsHBMIN = dif3rmsHBMIN;
3957  double MINdif3rmsHBMAX = dif3rmsHBMAX;
3958  if (MAXdif3rmsHBMIN < 0.95)
3959  MAXdif3rmsHBMIN = 0.95;
3960  if (MINdif3rmsHBMAX > 1.05)
3961  MINdif3rmsHBMAX = 1.05;
3962  cout << "22HB-2 MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
3963  //
3964  for (int j = 1; j <= ny; j++) {
3965  ccc0HB = Ghb1->GetBinContent(1, j);
3966  if (ccc0HB <= 0.)
3967  for (int i = 1; i <= nx; i++) {
3968  double ccc2 = Ghb1->GetBinContent(i, j);
3969  if (ccc2 > 0.) {
3970  ccc0HB = ccc2;
3971  break;
3972  }
3973  }
3974  if (ccc0HB > 0.) {
3975  int jeta = (j - 1) / 18; // jeta = 0-21
3976  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
3977  // i - # LSs:
3978  for (int i = 1; i <= nx; i++) {
3979  double ccc1 = Ghb1->GetBinContent(i, j);
3980  if (ccc1 > 0.) {
3981  double Rij = ccc1 / ccc0HB;
3982  if (Rij < MAXdif3rmsHBMIN || Rij > MINdif3rmsHBMAX) {
3983  Ghb61->Fill(jeta - 11, jphi, Rij);
3984  Ghb60->Fill(jeta - 11, jphi, 1.);
3985  }
3986  if (Rij < 0.8 || Rij > 1.2) {
3987  G20hb61->Fill(jeta - 11, jphi, Rij);
3988  G20hb60->Fill(jeta - 11, jphi, 1.);
3989  }
3990  if (Rij < 0.7 || Rij > 1.3) {
3991  G30hb61->Fill(jeta - 11, jphi, Rij);
3992  G30hb60->Fill(jeta - 11, jphi, 1.);
3993  }
3994  if (Rij < 0.6 || Rij > 1.4) {
3995  G40hb61->Fill(jeta - 11, jphi, Rij);
3996  G40hb60->Fill(jeta - 11, jphi, 1.);
3997  }
3998  } //if(ccc1>0.
3999  } // i
4000  } //if(ccc0HB>0
4001  } // j
4002  Ghb6->Divide(Ghb61, Ghb60, 1, 1, "B"); // average R
4003  G20hb6->Divide(G20hb61, G20hb60, 1, 1, "B"); // average R
4004  G30hb6->Divide(G30hb61, G30hb60, 1, 1, "B"); // average R
4005  G40hb6->Divide(G40hb61, G40hb60, 1, 1, "B"); // average R
4006 
4007  Ghb6->GetZaxis()->SetLabelSize(0.025);
4008  Ghb6->SetXTitle(" #eta \b");
4009  Ghb6->SetYTitle(" #phi \b");
4010  Ghb6->SetTitle("<Rj> for |1-<R>| > 0.05 \b");
4011  Ghb6->SetStats(0);
4012  Ghb6->Draw("COLZ");
4013  //================
4014  cRBX31->cd(3);
4015  TH1F *Ghb7 = new TH1F("Ghb7", "", 120, 0.4, 1.6);
4016  // j - etaphi index:
4017  for (int j = 1; j <= ny; j++) {
4018  ccc0HB = Ghb1->GetBinContent(1, j);
4019  if (ccc0HB <= 0.)
4020  for (int i = 1; i <= nx; i++) {
4021  double ccc2 = Ghb1->GetBinContent(i, j);
4022  if (ccc2 > 0.) {
4023  ccc0HB = ccc2;
4024  break;
4025  }
4026  }
4027  if (ccc0HB > 0.) {
4028  // i - # LSs:
4029  for (int i = 1; i <= nx; i++) {
4030  double ccc1 = Ghb1->GetBinContent(i, j);
4031  if (ccc1 > 0.) {
4032  double Rij = ccc1 / ccc0HB;
4033  Ghb7->Fill(Rij);
4034  }
4035  }
4036  }
4037  }
4038  Ghb7->SetMarkerStyle(20);
4039  Ghb7->SetMarkerSize(0.4);
4040  Ghb7->GetYaxis()->SetLabelSize(0.04);
4041  Ghb7->SetMarkerColor(2);
4042  Ghb7->SetLineColor(0);
4043  Ghb7->SetYTitle(" N \b");
4044  Ghb7->SetXTitle(" Rij \b");
4045  Ghb7->SetTitle(" Rij \b");
4046  //Ghb7->SetMinimum(0.8);Ghb7->SetMaximum(500.);
4047  gPad->SetGridy();
4048  gPad->SetGridx(); // gPad->SetLogy();
4049  // Ghb7->SetStats(1110000);
4050  Ghb7->GetYaxis()->SetLabelSize(0.025);
4051  Ghb7->Draw("Error");
4052  Float_t ymaxHB = Ghb7->GetMaximum();
4053  cout << "22HB-3 ymaxHB= " << ymaxHB << " MAXdif3rmsHBMIN= " << MAXdif3rmsHBMIN
4054  << " MINdif3rmsHBMAX= " << MINdif3rmsHBMAX << endl;
4055  TLine *lineHB = new TLine(MAXdif3rmsHBMIN, 0., MAXdif3rmsHBMIN, ymaxHB);
4056  lineHB->SetLineColor(kBlue);
4057  lineHB->Draw();
4058  TLine *line1HB = new TLine(MINdif3rmsHBMAX, 0., MINdif3rmsHBMAX, ymaxHB);
4059  line1HB->SetLineColor(kBlue);
4060  line1HB->Draw();
4061  //================
4063  cRBX31->Update();
4064  cRBX31->Print("RBX-HB-3plots.png");
4065  cRBX31->Clear();
4066  // clean-up
4067  if (Ghb5)
4068  delete Ghb5;
4069  if (Ghb60)
4070  delete Ghb60;
4071  if (Ghb61)
4072  delete Ghb61;
4073  if (Ghb6)
4074  delete Ghb6;
4075  if (Ghb7)
4076  delete Ghb7;
4077 
4078  if (G20hb60)
4079  delete G20hb60;
4080  if (G20hb61)
4081  delete G20hb61;
4082  if (G30hb60)
4083  delete G30hb60;
4084  if (G30hb61)
4085  delete G30hb61;
4086  if (G40hb60)
4087  delete G40hb60;
4088  if (G40hb61)
4089  delete G40hb61;
4090 
4091  if (Ghb1)
4092  delete Ghb1;
4093  //========================================================================================== 22-1 HB:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4094  //======================================================================
4095  //======================================================================28.11.2018
4096  //======================================================================
4097  //======================================================================
4098 
4099  gStyle->SetOptStat(1110000);
4100  cout << " RBX HB Ratio plotsmore *****" << endl;
4101  cRBX31->Clear();
4103  cRBX31->Divide(3, 1);
4104  //================
4105  cRBX31->cd(1);
4106  G20hb6->GetZaxis()->SetLabelSize(0.025);
4107  G20hb6->SetXTitle(" #eta \b");
4108  G20hb6->SetYTitle(" #phi \b");
4109  G20hb6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4110  G20hb6->SetStats(0);
4111  G20hb6->Draw("COLZ");
4112  //================
4113  cRBX31->cd(2);
4114  G30hb6->GetZaxis()->SetLabelSize(0.025);
4115  G30hb6->SetXTitle(" #eta \b");
4116  G30hb6->SetYTitle(" #phi \b");
4117  G30hb6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4118  G30hb6->SetStats(0);
4119  G30hb6->Draw("COLZ");
4120  //================
4121  cRBX31->cd(3);
4122  G40hb6->GetZaxis()->SetLabelSize(0.025);
4123  G40hb6->SetXTitle(" #eta \b");
4124  G40hb6->SetYTitle(" #phi \b");
4125  G40hb6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4126  G40hb6->SetStats(0);
4127  G40hb6->Draw("COLZ");
4128  //================
4129 
4131  cRBX31->Update();
4132  cRBX31->Print("RBX-HB-3plotsmore.png");
4133  cRBX31->Clear();
4134 
4135  // clean-up
4136  if (G20hb6)
4137  delete G20hb6;
4138  if (G30hb6)
4139  delete G30hb6;
4140  if (G40hb6)
4141  delete G40hb6;
4142  gStyle->SetOptStat(0);
4143 
4145 
4146  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4147  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4148  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4149  for (int jphi = 0; jphi < njphi; jphi++) {
4150  for (int jeta = 0; jeta < njeta; jeta++) {
4151  for (int i = 0; i < nx; i++) {
4152  alexall[jeta][jphi][i] = 0.;
4153  }
4154  }
4155  } // nulling
4156 
4158 
4160  //======================================================================
4161  //======================================================================
4162  //======================================================================
4163  cout << " RBX general for HE **************************" << endl;
4164  TH2F *Ghe1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs1");
4165  TH2F *Ghe1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs10");
4166  TH2F *Ghe1 = (TH2F *)Ghe1LLL->Clone("Ghe1");
4167  Ghe1->Divide(Ghe1KKK, Ghe1LLL, 1, 1, "B"); // average A
4168  // Ghe1->Sumw2();
4169  // int nx = Ghe1->GetXaxis()->GetNbins(); // # LS
4170  // nx = maxbinsRBX; // # LS
4171  ny = Ghe1->GetYaxis()->GetNbins(); // # jetaphi indexes
4172  for (int j = 1; j <= ny; j++) {
4173  int jeta = (j - 1) / njphi; // jeta = 0-21
4174  if ((jeta < 8 && jeta > 2) || (jeta < 19 && jeta > 13)) {
4175  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4176  // cout<<"HE 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4177  // over LS:
4178  for (int i = 1; i <= nx; i++) {
4179  double ccc1 = Ghe1->GetBinContent(i, j);
4180  alexall[jeta][jphi][i - 1] = ccc1;
4181  // if( i == 1 ) cout<<"HE 54 for LS=1 ccc1= "<< ccc1 <<endl;
4182  } //i
4183  } //if
4184  } //j
4185  // clean-up
4186  if (Ghe1KKK)
4187  delete Ghe1KKK;
4188  if (Ghe1LLL)
4189  delete Ghe1LLL;
4190  // if (Ghe1) delete Ghe1;
4191 
4192  //====================================================================== alexhe[k][i]
4193  for (int jphi = 0; jphi < njphi; jphi++) {
4194  for (int i = 0; i < nx; i++) {
4195  double sumccc1 = 0.;
4196  int isum = 0;
4197  for (int jeta = 0; jeta < njeta; jeta++) {
4198  double ccc1 = alexall[jeta][jphi][i];
4199  if (ccc1 > 0.) {
4200  sumccc1 += ccc1;
4201  isum++;
4202  }
4203  } // for jeta
4204  if (isum > 0.)
4205  sumccc1 /= isum;
4206  alexhe[jphi][i] = sumccc1;
4207  }
4208  } //for for
4209  //====================================================================== blexhe[k][i]
4210  for (int keta = 0; keta < njeta; keta++) {
4211  for (int i = 0; i < nx; i++) {
4212  double sumccc1 = 0.;
4213  int isum = 0;
4214  for (int kphi = 0; kphi < njphi; kphi++) {
4215  double ccc1 = alexall[keta][kphi][i];
4216  if (ccc1 > 0.) {
4217  sumccc1 += ccc1;
4218  isum++;
4219  }
4220  } // for kphi
4221  if (isum > 0.)
4222  sumccc1 /= isum;
4223  blexhe[keta][i] = sumccc1;
4224  }
4225  } //for for
4227  //========================================================================================== 21 HE:: 2D jeta = 0 - 21 jphi =0 - 17
4228  //======================================================================
4229  //======================================================================
4230  //======================================================================
4231  //======================================================================
4232  cout << " RBX HE 2D plot *****" << endl;
4233  cRBX1->Clear();
4235  cRBX1->Divide(1, 1);
4236  cRBX1->cd(1);
4237  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4238  TH2F *Ghe42D = new TH2F("Ghe42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4239  TH2F *Ghe42D0 = new TH2F("Ghe42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4240  // TH2F* Ghe42D = new TH2F("Ghe42D","", 22, -11., 11., 18, 0., 18. );
4241  // TH2F* Ghe42D0 = new TH2F("Ghe42D0","", 22, -11., 11., 18, 0., 18. );
4242  TH2F *Ghe42DF = (TH2F *)Ghe42D0->Clone("Ghe42DF");
4243  for (int jphi = 0; jphi < njphi; jphi++) {
4244  for (int jeta = 0; jeta < njeta; jeta++) {
4245  for (int i = 0; i < nx; i++) {
4246  double ccc1 = alexall[jeta][jphi][i];
4247  int neweta = jeta - 11 - 0.5;
4248  if (jeta >= 11)
4249  neweta = jeta - 11 + 1.5;
4250  if (ccc1 > 0.) {
4251  Ghe42D->Fill(neweta, jphi, ccc1);
4252  Ghe42D0->Fill(neweta, jphi, 1.);
4253  }
4254  // if(ccc1>0.) {Ghe42D ->Fill(jeta-11,jphi,ccc1); Ghe42D0 ->Fill(jeta-11,jphi,1.); }
4255  }
4256  }
4257  }
4258  Ghe42DF->Divide(Ghe42D, Ghe42D0, 1, 1, "B"); // average A
4259  // Ghe1->Sumw2();
4260  gPad->SetGridy();
4261  gPad->SetGridx(); // gPad->SetLogz();
4262  Ghe42DF->SetMarkerStyle(20);
4263  Ghe42DF->SetMarkerSize(0.4);
4264  Ghe42DF->GetZaxis()->SetLabelSize(0.04);
4265  Ghe42DF->SetXTitle("<A>_RBX #eta \b");
4266  Ghe42DF->SetYTitle(" #phi \b");
4267  Ghe42DF->SetZTitle("<A>_RBX - All \b");
4268  Ghe42DF->SetMarkerColor(2);
4269  Ghe42DF->SetLineColor(2); // Ghe42DF->SetMaximum(1.000); // Ghe42DF->SetMinimum(1.0);
4270  Ghe42DF->Draw("COLZ");
4271 
4273  cRBX1->Update();
4274  cRBX1->Print("RBX-HE-2Dplot.png");
4275  cRBX1->Clear();
4276  // clean-up
4277  if (Ghe42D)
4278  delete Ghe42D;
4279  if (Ghe42D0)
4280  delete Ghe42D0;
4281  if (Ghe42DF)
4282  delete Ghe42DF;
4283 
4284  //========================================================================================== 61 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4285  //======================================================================
4286  //======================================================================
4287  //======================================================================
4288  //======================================================================
4289  cout << " RBX HE 1D plot *****" << endl;
4290  cRBX1->Clear();
4292  cRBX1->Divide(1, 1);
4293  cRBX1->cd(1);
4294  TH1F *GphiHE1D = new TH1F("GphiHE1D", "", 18, 0., 18.);
4295  TH1F *GphiHE1D0 = new TH1F("GphiHE1D0", "", 18, 0., 18.);
4296  TH1F *GphiHE1DF = (TH1F *)GphiHE1D0->Clone("GphiHE1DF");
4297  for (int jphi = 0; jphi < 18; jphi++) {
4298  for (int jeta = 0; jeta < 22; jeta++) {
4299  for (int i = 0; i < nx; i++) {
4300  double ccc1 = alexall[jeta][jphi][i];
4301  if (ccc1 > 0.) {
4302  GphiHE1D->Fill(jphi, ccc1);
4303  GphiHE1D0->Fill(jphi, 1.);
4304  }
4305  }
4306  }
4307  }
4308  // GphiHE1D->Sumw2();GphiHE1D0->Sumw2();
4309  GphiHE1DF->Divide(GphiHE1D, GphiHE1D0, 1, 1, "B"); // average A
4310  // GphiHE1DF->Sumw2();
4311  for (int jphi = 1; jphi < 19; jphi++) {
4312  GphiHE1DF->SetBinError(jphi, 0.01);
4313  }
4314  gPad->SetGridy();
4315  gPad->SetGridx(); // gPad->SetLogz();
4316  GphiHE1DF->SetMarkerStyle(20);
4317  GphiHE1DF->SetMarkerSize(1.4);
4318  GphiHE1DF->GetZaxis()->SetLabelSize(0.08);
4319  GphiHE1DF->SetXTitle("PHI of RBX\b");
4320  GphiHE1DF->SetYTitle(" <Amplitude> \b");
4321  GphiHE1DF->SetZTitle("<A>_PHI - All \b");
4322  GphiHE1DF->SetMarkerColor(4);
4323  GphiHE1DF->SetLineColor(4);
4324  GphiHE1DF->SetMinimum(0.8); // GphiHE1DF->SetMaximum(1.000);
4325  GphiHE1DF->Draw("Error");
4327  cRBX1->Update();
4328  cRBX1->Print("RBX-HE-1Dplot.png");
4329  cRBX1->Clear();
4330  // clean-up
4331  if (GphiHE1D)
4332  delete GphiHE1D;
4333  if (GphiHE1D0)
4334  delete GphiHE1D0;
4335  if (GphiHE1DF)
4336  delete GphiHE1DF;
4337 
4338  //========================================================================================== 62 HE:: 1D j = 3,4,5, 6, 7 14,15,16,17,18 jphi =0 - 17
4339  //======================================================================
4340  //======================================================================
4341  //======================================================================
4342  //======================================================================
4343  cout << " RBX HE 11D plot *eta*" << endl;
4344  cRBX1->Clear();
4346  cRBX1->Divide(1, 1);
4347  cRBX1->cd(1);
4348  TH1F *GetaHE11D = new TH1F("GetaHE11D", "", 23, -11.5, 11.5);
4349  TH1F *GetaHE11D0 = new TH1F("GetaHE11D0", "", 23, -11.5, 11.5);
4350  TH1F *GetaHE11DF = (TH1F *)GetaHE11D0->Clone("GetaHE11DF");
4351 
4352  for (int jeta = 0; jeta < 22; jeta++) {
4353  for (int jphi = 0; jphi < 18; jphi++) {
4354  for (int i = 0; i < nx; i++) {
4355  double ccc1 = alexall[jeta][jphi][i];
4356  int neweta = jeta - 11 - 0.5;
4357  if (jeta >= 11)
4358  neweta = jeta - 11 + 1.5;
4359  if (ccc1 > 0.) {
4360  GetaHE11D->Fill(neweta, ccc1);
4361  GetaHE11D0->Fill(neweta, 1.);
4362  // if( i == 0 ) cout<<"62 HE: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4363  }
4364  }
4365  }
4366  }
4367  // GetaHE11D->Sumw2();GetaHE11D0->Sumw2();
4368  GetaHE11DF->Divide(GetaHE11D, GetaHE11D0, 1, 1, "B"); // average A
4369  // GetaHE11DF->Sumw2();
4370  for (int jeta = 1; jeta < 24; jeta++) {
4371  GetaHE11DF->SetBinError(jeta, 0.01);
4372  }
4373  gPad->SetGridy();
4374  gPad->SetGridx(); // gPad->SetLogz();
4375  GetaHE11DF->SetMarkerStyle(20);
4376  GetaHE11DF->SetMarkerSize(1.4);
4377  GetaHE11DF->GetZaxis()->SetLabelSize(0.08);
4378  GetaHE11DF->SetXTitle("#eta \b");
4379  GetaHE11DF->SetYTitle(" <A> \b");
4380  GetaHE11DF->SetZTitle("<A>_ETA - All \b");
4381  GetaHE11DF->SetMarkerColor(4);
4382  GetaHE11DF->SetLineColor(4);
4383  GetaHE11DF->SetMinimum(0.8); // GetaHE11DF->SetMaximum(1.000);
4384  GetaHE11DF->Draw("Error");
4385 
4387  cRBX1->Update();
4388  cRBX1->Print("RBX-HE-11Dplot.png");
4389  cRBX1->Clear();
4390  // clean-up
4391  if (GetaHE11D)
4392  delete GetaHE11D;
4393  if (GetaHE11D0)
4394  delete GetaHE11D0;
4395  if (GetaHE11DF)
4396  delete GetaHE11DF;
4397 
4398  //========================================================================================== 22 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4399  //======================================================================
4400  //======================================================================22.11.2018
4401  //======================================================================
4402  //======================================================================
4403 
4404  gStyle->SetOptStat(1110000);
4405  cout << " RBX HE Ratio plots *****" << endl;
4406  cRBX31->Clear();
4408  // gain stabilitY:
4409  // Rij = Aij / A1j , where i-over LSs, j-channels
4410  //
4411  // nx = maxbinsRBX; // # LS
4412  //
4413  double ccc0HE = 0.;
4414  cRBX31->Divide(3, 1);
4415  //================
4416  cRBX31->cd(1);
4417  // TH1F* Ghe5 = new TH1F("Ghe5","", nx, 1., nx+1.);
4418  TH1F *Ghe51 = new TH1F("Ghe51", "", nx, 1., nx + 1.);
4419  TH1F *Ghe50 = new TH1F("Ghe50", "", nx, 1., nx + 1.);
4420  TH1F *Ghe5 = (TH1F *)Ghe50->Clone("Ghe5");
4421  // j - etaphi index:
4422  for (int j = 1; j <= ny; j++) {
4423  ccc0HE = Ghe1->GetBinContent(1, j);
4424  // 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;} }
4425  if (ccc0HE <= 0.)
4426  for (int i = 1; i <= nx; i++) {
4427  double ccc2 = Ghe1->GetBinContent(i, j);
4428  if (ccc2 > 0.) {
4429  ccc0HE = ccc2;
4430  break;
4431  }
4432  }
4433  if (ccc0HE > 0.) {
4434  // i - # LSs:
4435  for (int i = 1; i <= nx; i++) {
4436  double ccc1 = Ghe1->GetBinContent(i, j);
4437  if (ccc1 > 0.) {
4438  double Rij = ccc1 / ccc0HE;
4439  // Ghe5 ->Fill( float(i), Rij);
4440  Ghe51->Fill(float(i), Rij);
4441  Ghe50->Fill(float(i), 1.);
4442  }
4443  }
4444  }
4445  }
4446  Ghe5->Divide(Ghe51, Ghe50, 1, 1, "B"); // average A
4447  for (int i = 1; i <= nx; i++) {
4448  Ghe5->SetBinError(i, 0.0001);
4449  }
4450  Ghe5->SetMarkerStyle(20);
4451  Ghe5->SetMarkerSize(0.4);
4452  Ghe5->GetYaxis()->SetLabelSize(0.04);
4453  Ghe5->SetMarkerColor(2);
4454  Ghe5->SetLineColor(0);
4455  Ghe5->SetXTitle(" iLS \b");
4456  Ghe5->SetYTitle(" <R> \b");
4457  Ghe5->SetTitle("<Ri> vs iLS \b");
4458  Ghe5->SetMinimum(0.); //Ghe5->SetMaximum(2.5);
4459  // gPad->SetLogy();
4460  gPad->SetGridy();
4461  gPad->SetGridx();
4462  Ghe5->SetStats(0);
4463  Ghe5->GetYaxis()->SetLabelSize(0.025);
4464  Ghe5->Draw("Error");
4465  //================
4466  cRBX31->cd(2);
4467  TH2F *Ghe60 = new TH2F("Ghe60", "", 22, -11., 11., 18, 0., 18.);
4468  TH2F *Ghe61 = new TH2F("Ghe61", "", 22, -11., 11., 18, 0., 18.);
4469  TH2F *Ghe6 = new TH2F("Ghe6", "", 22, -11., 11., 18, 0., 18.);
4470 
4471  TH2F *G20he60 = new TH2F("G20he60", "", 22, -11., 11., 18, 0., 18.);
4472  TH2F *G20he61 = new TH2F("G20he61", "", 22, -11., 11., 18, 0., 18.);
4473  TH2F *G20he6 = new TH2F("G20he6", "", 22, -11., 11., 18, 0., 18.);
4474  TH2F *G30he60 = new TH2F("G30he60", "", 22, -11., 11., 18, 0., 18.);
4475  TH2F *G30he61 = new TH2F("G30he61", "", 22, -11., 11., 18, 0., 18.);
4476  TH2F *G30he6 = new TH2F("G30he6", "", 22, -11., 11., 18, 0., 18.);
4477  TH2F *G40he60 = new TH2F("G40he60", "", 22, -11., 11., 18, 0., 18.);
4478  TH2F *G40he61 = new TH2F("G40he61", "", 22, -11., 11., 18, 0., 18.);
4479  TH2F *G40he6 = new TH2F("G40he6", "", 22, -11., 11., 18, 0., 18.);
4480  // j - etaphi index; i - # LSs;
4481  //
4482  // define mean and RMS:
4483  double sumjHE = 0.;
4484  int njHE = 0;
4485  double meanjHE = 0.;
4486  for (int j = 1; j <= ny; j++) {
4487  ccc0HE = Ghe1->GetBinContent(1, j);
4488  if (ccc0HE <= 0.)
4489  for (int i = 1; i <= nx; i++) {
4490  double ccc2 = Ghe1->GetBinContent(i, j);
4491  if (ccc2 > 0.) {
4492  ccc0HE = ccc2;
4493  break;
4494  }
4495  }
4496  if (ccc0HE > 0.) {
4497  for (int i = 1; i <= nx; i++) {
4498  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4499  if (ccc1 > 0.) {
4500  sumjHE += ccc1;
4501  njHE++;
4502  }
4503  }
4504  meanjHE = sumjHE / njHE;
4505  }
4506  } // j
4507 
4508  double ssumjHE = 0.;
4509  njHE = 0;
4510  double sigmajHE = 0.;
4511  for (int j = 1; j <= ny; j++) {
4512  ccc0HE = Ghe1->GetBinContent(1, j);
4513  if (ccc0HE <= 0.)
4514  for (int i = 1; i <= nx; i++) {
4515  double ccc2 = Ghe1->GetBinContent(i, j);
4516  if (ccc2 > 0.) {
4517  ccc0HE = ccc2;
4518  break;
4519  }
4520  }
4521  if (ccc0HE > 0.) {
4522  for (int i = 1; i <= nx; i++) {
4523  double ccc1 = Ghe1->GetBinContent(i, j) / ccc0HE;
4524  if (ccc1 > 0.) {
4525  ssumjHE += (ccc1 - meanjHE) * (ccc1 - meanjHE);
4526  njHE++;
4527  }
4528  }
4529  sigmajHE = sqrt(ssumjHE / njHE);
4530  }
4531  } // j
4532 
4533  double dif3rmsHEMIN = meanjHE - 3 * sigmajHE;
4534  if (dif3rmsHEMIN < 0.)
4535  dif3rmsHEMIN = 0.;
4536  double dif3rmsHEMAX = meanjHE + 3 * sigmajHE;
4537  cout << "22HE-2 meanjHE= " << meanjHE << " sigmajHE= " << sigmajHE << " dif3rmsHEMIN= " << dif3rmsHEMIN
4538  << " dif3rmsHEMAX= " << dif3rmsHEMAX << endl;
4539 
4540  double MAXdif3rmsHEMIN = dif3rmsHEMIN;
4541  double MINdif3rmsHEMAX = dif3rmsHEMAX;
4542  if (MAXdif3rmsHEMIN < 0.95)
4543  MAXdif3rmsHEMIN = 0.95;
4544  if (MINdif3rmsHEMAX > 1.05)
4545  MINdif3rmsHEMAX = 1.05;
4546  cout << "22HE-2 MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4547  //
4548  for (int j = 1; j <= ny; j++) {
4549  ccc0HE = Ghe1->GetBinContent(1, j);
4550  if (ccc0HE <= 0.)
4551  for (int i = 1; i <= nx; i++) {
4552  double ccc2 = Ghe1->GetBinContent(i, j);
4553  if (ccc2 > 0.) {
4554  ccc0HE = ccc2;
4555  break;
4556  }
4557  }
4558  if (ccc0HE > 0.) {
4559  int jeta = (j - 1) / 18; // jeta = 0-21
4560  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
4561  // i - # LSs:
4562  for (int i = 1; i <= nx; i++) {
4563  double ccc1 = Ghe1->GetBinContent(i, j);
4564  if (ccc1 > 0.) {
4565  double Rij = ccc1 / ccc0HE;
4566  if (Rij < MAXdif3rmsHEMIN || Rij > MINdif3rmsHEMAX) {
4567  Ghe61->Fill(jeta - 11, jphi, Rij);
4568  Ghe60->Fill(jeta - 11, jphi, 1.);
4569  }
4570  if (Rij < 0.8 || Rij > 1.2) {
4571  G20he61->Fill(jeta - 11, jphi, Rij);
4572  G20he60->Fill(jeta - 11, jphi, 1.);
4573  }
4574  if (Rij < 0.7 || Rij > 1.3) {
4575  G30he61->Fill(jeta - 11, jphi, Rij);
4576  G30he60->Fill(jeta - 11, jphi, 1.);
4577  }
4578  if (Rij < 0.6 || Rij > 1.4) {
4579  G40he61->Fill(jeta - 11, jphi, Rij);
4580  G40he60->Fill(jeta - 11, jphi, 1.);
4581  }
4582  } //if(ccc1>0.
4583  } // i
4584  } //if(ccc0HE>0
4585  } // j
4586  Ghe6->Divide(Ghe61, Ghe60, 1, 1, "B"); // average R
4587  G20he6->Divide(G20he61, G20he60, 1, 1, "B"); // average R
4588  G30he6->Divide(G30he61, G30he60, 1, 1, "B"); // average R
4589  G40he6->Divide(G40he61, G40he60, 1, 1, "B"); // average R
4590 
4591  // Ghe6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
4592  // Ghe6->GetZaxis()->SetLabelOffset(-0.05);
4593  Ghe6->GetZaxis()->SetLabelSize(0.025);
4594 
4595  Ghe6->SetXTitle(" #eta \b");
4596  Ghe6->SetYTitle(" #phi \b");
4597  Ghe6->SetTitle(
4598  "<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);
4599  //gStyle->SetOptStat(kFALSE);
4600  Ghe6->SetStats(0);
4601  Ghe6->Draw("COLZ");
4602  //================
4603  cRBX31->cd(3);
4604  TH1F *Ghe7 = new TH1F("Ghe7", "", 120, 0.4, 1.6);
4605  // j - etaphi index:
4606  for (int j = 1; j <= ny; j++) {
4607  ccc0HE = Ghe1->GetBinContent(1, j);
4608  if (ccc0HE <= 0.)
4609  for (int i = 1; i <= nx; i++) {
4610  double ccc2 = Ghe1->GetBinContent(i, j);
4611  if (ccc2 > 0.) {
4612  ccc0HE = ccc2;
4613  break;
4614  }
4615  }
4616  if (ccc0HE > 0.) {
4617  // i - # LSs:
4618  for (int i = 1; i <= nx; i++) {
4619  double ccc1 = Ghe1->GetBinContent(i, j);
4620  if (ccc1 > 0.) {
4621  double Rij = ccc1 / ccc0HE;
4622  Ghe7->Fill(Rij);
4623  }
4624  }
4625  }
4626  }
4627  Ghe7->SetMarkerStyle(20);
4628  Ghe7->SetMarkerSize(0.4);
4629  Ghe7->GetYaxis()->SetLabelSize(0.04);
4630  Ghe7->SetMarkerColor(2);
4631  Ghe7->SetLineColor(0);
4632  Ghe7->SetYTitle(" N \b");
4633  Ghe7->SetXTitle(" Rij \b");
4634  Ghe7->SetTitle(" Rij \b");
4635  //Ghe7->SetMinimum(0.8);Ghe7->SetMaximum(500.);
4636  gPad->SetGridy();
4637  gPad->SetGridx(); // gPad->SetLogy();
4638  // Ghe7->SetStats(1110000);
4639  Ghe7->GetYaxis()->SetLabelSize(0.025);
4640  Ghe7->Draw("Error");
4641  Float_t ymaxHE = Ghe7->GetMaximum();
4642  cout << "22HE-3 ymaxHE= " << ymaxHE << " MAXdif3rmsHEMIN= " << MAXdif3rmsHEMIN
4643  << " MINdif3rmsHEMAX= " << MINdif3rmsHEMAX << endl;
4644  TLine *lineHE = new TLine(MAXdif3rmsHEMIN, 0., MAXdif3rmsHEMIN, ymaxHE);
4645  lineHE->SetLineColor(kBlue);
4646  lineHE->Draw();
4647  TLine *line1HE = new TLine(MINdif3rmsHEMAX, 0., MINdif3rmsHEMAX, ymaxHE);
4648  line1HE->SetLineColor(kBlue);
4649  line1HE->Draw();
4650  //================
4652  cRBX31->Update();
4653  cRBX31->Print("RBX-HE-3plots.png");
4654  cRBX31->Clear();
4655  // clean-up
4656  if (Ghe5)
4657  delete Ghe5;
4658  if (Ghe60)
4659  delete Ghe60;
4660  if (Ghe61)
4661  delete Ghe61;
4662  if (Ghe6)
4663  delete Ghe6;
4664  if (Ghe7)
4665  delete Ghe7;
4666 
4667  if (G20he60)
4668  delete G20he60;
4669  if (G20he61)
4670  delete G20he61;
4671  if (G30he60)
4672  delete G30he60;
4673  if (G30he61)
4674  delete G30he61;
4675  if (G40he60)
4676  delete G40he60;
4677  if (G40he61)
4678  delete G40he61;
4679 
4680  if (Ghe1)
4681  delete Ghe1;
4682  //========================================================================================== 22-1 HE:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4683  //======================================================================
4684  //======================================================================28.11.2018
4685  //======================================================================
4686  //======================================================================
4687 
4688  gStyle->SetOptStat(1110000);
4689  cout << " RBX HE Ratio plotsmore *****" << endl;
4690  cRBX31->Clear();
4692  cRBX31->Divide(3, 1);
4693  //================
4694  cRBX31->cd(1);
4695  G20he6->GetZaxis()->SetLabelSize(0.025);
4696  G20he6->SetXTitle(" #eta \b");
4697  G20he6->SetYTitle(" #phi \b");
4698  G20he6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
4699  G20he6->SetStats(0);
4700  G20he6->Draw("COLZ");
4701  //================
4702  cRBX31->cd(2);
4703  G30he6->GetZaxis()->SetLabelSize(0.025);
4704  G30he6->SetXTitle(" #eta \b");
4705  G30he6->SetYTitle(" #phi \b");
4706  G30he6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
4707  G30he6->SetStats(0);
4708  G30he6->Draw("COLZ");
4709  //================
4710  cRBX31->cd(3);
4711  G40he6->GetZaxis()->SetLabelSize(0.025);
4712  G40he6->SetXTitle(" #eta \b");
4713  G40he6->SetYTitle(" #phi \b");
4714  G40he6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
4715  G40he6->SetStats(0);
4716  G40he6->Draw("COLZ");
4717  //================
4718 
4720  cRBX31->Update();
4721  cRBX31->Print("RBX-HE-3plotsmore.png");
4722  cRBX31->Clear();
4723 
4724  // clean-up
4725  if (G20he6)
4726  delete G20he6;
4727  if (G30he6)
4728  delete G30he6;
4729  if (G40he6)
4730  delete G40he6;
4731  gStyle->SetOptStat(0);
4733 
4734  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4735  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4736  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
4737  for (int jphi = 0; jphi < njphi; jphi++) {
4738  for (int jeta = 0; jeta < njeta; jeta++) {
4739  for (int i = 0; i < nx; i++) {
4740  alexall[jeta][jphi][i] = 0.;
4741  }
4742  }
4743  } // nulling
4744 
4746 
4748  //======================================================================
4749  //======================================================================
4750  //======================================================================
4751  cout << " RBX general for HO **************************" << endl;
4752  TH2F *Gho1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs2");
4753  TH2F *Gho1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs20");
4754  TH2F *Gho1 = (TH2F *)Gho1LLL->Clone("Gho1");
4755  Gho1->Divide(Gho1KKK, Gho1LLL, 1, 1, "B"); // average A
4756  // Gho1->Sumw2();
4757  // int nx = Gho1->GetXaxis()->GetNbins(); // # LS
4758  // nx = maxbinsRBX; // # LS
4759  ny = Gho1->GetYaxis()->GetNbins(); // # jetaphi indexes
4760  for (int j = 1; j <= ny; j++) {
4761  int jeta = (j - 1) / njphi; // jeta = 0-21
4762  if (jeta < 15 && jeta > 6) {
4763  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
4764  // cout<<"HO 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
4765  // over LS:
4766  for (int i = 1; i <= nx; i++) {
4767  double ccc1 = Gho1->GetBinContent(i, j);
4768  alexall[jeta][jphi][i - 1] = ccc1;
4769  // if( i == 1 ) cout<<"HO 54 for LS=1 ccc1= "<< ccc1 <<endl;
4770  } //i
4771  } //if
4772  } //j
4773  // clean-up
4774  if (Gho1KKK)
4775  delete Gho1KKK;
4776  if (Gho1LLL)
4777  delete Gho1LLL;
4778  // if (Gho1) delete Gho1;
4779 
4780  //====================================================================== alexho[k][i]
4781  for (int jphi = 0; jphi < njphi; jphi++) {
4782  for (int i = 0; i < nx; i++) {
4783  double sumccc1 = 0.;
4784  int isum = 0;
4785  for (int jeta = 0; jeta < njeta; jeta++) {
4786  double ccc1 = alexall[jeta][jphi][i];
4787  if (ccc1 > 0.) {
4788  sumccc1 += ccc1;
4789  isum++;
4790  }
4791  } // for jeta
4792  if (isum > 0.)
4793  sumccc1 /= isum;
4794  alexho[jphi][i] = sumccc1;
4795  }
4796  } //for for
4797  //====================================================================== blexho[k][i]
4798  for (int keta = 0; keta < njeta; keta++) {
4799  for (int i = 0; i < nx; i++) {
4800  double sumccc1 = 0.;
4801  int isum = 0;
4802  for (int kphi = 0; kphi < njphi; kphi++) {
4803  double ccc1 = alexall[keta][kphi][i];
4804  if (ccc1 > 0.) {
4805  sumccc1 += ccc1;
4806  isum++;
4807  }
4808  } // for kphi
4809  if (isum > 0.)
4810  sumccc1 /= isum;
4811  blexho[keta][i] = sumccc1;
4812  }
4813  } //for for
4814 
4816  //========================================================================================== 33 HO:: 2D jeta = 0 - 21 jphi =0 - 17
4817  //======================================================================
4818  //======================================================================
4819  //======================================================================
4820  //======================================================================
4821  cout << " RBX HO 2D plot *****" << endl;
4822  cRBX1->Clear();
4824  cRBX1->Divide(1, 1);
4825  cRBX1->cd(1);
4826  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
4827  TH2F *Gho42D = new TH2F("Gho42D", "", 23, -11.5, 11.5, 18, 0., 18.);
4828  TH2F *Gho42D0 = new TH2F("Gho42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
4829  // TH2F* Gho42D = new TH2F("Gho42D","", 22, -11., 11., 18, 0., 18. );
4830  // TH2F* Gho42D0 = new TH2F("Gho42D0","", 22, -11., 11., 18, 0., 18. );
4831  TH2F *Gho42DF = (TH2F *)Gho42D0->Clone("Gho42DF");
4832  for (int jphi = 0; jphi < njphi; jphi++) {
4833  for (int jeta = 0; jeta < njeta; jeta++) {
4834  for (int i = 0; i < nx; i++) {
4835  double ccc1 = alexall[jeta][jphi][i];
4836  int neweta = jeta - 11 - 0.5;
4837  if (jeta >= 11)
4838  neweta = jeta - 11 + 1.5;
4839  if (ccc1 > 0.) {
4840  Gho42D->Fill(neweta, jphi, ccc1);
4841  Gho42D0->Fill(neweta, jphi, 1.);
4842  }
4843  // if(ccc1>0.) {Gho42D ->Fill(jeta-11,jphi,ccc1); Gho42D0 ->Fill(jeta-11,jphi,1.); }
4844  }
4845  }
4846  }
4847  Gho42DF->Divide(Gho42D, Gho42D0, 1, 1, "B"); // average A
4848  // Gho1->Sumw2();
4849  gPad->SetGridy();
4850  gPad->SetGridx(); // gPad->SetLogz();
4851  Gho42DF->SetMarkerStyle(20);
4852  Gho42DF->SetMarkerSize(0.4);
4853  Gho42DF->GetZaxis()->SetLabelSize(0.04);
4854  Gho42DF->SetXTitle("<A>_RBX #eta \b");
4855  Gho42DF->SetYTitle(" #phi \b");
4856  Gho42DF->SetZTitle("<A>_RBX - All \b");
4857  Gho42DF->SetMarkerColor(2);
4858  Gho42DF->SetLineColor(2); // Gho42DF->SetMaximum(1.000); // Gho42DF->SetMinimum(1.0);
4859  Gho42DF->Draw("COLZ");
4860 
4862  cRBX1->Update();
4863  cRBX1->Print("RBX-HO-2Dplot.png");
4864  cRBX1->Clear();
4865  // clean-up
4866  if (Gho42D)
4867  delete Gho42D;
4868  if (Gho42D0)
4869  delete Gho42D0;
4870  if (Gho42DF)
4871  delete Gho42DF;
4872 
4873  //========================================================================================== 61 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4874  //======================================================================
4875  //======================================================================
4876  //======================================================================
4877  //======================================================================
4878  cout << " RBX HO 1D plot *****" << endl;
4879  cRBX1->Clear();
4881  cRBX1->Divide(1, 1);
4882  cRBX1->cd(1);
4883  TH1F *GphiHO1D = new TH1F("GphiHO1D", "", 18, 0., 18.);
4884  TH1F *GphiHO1D0 = new TH1F("GphiHO1D0", "", 18, 0., 18.);
4885  TH1F *GphiHO1DF = (TH1F *)GphiHO1D0->Clone("GphiHO1DF");
4886  for (int jphi = 0; jphi < 18; jphi++) {
4887  for (int jeta = 0; jeta < 22; jeta++) {
4888  for (int i = 0; i < nx; i++) {
4889  double ccc1 = alexall[jeta][jphi][i];
4890  if (ccc1 > 0.) {
4891  GphiHO1D->Fill(jphi, ccc1);
4892  GphiHO1D0->Fill(jphi, 1.);
4893  }
4894  }
4895  }
4896  }
4897  // GphiHO1D->Sumw2();GphiHO1D0->Sumw2();
4898  GphiHO1DF->Divide(GphiHO1D, GphiHO1D0, 1, 1, "B"); // average A
4899  // GphiHO1DF->Sumw2();
4900  for (int jphi = 1; jphi < 19; jphi++) {
4901  GphiHO1DF->SetBinError(jphi, 0.01);
4902  }
4903  gPad->SetGridy();
4904  gPad->SetGridx(); // gPad->SetLogz();
4905  GphiHO1DF->SetMarkerStyle(20);
4906  GphiHO1DF->SetMarkerSize(1.4);
4907  GphiHO1DF->GetZaxis()->SetLabelSize(0.08);
4908  GphiHO1DF->SetXTitle("PHI of RBX\b");
4909  GphiHO1DF->SetYTitle(" <Amplitude> \b");
4910  GphiHO1DF->SetZTitle("<A>_PHI - All \b");
4911  GphiHO1DF->SetMarkerColor(4);
4912  GphiHO1DF->SetLineColor(4);
4913  GphiHO1DF->SetMinimum(0.8); // GphiHO1DF->SetMaximum(1.000);
4914  GphiHO1DF->Draw("Error");
4916  cRBX1->Update();
4917  cRBX1->Print("RBX-HO-1Dplot.png");
4918  cRBX1->Clear();
4919  // clean-up
4920  if (GphiHO1D)
4921  delete GphiHO1D;
4922  if (GphiHO1D0)
4923  delete GphiHO1D0;
4924  if (GphiHO1DF)
4925  delete GphiHO1DF;
4926 
4927  //========================================================================================== 62 HO:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
4928  //======================================================================
4929  //======================================================================
4930  //======================================================================
4931  //======================================================================
4932  cout << " RBX HO 11D plot *eta*" << endl;
4933  cRBX1->Clear();
4935  cRBX1->Divide(1, 1);
4936  cRBX1->cd(1);
4937  TH1F *GetaHO11D = new TH1F("GetaHO11D", "", 23, -11.5, 11.5);
4938  TH1F *GetaHO11D0 = new TH1F("GetaHO11D0", "", 23, -11.5, 11.5);
4939  TH1F *GetaHO11DF = (TH1F *)GetaHO11D0->Clone("GetaHO11DF");
4940 
4941  for (int jeta = 0; jeta < 22; jeta++) {
4942  for (int jphi = 0; jphi < 18; jphi++) {
4943  for (int i = 0; i < nx; i++) {
4944  double ccc1 = alexall[jeta][jphi][i];
4945  int neweta = jeta - 11 - 0.5;
4946  if (jeta >= 11)
4947  neweta = jeta - 11 + 1.5;
4948  if (ccc1 > 0.) {
4949  GetaHO11D->Fill(neweta, ccc1);
4950  GetaHO11D0->Fill(neweta, 1.);
4951  // if( i == 0 ) cout<<"62 HO: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
4952  }
4953  }
4954  }
4955  }
4956  // GetaHO11D->Sumw2();GetaHO11D0->Sumw2();
4957  GetaHO11DF->Divide(GetaHO11D, GetaHO11D0, 1, 1, "B"); // average A
4958  // GetaHO11DF->Sumw2();
4959  for (int jeta = 1; jeta < 24; jeta++) {
4960  GetaHO11DF->SetBinError(jeta, 0.01);
4961  }
4962  gPad->SetGridy();
4963  gPad->SetGridx(); // gPad->SetLogz();
4964  GetaHO11DF->SetMarkerStyle(20);
4965  GetaHO11DF->SetMarkerSize(1.4);
4966  GetaHO11DF->GetZaxis()->SetLabelSize(0.08);
4967  GetaHO11DF->SetXTitle("#eta \b");
4968  GetaHO11DF->SetYTitle(" <A> \b");
4969  GetaHO11DF->SetZTitle("<A>_ETA - All \b");
4970  GetaHO11DF->SetMarkerColor(4);
4971  GetaHO11DF->SetLineColor(4);
4972  GetaHO11DF->SetMinimum(0.8); // GetaHO11DF->SetMaximum(1.000);
4973  GetaHO11DF->Draw("Error");
4974 
4976  cRBX1->Update();
4977  cRBX1->Print("RBX-HO-11Dplot.png");
4978  cRBX1->Clear();
4979  // clean-up
4980  if (GetaHO11D)
4981  delete GetaHO11D;
4982  if (GetaHO11D0)
4983  delete GetaHO11D0;
4984  if (GetaHO11DF)
4985  delete GetaHO11DF;
4986 
4987  //========================================================================================== 22 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
4988  //======================================================================
4989  //======================================================================22.11.2018
4990  //======================================================================
4991  //======================================================================
4992 
4993  gStyle->SetOptStat(1110000);
4994  cout << " RBX HO Ratio plots *****" << endl;
4995  cRBX31->Clear();
4997  // gain stabilitY:
4998  // Rij = Aij / A1j , where i-over LSs, j-channels
4999  //
5000  // nx = maxbinsRBX; // # LS
5001  //
5002  double ccc0HO = 0.;
5003  cRBX31->Divide(3, 1);
5004  //================
5005  cRBX31->cd(1);
5006  // TH1F* Gho5 = new TH1F("Gho5","", nx, 1., nx+1.);
5007  TH1F *Gho51 = new TH1F("Gho51", "", nx, 1., nx + 1.);
5008  TH1F *Gho50 = new TH1F("Gho50", "", nx, 1., nx + 1.);
5009  TH1F *Gho5 = (TH1F *)Gho50->Clone("Gho5");
5010  // j - etaphi index:
5011  for (int j = 1; j <= ny; j++) {
5012  ccc0HO = Gho1->GetBinContent(1, j);
5013  // 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;} }
5014  if (ccc0HO <= 0.)
5015  for (int i = 1; i <= nx; i++) {
5016  double ccc2 = Gho1->GetBinContent(i, j);
5017  if (ccc2 > 0.) {
5018  ccc0HO = ccc2;
5019  break;
5020  }
5021  }
5022  if (ccc0HO > 0.) {
5023  // i - # LSs:
5024  for (int i = 1; i <= nx; i++) {
5025  double ccc1 = Gho1->GetBinContent(i, j);
5026  if (ccc1 > 0.) {
5027  double Rij = ccc1 / ccc0HO;
5028  // Gho5 ->Fill( float(i), Rij);
5029  Gho51->Fill(float(i), Rij);
5030  Gho50->Fill(float(i), 1.);
5031  }
5032  }
5033  }
5034  }
5035  Gho5->Divide(Gho51, Gho50, 1, 1, "B"); // average A
5036  for (int i = 1; i <= nx; i++) {
5037  Gho5->SetBinError(i, 0.0001);
5038  }
5039  Gho5->SetMarkerStyle(20);
5040  Gho5->SetMarkerSize(0.4);
5041  Gho5->GetYaxis()->SetLabelSize(0.04);
5042  Gho5->SetMarkerColor(2);
5043  Gho5->SetLineColor(0);
5044  Gho5->SetXTitle(" iLS \b");
5045  Gho5->SetYTitle(" <R> \b");
5046  Gho5->SetTitle("<Ri> vs iLS \b");
5047  Gho5->SetMinimum(0.); //Gho5->SetMaximum(2.5);
5048  // gPad->SetLogy();
5049  gPad->SetGridy();
5050  gPad->SetGridx();
5051  Gho5->SetStats(0);
5052  Gho5->GetYaxis()->SetLabelSize(0.025);
5053  Gho5->Draw("Error");
5054  //================
5055  cRBX31->cd(2);
5056  TH2F *Gho60 = new TH2F("Gho60", "", 22, -11., 11., 18, 0., 18.);
5057  TH2F *Gho61 = new TH2F("Gho61", "", 22, -11., 11., 18, 0., 18.);
5058  TH2F *Gho6 = new TH2F("Gho6", "", 22, -11., 11., 18, 0., 18.);
5059 
5060  TH2F *G20ho60 = new TH2F("G20ho60", "", 22, -11., 11., 18, 0., 18.);
5061  TH2F *G20ho61 = new TH2F("G20ho61", "", 22, -11., 11., 18, 0., 18.);
5062  TH2F *G20ho6 = new TH2F("G20ho6", "", 22, -11., 11., 18, 0., 18.);
5063  TH2F *G30ho60 = new TH2F("G30ho60", "", 22, -11., 11., 18, 0., 18.);
5064  TH2F *G30ho61 = new TH2F("G30ho61", "", 22, -11., 11., 18, 0., 18.);
5065  TH2F *G30ho6 = new TH2F("G30ho6", "", 22, -11., 11., 18, 0., 18.);
5066  TH2F *G40ho60 = new TH2F("G40ho60", "", 22, -11., 11., 18, 0., 18.);
5067  TH2F *G40ho61 = new TH2F("G40ho61", "", 22, -11., 11., 18, 0., 18.);
5068  TH2F *G40ho6 = new TH2F("G40ho6", "", 22, -11., 11., 18, 0., 18.);
5069 
5070  // j - etaphi index; i - # LSs;
5071  //
5072  // define mean and RMS:
5073  double sumjHO = 0.;
5074  int njHO = 0;
5075  double meanjHO = 0.;
5076  for (int j = 1; j <= ny; j++) {
5077  ccc0HO = Gho1->GetBinContent(1, j);
5078  if (ccc0HO <= 0.)
5079  for (int i = 1; i <= nx; i++) {
5080  double ccc2 = Gho1->GetBinContent(i, j);
5081  if (ccc2 > 0.) {
5082  ccc0HO = ccc2;
5083  break;
5084  }
5085  }
5086  if (ccc0HO > 0.) {
5087  for (int i = 1; i <= nx; i++) {
5088  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5089  if (ccc1 > 0.) {
5090  sumjHO += ccc1;
5091  njHO++;
5092  }
5093  }
5094  meanjHO = sumjHO / njHO;
5095  }
5096  } // j
5097 
5098  double ssumjHO = 0.;
5099  njHO = 0;
5100  double sigmajHO = 0.;
5101  for (int j = 1; j <= ny; j++) {
5102  ccc0HO = Gho1->GetBinContent(1, j);
5103  if (ccc0HO <= 0.)
5104  for (int i = 1; i <= nx; i++) {
5105  double ccc2 = Gho1->GetBinContent(i, j);
5106  if (ccc2 > 0.) {
5107  ccc0HO = ccc2;
5108  break;
5109  }
5110  }
5111  if (ccc0HO > 0.) {
5112  for (int i = 1; i <= nx; i++) {
5113  double ccc1 = Gho1->GetBinContent(i, j) / ccc0HO;
5114  if (ccc1 > 0.) {
5115  ssumjHO += (ccc1 - meanjHO) * (ccc1 - meanjHO);
5116  njHO++;
5117  }
5118  }
5119  sigmajHO = sqrt(ssumjHO / njHO);
5120  }
5121  } // j
5122 
5123  double dif3rmsHOMIN = meanjHO - 3 * sigmajHO;
5124  if (dif3rmsHOMIN < 0.)
5125  dif3rmsHOMIN = 0.;
5126  double dif3rmsHOMAX = meanjHO + 3 * sigmajHO;
5127  cout << "22HO-2 meanjHO= " << meanjHO << " sigmajHO= " << sigmajHO << " dif3rmsHOMIN= " << dif3rmsHOMIN
5128  << " dif3rmsHOMAX= " << dif3rmsHOMAX << endl;
5129 
5130  double MAXdif3rmsHOMIN = dif3rmsHOMIN;
5131  double MINdif3rmsHOMAX = dif3rmsHOMAX;
5132  if (MAXdif3rmsHOMIN < 0.95)
5133  MAXdif3rmsHOMIN = 0.95;
5134  if (MINdif3rmsHOMAX > 1.05)
5135  MINdif3rmsHOMAX = 1.05;
5136  cout << "22HO-2 MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5137  //
5138  for (int j = 1; j <= ny; j++) {
5139  ccc0HO = Gho1->GetBinContent(1, j);
5140  if (ccc0HO <= 0.)
5141  for (int i = 1; i <= nx; i++) {
5142  double ccc2 = Gho1->GetBinContent(i, j);
5143  if (ccc2 > 0.) {
5144  ccc0HO = ccc2;
5145  break;
5146  }
5147  }
5148  if (ccc0HO > 0.) {
5149  int jeta = (j - 1) / 18; // jeta = 0-21
5150  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5151  // i - # LSs:
5152  for (int i = 1; i <= nx; i++) {
5153  double ccc1 = Gho1->GetBinContent(i, j);
5154  if (ccc1 > 0.) {
5155  double Rij = ccc1 / ccc0HO;
5156  if (Rij < MAXdif3rmsHOMIN || Rij > MINdif3rmsHOMAX) {
5157  Gho61->Fill(jeta - 11, jphi, Rij);
5158  Gho60->Fill(jeta - 11, jphi, 1.);
5159  }
5160  if (Rij < 0.8 || Rij > 1.2) {
5161  G20ho61->Fill(jeta - 11, jphi, Rij);
5162  G20ho60->Fill(jeta - 11, jphi, 1.);
5163  }
5164  if (Rij < 0.7 || Rij > 1.3) {
5165  G30ho61->Fill(jeta - 11, jphi, Rij);
5166  G30ho60->Fill(jeta - 11, jphi, 1.);
5167  }
5168  if (Rij < 0.6 || Rij > 1.4) {
5169  G40ho61->Fill(jeta - 11, jphi, Rij);
5170  G40ho60->Fill(jeta - 11, jphi, 1.);
5171  }
5172  } //if(ccc1>0.
5173  } // i
5174  } //if(ccc0HO>0
5175  } // j
5176  Gho6->Divide(Gho61, Gho60, 1, 1, "B"); // average R
5177  G20ho6->Divide(G20ho61, G20ho60, 1, 1, "B"); // average R
5178  G30ho6->Divide(G30ho61, G30ho60, 1, 1, "B"); // average R
5179  G40ho6->Divide(G40ho61, G40ho60, 1, 1, "B"); // average R
5180  // Gho6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5181  // Gho6->GetZaxis()->SetLabelOffset(-0.05);
5182  Gho6->GetZaxis()->SetLabelSize(0.025);
5183 
5184  Gho6->SetXTitle(" #eta \b");
5185  Gho6->SetYTitle(" #phi \b");
5186  Gho6->SetTitle(
5187  "<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);
5188  //gStyle->SetOptStat(kFALSE);
5189  Gho6->SetStats(0);
5190  Gho6->Draw("COLZ");
5191  //================
5192  cRBX31->cd(3);
5193  TH1F *Gho7 = new TH1F("Gho7", "", 120, 0.4, 1.6);
5194  // j - etaphi index:
5195  for (int j = 1; j <= ny; j++) {
5196  ccc0HO = Gho1->GetBinContent(1, j);
5197  if (ccc0HO <= 0.)
5198  for (int i = 1; i <= nx; i++) {
5199  double ccc2 = Gho1->GetBinContent(i, j);
5200  if (ccc2 > 0.) {
5201  ccc0HO = ccc2;
5202  break;
5203  }
5204  }
5205  if (ccc0HO > 0.) {
5206  // i - # LSs:
5207  for (int i = 1; i <= nx; i++) {
5208  double ccc1 = Gho1->GetBinContent(i, j);
5209  if (ccc1 > 0.) {
5210  double Rij = ccc1 / ccc0HO;
5211  Gho7->Fill(Rij);
5212  }
5213  }
5214  }
5215  }
5216  Gho7->SetMarkerStyle(20);
5217  Gho7->SetMarkerSize(0.4);
5218  Gho7->GetYaxis()->SetLabelSize(0.04);
5219  Gho7->SetMarkerColor(2);
5220  Gho7->SetLineColor(0);
5221  Gho7->SetYTitle(" N \b");
5222  Gho7->SetXTitle(" Rij \b");
5223  Gho7->SetTitle(" Rij \b");
5224  //Gho7->SetMinimum(0.8);Gho7->SetMaximum(500.);
5225  gPad->SetGridy();
5226  gPad->SetGridx(); // gPad->SetLogy();
5227  // Gho7->SetStats(1110000);
5228  Gho7->GetYaxis()->SetLabelSize(0.025);
5229  Gho7->Draw("Error");
5230  Float_t ymaxHO = Gho7->GetMaximum();
5231  cout << "22HO-3 ymaxHO= " << ymaxHO << " MAXdif3rmsHOMIN= " << MAXdif3rmsHOMIN
5232  << " MINdif3rmsHOMAX= " << MINdif3rmsHOMAX << endl;
5233  TLine *lineHO = new TLine(MAXdif3rmsHOMIN, 0., MAXdif3rmsHOMIN, ymaxHO);
5234  lineHO->SetLineColor(kBlue);
5235  lineHO->Draw();
5236  TLine *line1HO = new TLine(MINdif3rmsHOMAX, 0., MINdif3rmsHOMAX, ymaxHO);
5237  line1HO->SetLineColor(kBlue);
5238  line1HO->Draw();
5239  //================
5241  cRBX31->Update();
5242  cRBX31->Print("RBX-HO-3plots.png");
5243  cRBX31->Clear();
5244  // clean-up
5245  if (Gho5)
5246  delete Gho5;
5247  if (Gho60)
5248  delete Gho60;
5249  if (Gho61)
5250  delete Gho61;
5251  if (Gho6)
5252  delete Gho6;
5253  if (Gho7)
5254  delete Gho7;
5255 
5256  if (G20ho60)
5257  delete G20ho60;
5258  if (G20ho61)
5259  delete G20ho61;
5260  if (G30ho60)
5261  delete G30ho60;
5262  if (G30ho61)
5263  delete G30ho61;
5264  if (G40ho60)
5265  delete G40ho60;
5266  if (G40ho61)
5267  delete G40ho61;
5268 
5269  if (Gho1)
5270  delete Gho1;
5271  //========================================================================================== 22-1 HO:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5272  //======================================================================
5273  //======================================================================28.11.2018
5274  //======================================================================
5275  //======================================================================
5276 
5277  gStyle->SetOptStat(1110000);
5278  cout << " RBX HO Ratio plotsmore *****" << endl;
5279  cRBX31->Clear();
5281  cRBX31->Divide(3, 1);
5282  //================
5283  cRBX31->cd(1);
5284  G20ho6->GetZaxis()->SetLabelSize(0.025);
5285  G20ho6->SetXTitle(" #eta \b");
5286  G20ho6->SetYTitle(" #phi \b");
5287  G20ho6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5288  G20ho6->SetStats(0);
5289  G20ho6->Draw("COLZ");
5290  //================
5291  cRBX31->cd(2);
5292  G30ho6->GetZaxis()->SetLabelSize(0.025);
5293  G30ho6->SetXTitle(" #eta \b");
5294  G30ho6->SetYTitle(" #phi \b");
5295  G30ho6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5296  G30ho6->SetStats(0);
5297  G30ho6->Draw("COLZ");
5298  //================
5299  cRBX31->cd(3);
5300  G40ho6->GetZaxis()->SetLabelSize(0.025);
5301  G40ho6->SetXTitle(" #eta \b");
5302  G40ho6->SetYTitle(" #phi \b");
5303  G40ho6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5304  G40ho6->SetStats(0);
5305  G40ho6->Draw("COLZ");
5306  //================
5307 
5309  cRBX31->Update();
5310  cRBX31->Print("RBX-HO-3plotsmore.png");
5311  cRBX31->Clear();
5312 
5313  // clean-up
5314  if (G20ho6)
5315  delete G20ho6;
5316  if (G30ho6)
5317  delete G30ho6;
5318  if (G40ho6)
5319  delete G40ho6;
5320  gStyle->SetOptStat(0);
5322 
5323  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5324  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5325  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5326  for (int jphi = 0; jphi < njphi; jphi++) {
5327  for (int jeta = 0; jeta < njeta; jeta++) {
5328  for (int i = 0; i < nx; i++) {
5329  alexall[jeta][jphi][i] = 0.;
5330  }
5331  }
5332  } // nulling
5333 
5335 
5337  //======================================================================
5338  //======================================================================
5339  //======================================================================
5340  cout << " RBX general for HF **************************" << endl;
5341  TH2F *Ghf1KKK = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs3");
5342  TH2F *Ghf1LLL = (TH2F *)dir->FindObjectAny("h_2DsumADCAmplEtaPhiLs30");
5343  TH2F *Ghf1 = (TH2F *)Ghf1LLL->Clone("Ghf1");
5344  Ghf1->Divide(Ghf1KKK, Ghf1LLL, 1, 1, "B"); // average A
5345  // Ghf1->Sumw2();
5346  // int nx = Ghf1->GetXaxis()->GetNbins(); // # LS
5347  // nx = maxbinsRBX; // # LS
5348  ny = Ghf1->GetYaxis()->GetNbins(); // # jetaphi indexes
5349  for (int j = 1; j <= ny; j++) {
5350  int jeta = (j - 1) / njphi; // jeta = 0-21
5351  if (jeta < 4 || jeta > 17) {
5352  int jphi = (j - 1) - njphi * jeta; // jphi=0-17
5353  // cout<<"HF 54 jeta= "<< jeta <<" jphi = "<<jphi <<endl;
5354  // over LS:
5355  for (int i = 1; i <= nx; i++) {
5356  double ccc1 = Ghf1->GetBinContent(i, j);
5357  alexall[jeta][jphi][i - 1] = ccc1;
5358  // if( i == 1 ) cout<<"HF 54 for LS=1 ccc1= "<< ccc1 <<endl;
5359  } //i
5360  } //if
5361  } //j
5362  // clean-up
5363  if (Ghf1KKK)
5364  delete Ghf1KKK;
5365  if (Ghf1LLL)
5366  delete Ghf1LLL;
5367  // if (Ghf1) delete Ghf1;
5368 
5369  //====================================================================== alexhf[k][i]
5370  for (int jphi = 0; jphi < njphi; jphi++) {
5371  for (int i = 0; i < nx; i++) {
5372  double sumccc1 = 0.;
5373  int isum = 0;
5374  for (int jeta = 0; jeta < njeta; jeta++) {
5375  double ccc1 = alexall[jeta][jphi][i];
5376  if (ccc1 > 0.) {
5377  sumccc1 += ccc1;
5378  isum++;
5379  }
5380  } // for jeta
5381  if (isum > 0.)
5382  sumccc1 /= isum;
5383  alexhf[jphi][i] = sumccc1;
5384  }
5385  } //for for
5386  //====================================================================== blexhf[k][i]
5387  for (int keta = 0; keta < njeta; keta++) {
5388  for (int i = 0; i < nx; i++) {
5389  double sumccc1 = 0.;
5390  int isum = 0;
5391  for (int kphi = 0; kphi < njphi; kphi++) {
5392  double ccc1 = alexall[keta][kphi][i];
5393  if (ccc1 > 0.) {
5394  sumccc1 += ccc1;
5395  isum++;
5396  }
5397  } // for kphi
5398  if (isum > 0.)
5399  sumccc1 /= isum;
5400  blexhf[keta][i] = sumccc1;
5401  }
5402  } //for for
5404  //========================================================================================== 60 HF:: 2D jeta = 0 - 21 jphi =0 - 17
5405  //======================================================================
5406  //======================================================================
5407  //======================================================================
5408  //======================================================================
5409  cout << " RBX HF 2D plot *****" << endl;
5410  cRBX1->Clear();
5412  cRBX1->Divide(1, 1);
5413  cRBX1->cd(1);
5414  // int ietaphi = 0; ietaphi = ((k2+1)-1)*nphi + (k3+1) ; k2=0-neta-1; k3=0-nphi-1; neta=18; nphi=22;
5415  TH2F *Ghf42D = new TH2F("Ghf42D", "", 23, -11.5, 11.5, 18, 0., 18.);
5416  TH2F *Ghf42D0 = new TH2F("Ghf42D0", "", 23, -11.5, 11.5, 18, 0., 18.);
5417  // TH2F* Ghf42D = new TH2F("Ghf42D","", 22, -11., 11., 18, 0., 18. );
5418  // TH2F* Ghf42D0 = new TH2F("Ghf42D0","", 22, -11., 11., 18, 0., 18. );
5419  TH2F *Ghf42DF = (TH2F *)Ghf42D0->Clone("Ghf42DF");
5420  for (int jphi = 0; jphi < njphi; jphi++) {
5421  for (int jeta = 0; jeta < njeta; jeta++) {
5422  for (int i = 0; i < nx; i++) {
5423  double ccc1 = alexall[jeta][jphi][i];
5424  int neweta = jeta - 11 - 0.5;
5425  if (jeta >= 11)
5426  neweta = jeta - 11 + 1.5;
5427  if (ccc1 > 0.) {
5428  Ghf42D->Fill(neweta, jphi, ccc1);
5429  Ghf42D0->Fill(neweta, jphi, 1.);
5430  }
5431  // if(ccc1>0.) {Ghf42D ->Fill(jeta-11,jphi,ccc1); Ghf42D0 ->Fill(jeta-11,jphi,1.); }
5432  }
5433  }
5434  }
5435  Ghf42DF->Divide(Ghf42D, Ghf42D0, 1, 1, "B"); // average A
5436  // Ghf1->Sumw2();
5437  gPad->SetGridy();
5438  gPad->SetGridx(); // gPad->SetLogz();
5439  Ghf42DF->SetMarkerStyle(20);
5440  Ghf42DF->SetMarkerSize(0.4);
5441  Ghf42DF->GetZaxis()->SetLabelSize(0.04);
5442  Ghf42DF->SetXTitle("<A>_RBX #eta \b");
5443  Ghf42DF->SetYTitle(" #phi \b");
5444  Ghf42DF->SetZTitle("<A>_RBX - All \b");
5445  Ghf42DF->SetMarkerColor(2);
5446  Ghf42DF->SetLineColor(2); // Ghf42DF->SetMaximum(1.000); // Ghf42DF->SetMinimum(1.0);
5447  Ghf42DF->Draw("COLZ");
5448 
5450  cRBX1->Update();
5451  cRBX1->Print("RBX-HF-2Dplot.png");
5452  cRBX1->Clear();
5453  // clean-up
5454  if (Ghf42D)
5455  delete Ghf42D;
5456  if (Ghf42D0)
5457  delete Ghf42D0;
5458  if (Ghf42DF)
5459  delete Ghf42DF;
5460 
5461  //========================================================================================== 61 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5462  //======================================================================
5463  //======================================================================
5464  //======================================================================
5465  //======================================================================
5466  cout << " RBX HF 1D plot *****" << endl;
5467  cRBX1->Clear();
5469  cRBX1->Divide(1, 1);
5470  cRBX1->cd(1);
5471  TH1F *GphiHF1D = new TH1F("GphiHF1D", "", 18, 0., 18.);
5472  TH1F *GphiHF1D0 = new TH1F("GphiHF1D0", "", 18, 0., 18.);
5473  TH1F *GphiHF1DF = (TH1F *)GphiHF1D0->Clone("GphiHF1DF");
5474  for (int jphi = 0; jphi < 18; jphi++) {
5475  for (int jeta = 0; jeta < 22; jeta++) {
5476  for (int i = 0; i < nx; i++) {
5477  double ccc1 = alexall[jeta][jphi][i];
5478  if (ccc1 > 0.) {
5479  GphiHF1D->Fill(jphi, ccc1);
5480  GphiHF1D0->Fill(jphi, 1.);
5481  }
5482  }
5483  }
5484  }
5485  // GphiHF1D->Sumw2();GphiHF1D0->Sumw2();
5486  GphiHF1DF->Divide(GphiHF1D, GphiHF1D0, 1, 1, "B"); // average A
5487  // GphiHF1DF->Sumw2();
5488  for (int jphi = 1; jphi < 19; jphi++) {
5489  GphiHF1DF->SetBinError(jphi, 0.01);
5490  }
5491  gPad->SetGridy();
5492  gPad->SetGridx(); // gPad->SetLogz();
5493  GphiHF1DF->SetMarkerStyle(20);
5494  GphiHF1DF->SetMarkerSize(1.4);
5495  GphiHF1DF->GetZaxis()->SetLabelSize(0.08);
5496  GphiHF1DF->SetXTitle("PHI of RBX\b");
5497  GphiHF1DF->SetYTitle(" <Amplitude> \b");
5498  GphiHF1DF->SetZTitle("<A>_PHI - All \b");
5499  GphiHF1DF->SetMarkerColor(4);
5500  GphiHF1DF->SetLineColor(4);
5501  GphiHF1DF->SetMinimum(0.8); // GphiHF1DF->SetMaximum(1.000);
5502  GphiHF1DF->Draw("Error");
5504  cRBX1->Update();
5505  cRBX1->Print("RBX-HF-1Dplot.png");
5506  cRBX1->Clear();
5507  // clean-up
5508  if (GphiHF1D)
5509  delete GphiHF1D;
5510  if (GphiHF1D0)
5511  delete GphiHF1D0;
5512  if (GphiHF1DF)
5513  delete GphiHF1DF;
5514 
5515  //========================================================================================== 62 HF:: 1D j = 7,8,9,10 ; 11,12,13,14 jphi =0 - 17
5516  //======================================================================
5517  //======================================================================
5518  //======================================================================
5519  //======================================================================
5520  cout << " RBX HF 11D plot *eta*" << endl;
5521  cRBX1->Clear();
5523  cRBX1->Divide(1, 1);
5524  cRBX1->cd(1);
5525  TH1F *GetaHF11D = new TH1F("GetaHF11D", "", 23, -11.5, 11.5);
5526  TH1F *GetaHF11D0 = new TH1F("GetaHF11D0", "", 23, -11.5, 11.5);
5527  TH1F *GetaHF11DF = (TH1F *)GetaHF11D0->Clone("GetaHF11DF");
5528 
5529  for (int jeta = 0; jeta < 22; jeta++) {
5530  for (int jphi = 0; jphi < 18; jphi++) {
5531  for (int i = 0; i < nx; i++) {
5532  double ccc1 = alexall[jeta][jphi][i];
5533  int neweta = jeta - 11 - 0.5;
5534  if (jeta >= 11)
5535  neweta = jeta - 11 + 1.5;
5536  if (ccc1 > 0.) {
5537  GetaHF11D->Fill(neweta, ccc1);
5538  GetaHF11D0->Fill(neweta, 1.);
5539  // if( i == 0 ) cout<<"62 HF: ibin= "<< i <<" jphi= "<< jphi <<" jeta= "<< jeta <<" A= "<< ccc1 <<endl;
5540  }
5541  }
5542  }
5543  }
5544  // GetaHF11D->Sumw2();GetaHF11D0->Sumw2();
5545  GetaHF11DF->Divide(GetaHF11D, GetaHF11D0, 1, 1, "B"); // average A
5546  // GetaHF11DF->Sumw2();
5547  for (int jeta = 1; jeta < 24; jeta++) {
5548  GetaHF11DF->SetBinError(jeta, 0.01);
5549  }
5550  gPad->SetGridy();
5551  gPad->SetGridx(); // gPad->SetLogz();
5552  GetaHF11DF->SetMarkerStyle(20);
5553  GetaHF11DF->SetMarkerSize(1.4);
5554  GetaHF11DF->GetZaxis()->SetLabelSize(0.08);
5555  GetaHF11DF->SetXTitle("#eta \b");
5556  GetaHF11DF->SetYTitle(" <A> \b");
5557  GetaHF11DF->SetZTitle("<A>_ETA - All \b");
5558  GetaHF11DF->SetMarkerColor(4);
5559  GetaHF11DF->SetLineColor(4);
5560  GetaHF11DF->SetMinimum(0.8); // GetaHF11DF->SetMaximum(1.000);
5561  GetaHF11DF->Draw("Error");
5562 
5564  cRBX1->Update();
5565  cRBX1->Print("RBX-HF-11Dplot.png");
5566  cRBX1->Clear();
5567  // clean-up
5568  if (GetaHF11D)
5569  delete GetaHF11D;
5570  if (GetaHF11D0)
5571  delete GetaHF11D0;
5572  if (GetaHF11DF)
5573  delete GetaHF11DF;
5574 
5575  //========================================================================================== 22 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5576  //======================================================================
5577  //======================================================================22.11.2018
5578  //======================================================================
5579  //======================================================================
5580 
5581  gStyle->SetOptStat(1110000);
5582  cout << " RBX HF Ratio plots *****" << endl;
5583  cRBX31->Clear();
5585  // gain stabilitY:
5586  // Rij = Aij / A1j , where i-over LSs, j-channels
5587  //
5588  // nx = maxbinsRBX; // # LS
5589  //
5590  double ccc0HF = 0.;
5591  cRBX31->Divide(3, 1);
5592  //================
5593  cRBX31->cd(1);
5594  // TH1F* Ghf5 = new TH1F("Ghf5","", nx, 1., nx+1.);
5595  TH1F *Ghf51 = new TH1F("Ghf51", "", nx, 1., nx + 1.);
5596  TH1F *Ghf50 = new TH1F("Ghf50", "", nx, 1., nx + 1.);
5597  TH1F *Ghf5 = (TH1F *)Ghf50->Clone("Ghf5");
5598  // j - etaphi index:
5599  for (int j = 1; j <= ny; j++) {
5600  ccc0HF = Ghf1->GetBinContent(1, j);
5601  // 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;} }
5602  if (ccc0HF <= 0.)
5603  for (int i = 1; i <= nx; i++) {
5604  double ccc2 = Ghf1->GetBinContent(i, j);
5605  if (ccc2 > 0.) {
5606  ccc0HF = ccc2;
5607  break;
5608  }
5609  }
5610  if (ccc0HF > 0.) {
5611  // i - # LSs:
5612  for (int i = 1; i <= nx; i++) {
5613  double ccc1 = Ghf1->GetBinContent(i, j);
5614  if (ccc1 > 0.) {
5615  double Rij = ccc1 / ccc0HF;
5616  // Ghf5 ->Fill( float(i), Rij);
5617  Ghf51->Fill(float(i), Rij);
5618  Ghf50->Fill(float(i), 1.);
5619  }
5620  }
5621  }
5622  }
5623  Ghf5->Divide(Ghf51, Ghf50, 1, 1, "B"); // average A
5624  for (int i = 1; i <= nx; i++) {
5625  Ghf5->SetBinError(i, 0.0001);
5626  }
5627  Ghf5->SetMarkerStyle(20);
5628  Ghf5->SetMarkerSize(0.4);
5629  Ghf5->GetYaxis()->SetLabelSize(0.04);
5630  Ghf5->SetMarkerColor(2);
5631  Ghf5->SetLineColor(0);
5632  Ghf5->SetXTitle(" iLS \b");
5633  Ghf5->SetYTitle(" <R> \b");
5634  Ghf5->SetTitle("<Ri> vs iLS \b");
5635  Ghf5->SetMinimum(0.); //Ghf5->SetMaximum(2.5);
5636  // gPad->SetLogy();
5637  gPad->SetGridy();
5638  gPad->SetGridx();
5639  Ghf5->SetStats(0);
5640  Ghf5->GetYaxis()->SetLabelSize(0.025);
5641  Ghf5->Draw("Error");
5642  //================
5643  cRBX31->cd(2);
5644  TH2F *Ghf60 = new TH2F("Ghf60", "", 22, -11., 11., 18, 0., 18.);
5645  TH2F *Ghf61 = new TH2F("Ghf61", "", 22, -11., 11., 18, 0., 18.);
5646  TH2F *Ghf6 = new TH2F("Ghf6", "", 22, -11., 11., 18, 0., 18.);
5647 
5648  TH2F *G20hf60 = new TH2F("G20hf60", "", 22, -11., 11., 18, 0., 18.);
5649  TH2F *G20hf61 = new TH2F("G20hf61", "", 22, -11., 11., 18, 0., 18.);
5650  TH2F *G20hf6 = new TH2F("G20hf6", "", 22, -11., 11., 18, 0., 18.);
5651  TH2F *G30hf60 = new TH2F("G30hf60", "", 22, -11., 11., 18, 0., 18.);
5652  TH2F *G30hf61 = new TH2F("G30hf61", "", 22, -11., 11., 18, 0., 18.);
5653  TH2F *G30hf6 = new TH2F("G30hf6", "", 22, -11., 11., 18, 0., 18.);
5654  TH2F *G40hf60 = new TH2F("G40hf60", "", 22, -11., 11., 18, 0., 18.);
5655  TH2F *G40hf61 = new TH2F("G40hf61", "", 22, -11., 11., 18, 0., 18.);
5656  TH2F *G40hf6 = new TH2F("G40hf6", "", 22, -11., 11., 18, 0., 18.);
5657  // j - etaphi index; i - # LSs;
5658  //
5659  // define mean and RMS:
5660  double sumjHF = 0.;
5661  int njHF = 0;
5662  double meanjHF = 0.;
5663  for (int j = 1; j <= ny; j++) {
5664  ccc0HF = Ghf1->GetBinContent(1, j);
5665  if (ccc0HF <= 0.)
5666  for (int i = 1; i <= nx; i++) {
5667  double ccc2 = Ghf1->GetBinContent(i, j);
5668  if (ccc2 > 0.) {
5669  ccc0HF = ccc2;
5670  break;
5671  }
5672  }
5673  if (ccc0HF > 0.) {
5674  for (int i = 1; i <= nx; i++) {
5675  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5676  if (ccc1 > 0.) {
5677  sumjHF += ccc1;
5678  njHF++;
5679  }
5680  }
5681  meanjHF = sumjHF / njHF;
5682  }
5683  } // j
5684 
5685  double ssumjHF = 0.;
5686  njHF = 0;
5687  double sigmajHF = 0.;
5688  for (int j = 1; j <= ny; j++) {
5689  ccc0HF = Ghf1->GetBinContent(1, j);
5690  if (ccc0HF <= 0.)
5691  for (int i = 1; i <= nx; i++) {
5692  double ccc2 = Ghf1->GetBinContent(i, j);
5693  if (ccc2 > 0.) {
5694  ccc0HF = ccc2;
5695  break;
5696  }
5697  }
5698  if (ccc0HF > 0.) {
5699  for (int i = 1; i <= nx; i++) {
5700  double ccc1 = Ghf1->GetBinContent(i, j) / ccc0HF;
5701  if (ccc1 > 0.) {
5702  ssumjHF += (ccc1 - meanjHF) * (ccc1 - meanjHF);
5703  njHF++;
5704  }
5705  }
5706  sigmajHF = sqrt(ssumjHF / njHF);
5707  }
5708  } // j
5709 
5710  double dif3rmsHFMIN = meanjHF - 3 * sigmajHF;
5711  if (dif3rmsHFMIN < 0.)
5712  dif3rmsHFMIN = 0.;
5713  double dif3rmsHFMAX = meanjHF + 3 * sigmajHF;
5714  cout << "22HF-2 meanjHF= " << meanjHF << " sigmajHF= " << sigmajHF << " dif3rmsHFMIN= " << dif3rmsHFMIN
5715  << " dif3rmsHFMAX= " << dif3rmsHFMAX << endl;
5716 
5717  double MAXdif3rmsHFMIN = dif3rmsHFMIN;
5718  double MINdif3rmsHFMAX = dif3rmsHFMAX;
5719  if (MAXdif3rmsHFMIN < 0.95)
5720  MAXdif3rmsHFMIN = 0.95;
5721  if (MINdif3rmsHFMAX > 1.05)
5722  MINdif3rmsHFMAX = 1.05;
5723  cout << "22HF-2 MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5724  //
5725  for (int j = 1; j <= ny; j++) {
5726  ccc0HF = Ghf1->GetBinContent(1, j);
5727  if (ccc0HF <= 0.)
5728  for (int i = 1; i <= nx; i++) {
5729  double ccc2 = Ghf1->GetBinContent(i, j);
5730  if (ccc2 > 0.) {
5731  ccc0HF = ccc2;
5732  break;
5733  }
5734  }
5735  if (ccc0HF > 0.) {
5736  int jeta = (j - 1) / 18; // jeta = 0-21
5737  int jphi = (j - 1) - 18 * jeta; // jphi=0-17
5738  // i - # LSs:
5739  for (int i = 1; i <= nx; i++) {
5740  double ccc1 = Ghf1->GetBinContent(i, j);
5741  if (ccc1 > 0.) {
5742  double Rij = ccc1 / ccc0HF;
5743  if (Rij < MAXdif3rmsHFMIN || Rij > MINdif3rmsHFMAX) {
5744  Ghf61->Fill(jeta - 11, jphi, Rij);
5745  Ghf60->Fill(jeta - 11, jphi, 1.);
5746  }
5747  if (Rij < 0.8 || Rij > 1.2) {
5748  G20hf61->Fill(jeta - 11, jphi, Rij);
5749  G20hf60->Fill(jeta - 11, jphi, 1.);
5750  }
5751  if (Rij < 0.7 || Rij > 1.3) {
5752  G30hf61->Fill(jeta - 11, jphi, Rij);
5753  G30hf60->Fill(jeta - 11, jphi, 1.);
5754  }
5755  if (Rij < 0.6 || Rij > 1.4) {
5756  G40hf61->Fill(jeta - 11, jphi, Rij);
5757  G40hf60->Fill(jeta - 11, jphi, 1.);
5758  }
5759  } //if(ccc1>0.
5760  } // i
5761  } //if(ccc0HF>0
5762  } // j
5763  Ghf6->Divide(Ghf61, Ghf60, 1, 1, "B"); // average R
5764  G20hf6->Divide(G20hf61, G20hf60, 1, 1, "B"); // average R
5765  G30hf6->Divide(G30hf61, G30hf60, 1, 1, "B"); // average R
5766  G40hf6->Divide(G40hf61, G40hf60, 1, 1, "B"); // average R
5767  // Ghf6->SetLabelOffset (Float_t offset=0.005, Option_t *axis="X")//Set offset between axis and axis' labels
5768  // Ghf6->GetZaxis()->SetLabelOffset(-0.05);
5769  Ghf6->GetZaxis()->SetLabelSize(0.025);
5770 
5771  Ghf6->SetXTitle(" #eta \b");
5772  Ghf6->SetYTitle(" #phi \b");
5773  Ghf6->SetTitle(
5774  "<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);
5775  //gStyle->SetOptStat(kFALSE);
5776  Ghf6->SetStats(0);
5777  Ghf6->Draw("COLZ");
5778  //================
5779  cRBX31->cd(3);
5780  TH1F *Ghf7 = new TH1F("Ghf7", "", 120, 0.4, 1.6);
5781  // j - etaphi index:
5782  for (int j = 1; j <= ny; j++) {
5783  ccc0HF = Ghf1->GetBinContent(1, j);
5784  if (ccc0HF <= 0.)
5785  for (int i = 1; i <= nx; i++) {
5786  double ccc2 = Ghf1->GetBinContent(i, j);
5787  if (ccc2 > 0.) {
5788  ccc0HF = ccc2;
5789  break;
5790  }
5791  }
5792  if (ccc0HF > 0.) {
5793  // i - # LSs:
5794  for (int i = 1; i <= nx; i++) {
5795  double ccc1 = Ghf1->GetBinContent(i, j);
5796  if (ccc1 > 0.) {
5797  double Rij = ccc1 / ccc0HF;
5798  Ghf7->Fill(Rij);
5799  }
5800  }
5801  }
5802  }
5803  Ghf7->SetMarkerStyle(20);
5804  Ghf7->SetMarkerSize(0.4);
5805  Ghf7->GetYaxis()->SetLabelSize(0.04);
5806  Ghf7->SetMarkerColor(2);
5807  Ghf7->SetLineColor(0);
5808  Ghf7->SetYTitle(" N \b");
5809  Ghf7->SetXTitle(" Rij \b");
5810  Ghf7->SetTitle(" Rij \b");
5811  //Ghf7->SetMinimum(0.8);Ghf7->SetMaximum(500.);
5812  gPad->SetGridy();
5813  gPad->SetGridx(); // gPad->SetLogy();
5814  // Ghf7->SetStats(1110000);
5815  Ghf7->GetYaxis()->SetLabelSize(0.025);
5816  Ghf7->Draw("Error");
5817  Float_t ymaxHF = Ghf7->GetMaximum();
5818  cout << "22HF-3 ymaxHF= " << ymaxHF << " MAXdif3rmsHFMIN= " << MAXdif3rmsHFMIN
5819  << " MINdif3rmsHFMAX= " << MINdif3rmsHFMAX << endl;
5820  TLine *lineHF = new TLine(MAXdif3rmsHFMIN, 0., MAXdif3rmsHFMIN, ymaxHF);
5821  lineHF->SetLineColor(kBlue);
5822  lineHF->Draw();
5823  TLine *line1HF = new TLine(MINdif3rmsHFMAX, 0., MINdif3rmsHFMAX, ymaxHF);
5824  line1HF->SetLineColor(kBlue);
5825  line1HF->Draw();
5826  //================
5828  cRBX31->Update();
5829  cRBX31->Print("RBX-HF-3plots.png");
5830  cRBX31->Clear();
5831  // clean-up
5832  if (Ghf5)
5833  delete Ghf5;
5834  if (Ghf60)
5835  delete Ghf60;
5836  if (Ghf61)
5837  delete Ghf61;
5838  if (Ghf6)
5839  delete Ghf6;
5840  if (Ghf7)
5841  delete Ghf7;
5842 
5843  if (G20hf60)
5844  delete G20hf60;
5845  if (G20hf61)
5846  delete G20hf61;
5847  if (G30hf60)
5848  delete G30hf60;
5849  if (G30hf61)
5850  delete G30hf61;
5851  if (G40hf60)
5852  delete G40hf60;
5853  if (G40hf61)
5854  delete G40hf61;
5855 
5856  if (Ghf1)
5857  delete Ghf1;
5858  //========================================================================================== 22-1 HF:: Ratio plots jeta = 0 - 21 jphi =0 - 17
5859  //======================================================================
5860  //======================================================================28.11.2018
5861  //======================================================================
5862  //======================================================================
5863 
5864  gStyle->SetOptStat(1110000);
5865  cout << " RBX HF Ratio plotsmore *****" << endl;
5866  cRBX31->Clear();
5868  cRBX31->Divide(3, 1);
5869  //================
5870  cRBX31->cd(1);
5871  G20hf6->GetZaxis()->SetLabelSize(0.025);
5872  G20hf6->SetXTitle(" #eta \b");
5873  G20hf6->SetYTitle(" #phi \b");
5874  G20hf6->SetTitle("<Rj> for |1-<R>| > 0.20 \b");
5875  G20hf6->SetStats(0);
5876  G20hf6->Draw("COLZ");
5877  //================
5878  cRBX31->cd(2);
5879  G30hf6->GetZaxis()->SetLabelSize(0.025);
5880  G30hf6->SetXTitle(" #eta \b");
5881  G30hf6->SetYTitle(" #phi \b");
5882  G30hf6->SetTitle("<Rj> for |1-<R>| > 0.30 \b");
5883  G30hf6->SetStats(0);
5884  G30hf6->Draw("COLZ");
5885  //================
5886  cRBX31->cd(3);
5887  G40hf6->GetZaxis()->SetLabelSize(0.025);
5888  G40hf6->SetXTitle(" #eta \b");
5889  G40hf6->SetYTitle(" #phi \b");
5890  G40hf6->SetTitle("<Rj> for |1-<R>| > 0.40 \b");
5891  G40hf6->SetStats(0);
5892  G40hf6->Draw("COLZ");
5893  //================
5894 
5896  cRBX31->Update();
5897  cRBX31->Print("RBX-HF-3plotsmore.png");
5898  cRBX31->Clear();
5899 
5900  // clean-up
5901  if (G20hf6)
5902  delete G20hf6;
5903  if (G30hf6)
5904  delete G30hf6;
5905  if (G40hf6)
5906  delete G40hf6;
5907  gStyle->SetOptStat(0);
5909  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5910  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5911  cout << ">>>>>>>>>>>>>>>>>>>>>>>> " << endl;
5913 
5915 
5917  //=============================================================================== occupancyHB
5918  // For occupancy plots. Produces OccPlots_HBx.png (x=1)
5919  int mymaxbins = MaxLum;
5920  {
5921  cHB->Clear();
5922  cHB->Divide(2, 1);
5924  cHB->cd(1);
5925  TH2F *occhbm = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HBM");
5926  TH1F *uyhbm = new TH1F("uyhbm", "", mymaxbins, 1., mymaxbins + 1.);
5927  for (int i = 1; i <= occhbm->GetXaxis()->GetNbins(); i++) {
5928  double ccc1 = occhbm->GetBinContent(i);
5929  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5930  if (ccc1 > 0.)
5931  uyhbm->Fill(float(i), ccc1);
5932  }
5933  // gPad->SetLogy();
5934  uyhbm->SetMarkerStyle(20);
5935  uyhbm->SetMarkerSize(0.6);
5936  uyhbm->GetYaxis()->SetLabelSize(0.04);
5937  uyhbm->SetXTitle("min/av occupancy - HBM \b");
5938  uyhbm->SetMarkerColor(2);
5939  uyhbm->SetLineColor(0);
5940  uyhbm->SetMaximum(1.0);
5941  uyhbm->SetMinimum(0.2);
5942  gPad->SetGridy();
5943  uyhbm->Draw("Error");
5945  cHB->cd(2);
5946  TH2F *occhbp = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HBP");
5947  TH1F *uyhbp = new TH1F("uyhbp", "", mymaxbins, 1., mymaxbins + 1.);
5948  for (int i = 1; i <= occhbp->GetXaxis()->GetNbins(); i++) {
5949  double ccc1 = occhbp->GetBinContent(i);
5950  // if(ccc1>0.) cout<<" depth1_HB iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5951  if (ccc1 > 0.)
5952  uyhbp->Fill(float(i), ccc1);
5953  }
5954  // gPad->SetLogy();
5955  uyhbp->SetMarkerStyle(20);
5956  uyhbp->SetMarkerSize(0.6);
5957  uyhbp->GetYaxis()->SetLabelSize(0.04);
5958  uyhbp->SetXTitle("min/av occupancy - HBP \b");
5959  uyhbp->SetMarkerColor(2);
5960  uyhbp->SetLineColor(0);
5961  uyhbp->SetMaximum(1.0);
5962  uyhbp->SetMinimum(0.2);
5963  gPad->SetGridy();
5964  uyhbp->Draw("Error");
5966 
5968  cHB->Update();
5969  cHB->Print(Form("OccPlots_HB.png"));
5970  cHB->Clear();
5971 
5972  // clean-up
5973  if (occhbm)
5974  delete occhbm;
5975  if (uyhbm)
5976  delete uyhbm;
5977  if (occhbp)
5978  delete occhbp;
5979  if (uyhbp)
5980  delete uyhbp;
5981  }
5982  //=============================================================================== occupancyHE
5983  // For occupancy plots. Produces OccPlots_HEx.png (x=1)
5984  {
5985  cHB->Clear();
5986  cHB->Divide(2, 1);
5988  cHB->cd(1);
5989  TH2F *occhem = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HEM");
5990  TH1F *uyhem = new TH1F("uyhem", "", mymaxbins, 1., mymaxbins + 1.);
5991  for (int i = 1; i <= occhem->GetXaxis()->GetNbins(); i++) {
5992  double ccc1 = occhem->GetBinContent(i);
5993  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
5994  if (ccc1 > 0.)
5995  uyhem->Fill(float(i), ccc1);
5996  }
5997  // gPad->SetLogy();
5998  uyhem->SetMarkerStyle(20);
5999  uyhem->SetMarkerSize(0.6);
6000  uyhem->GetYaxis()->SetLabelSize(0.04);
6001  uyhem->SetXTitle("min/av occupancy - HEM \b");
6002  uyhem->SetMarkerColor(2);
6003  uyhem->SetLineColor(0);
6004  uyhem->SetMaximum(1.0);
6005  uyhem->SetMinimum(0.2);
6006  gPad->SetGridy();
6007  uyhem->Draw("Error");
6009  cHB->cd(2);
6010  TH2F *occhep = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HEP");
6011  TH1F *uyhep = new TH1F("uyhep", "", mymaxbins, 1., mymaxbins + 1.);
6012  for (int i = 1; i <= occhep->GetXaxis()->GetNbins(); i++) {
6013  double ccc1 = occhep->GetBinContent(i);
6014  // if(ccc1>0.) cout<<" depth1_HE iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6015  if (ccc1 > 0.)
6016  uyhep->Fill(float(i), ccc1);
6017  }
6018  // gPad->SetLogy();
6019  uyhep->SetMarkerStyle(20);
6020  uyhep->SetMarkerSize(0.6);
6021  uyhep->GetYaxis()->SetLabelSize(0.04);
6022  uyhep->SetXTitle("min/av occupancy - HEP \b");
6023  uyhep->SetMarkerColor(2);
6024  uyhep->SetLineColor(0);
6025  uyhep->SetMaximum(1.0);
6026  uyhep->SetMinimum(0.2);
6027  gPad->SetGridy();
6028  uyhep->Draw("Error");
6030 
6032  cHB->Update();
6033  cHB->Print(Form("OccPlots_HE.png"));
6034  cHB->Clear();
6035 
6036  // clean-up
6037  if (occhem)
6038  delete occhem;
6039  if (uyhem)
6040  delete uyhem;
6041  if (occhep)
6042  delete occhep;
6043  if (uyhep)
6044  delete uyhep;
6045  }
6046  //=============================================================================== occupancyHO
6047  // For occupancy plots. Produces OccPlots_HOx.png (x=1)
6048  {
6049  cHB->Clear();
6050  cHB->Divide(2, 1);
6052  cHB->cd(1);
6053  TH2F *occhom = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HOM");
6054  TH1F *uyhom = new TH1F("uyhom", "", mymaxbins, 1., mymaxbins + 1.);
6055  for (int i = 1; i <= occhom->GetXaxis()->GetNbins(); i++) {
6056  double ccc1 = occhom->GetBinContent(i);
6057  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6058  if (ccc1 > 0.)
6059  uyhom->Fill(float(i), ccc1);
6060  }
6061  // gPad->SetLogy();
6062  uyhom->SetMarkerStyle(20);
6063  uyhom->SetMarkerSize(0.6);
6064  uyhom->GetYaxis()->SetLabelSize(0.04);
6065  uyhom->SetXTitle("min/av occupancy - HOM \b");
6066  uyhom->SetMarkerColor(2);
6067  uyhom->SetLineColor(0);
6068  uyhom->SetMaximum(1.0);
6069  uyhom->SetMinimum(0.2);
6070  gPad->SetGridy();
6071  uyhom->Draw("Error");
6073  cHB->cd(2);
6074  TH2F *occhop = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HOP");
6075  TH1F *uyhop = new TH1F("uyhop", "", mymaxbins, 1., mymaxbins + 1.);
6076  for (int i = 1; i <= occhop->GetXaxis()->GetNbins(); i++) {
6077  double ccc1 = occhop->GetBinContent(i);
6078  // if(ccc1>0.) cout<<" depth1_HO iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6079  if (ccc1 > 0.)
6080  uyhop->Fill(float(i), ccc1);
6081  }
6082  // gPad->SetLogy();
6083  uyhop->SetMarkerStyle(20);
6084  uyhop->SetMarkerSize(0.6);
6085  uyhop->GetYaxis()->SetLabelSize(0.04);
6086  uyhop->SetXTitle("min/av occupancy - HOP \b");
6087  uyhop->SetMarkerColor(2);
6088  uyhop->SetLineColor(0);
6089  uyhop->SetMaximum(1.0);
6090  uyhop->SetMinimum(0.2);
6091  gPad->SetGridy();
6092  uyhop->Draw("Error");
6094 
6096  cHB->Update();
6097  cHB->Print(Form("OccPlots_HO.png"));
6098  cHB->Clear();
6099 
6100  // clean-up
6101  if (occhom)
6102  delete occhom;
6103  if (uyhom)
6104  delete uyhom;
6105  if (occhop)
6106  delete occhop;
6107  if (uyhop)
6108  delete uyhop;
6109  }
6110  //=============================================================================== occupancyHF
6111  // For occupancy plots. Produces OccPlots_HFx.png (x=1)
6112  {
6113  cHB->Clear();
6114  cHB->Divide(2, 1);
6116  cHB->cd(1);
6117  TH2F *occhfm = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HFM");
6118  TH1F *uyhfm = new TH1F("uyhfm", "", mymaxbins, 1., mymaxbins + 1.);
6119  for (int i = 1; i <= occhfm->GetXaxis()->GetNbins(); i++) {
6120  double ccc1 = occhfm->GetBinContent(i);
6121  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6122  if (ccc1 > 0.)
6123  uyhfm->Fill(float(i), ccc1);
6124  }
6125  // gPad->SetLogy();
6126  uyhfm->SetMarkerStyle(20);
6127  uyhfm->SetMarkerSize(0.6);
6128  uyhfm->GetYaxis()->SetLabelSize(0.04);
6129  uyhfm->SetXTitle("min/av occupancy - HFM \b");
6130  uyhfm->SetMarkerColor(2);
6131  uyhfm->SetLineColor(0);
6132  uyhfm->SetMaximum(1.0);
6133  uyhfm->SetMinimum(0.2);
6134  gPad->SetGridy();
6135  uyhfm->Draw("Error");
6137  cHB->cd(2);
6138  TH2F *occhfp = (TH2F *)dir->FindObjectAny("h_RatioOccupancy_HFP");
6139  TH1F *uyhfp = new TH1F("uyhfp", "", mymaxbins, 1., mymaxbins + 1.);
6140  for (int i = 1; i <= occhfp->GetXaxis()->GetNbins(); i++) {
6141  double ccc1 = occhfp->GetBinContent(i);
6142  // if(ccc1>0.) cout<<" depth1_HF iLS = "<<i<<" <As> per LS= "<<ccc1<<endl;
6143  if (ccc1 > 0.)
6144  uyhfp->Fill(float(i), ccc1);
6145  }
6146  // gPad->SetLogy();
6147  uyhfp->SetMarkerStyle(20);
6148  uyhfp->SetMarkerSize(0.6);
6149  uyhfp->GetYaxis()->SetLabelSize(0.04);
6150  uyhfp->SetXTitle("min/av occupancy - HFP \b");
6151  uyhfp->SetMarkerColor(2);
6152  uyhfp->SetLineColor(0);
6153  uyhfp->SetMaximum(1.0);
6154  uyhfp->SetMinimum(0.2);
6155  gPad->SetGridy();
6156  uyhfp->Draw("Error");
6158 
6160  cHB->Update();
6161  cHB->Print(Form("OccPlots_HF.png"));
6162  cHB->Clear();
6163 
6164  // clean-up
6165  if (occhfm)
6166  delete occhfm;
6167  if (uyhfm)
6168  delete uyhfm;
6169  if (occhfp)
6170  delete occhfp;
6171  if (uyhfp)
6172  delete uyhfp;
6173  }
6174  std::cout << "************>>> occupancy plots done" << std::endl;
6175 
6180  //************************* ***** Signal *****
6181  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots " << endl;
6182  int maxbins = MaxLum;
6183  cout << ">>>> maxbins = " << maxbins << endl;
6184  TH1F *SummedAmplitudeHisto[4]; // 1d histogramm for subdet
6185  SummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HB");
6186  SummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HE");
6187  SummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HO");
6188  SummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_averSIGNALsumamplitude_HF");
6189  TH1F *SummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6190  SummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HB");
6191  SummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HE");
6192  SummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HO");
6193  SummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_averSIGNALoccupancy_HF");
6194  for (int sub = 0; sub < 4; sub++) {
6195  cHE->Clear();
6196  cHE->Divide(2, 1);
6197  cHE->cd(1);
6198  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6199  // cout<<">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sub = "<< sub <<endl;
6200  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6201  double ccc1 = 0.;
6202  if (SummedAmplitudeHisto[sub])
6203  ccc1 = SummedAmplitudeHisto[sub]->GetBinContent(i);
6204  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6205  if (ccc1 > 0.)
6206  kslpq->Fill(float(i), ccc1);
6207  }
6208  // gPad->SetLogy();
6209  kslpq->SetMarkerStyle(20);
6210  kslpq->SetMarkerSize(0.8);
6211  kslpq->GetYaxis()->SetLabelSize(0.04);
6212  kslpq->SetXTitle("SumA of channels w/ signal per LS \b");
6213  kslpq->SetMarkerColor(2);
6214  kslpq->SetLineColor(0);
6215  // kslpq->SetMinimum(0.8);
6216  gPad->SetGridx();
6217  kslpq->Draw("Error");
6219  cHE->cd(2);
6220  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6221  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6222  double ccc1 = 0.;
6223  if (SummedAmplitudeOccupancyHisto[sub])
6224  ccc1 = SummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6225  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6226  if (ccc1 > 0.)
6227  pqmks->Fill(float(i), ccc1);
6228  }
6229  // gPad->SetLogy();
6230  pqmks->SetMarkerStyle(20);
6231  pqmks->SetMarkerSize(0.8);
6232  pqmks->GetYaxis()->SetLabelSize(0.04);
6233  pqmks->SetXTitle("Occupancy of channels w/ signal per LS \b");
6234  pqmks->SetMarkerColor(4);
6235  pqmks->SetLineColor(0);
6236  // pqmks->SetMinimum(0.8);
6237  gPad->SetGridx();
6238  pqmks->Draw("Error");
6239  cHE->Update();
6240  if (sub == 0)
6241  cHE->Print("SummedAmplitudesSignal_HB.png");
6242  if (sub == 1)
6243  cHE->Print("SummedAmplitudesSignal_HE.png");
6244  if (sub == 2)
6245  cHE->Print("SummedAmplitudesSignal_HO.png");
6246  if (sub == 3)
6247  cHE->Print("SummedAmplitudesSignal_HF.png");
6248  cHE->Clear();
6249  if (kslpq)
6250  delete kslpq;
6251  if (pqmks)
6252  delete pqmks;
6253  } //for
6254  // clean-up
6255  //for (unsigned int i=0; i<4; i++) {delete SummedAmplitudeHisto[i];delete SummedAmplitudeOccupancyHisto[i];}
6256 
6259  //************************* ***** NoSignal *****
6260  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots NoSignal " << endl;
6261  TH1F *NoSignalSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6262  NoSignalSummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HB");
6263  NoSignalSummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HE");
6264  NoSignalSummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HO");
6265  NoSignalSummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALsumamplitude_HF");
6266  TH1F *NoSignalSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6267  NoSignalSummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HB");
6268  NoSignalSummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HE");
6269  NoSignalSummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HO");
6270  NoSignalSummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_averNOSIGNALoccupancy_HF");
6271  for (int sub = 0; sub < 4; sub++) {
6272  cHE->Clear();
6273  cHE->Divide(2, 1);
6274 
6275  cHE->cd(1);
6276  TH1F *kslpq = new TH1F("kslpq", "", maxbins, 1., maxbins + 1.);
6277  for (int i = 1; i <= kslpq->GetXaxis()->GetNbins(); i++) {
6278  double ccc1 = 0.;
6279  if (NoSignalSummedAmplitudeHisto[sub])
6280  ccc1 = NoSignalSummedAmplitudeHisto[sub]->GetBinContent(i);
6281  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6282  if (ccc1 > 0.)
6283  kslpq->Fill(float(i), ccc1);
6284  }
6285  // gPad->SetLogy();
6286  kslpq->SetMarkerStyle(20);
6287  kslpq->SetMarkerSize(0.8);
6288  kslpq->GetYaxis()->SetLabelSize(0.04);
6289  kslpq->SetXTitle("SumA of channels w/o signal per LS \b");
6290  kslpq->SetMarkerColor(2);
6291  kslpq->SetLineColor(0);
6292  if (sub == 0) {
6293  kslpq->SetMaximum(20000.);
6294  kslpq->SetMinimum(5000.);
6295  } else if (sub == 1) {
6296  kslpq->SetMaximum(40000.);
6297  kslpq->SetMinimum(0.);
6298  } else if (sub == 2) {
6299  kslpq->SetMaximum(10000.);
6300  kslpq->SetMinimum(15000.);
6301  } else if (sub == 3) {
6302  kslpq->SetMaximum(100000.);
6303  kslpq->SetMinimum(0.);
6304  }
6305  gPad->SetGridx();
6306  kslpq->Draw("Error");
6308  cHE->cd(2);
6309  TH1F *pqmks = new TH1F("pqmks", "", maxbins, 1., maxbins + 1.);
6310  for (int i = 1; i <= pqmks->GetXaxis()->GetNbins(); i++) {
6311  double ccc1 = 0.;
6312  if (NoSignalSummedAmplitudeOccupancyHisto[sub])
6313  ccc1 = NoSignalSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6314  // if(ccc1>0.) cout<<" iLS = "<<i<<" LS= "<<ccc1<<endl;
6315  if (ccc1 > 0.)
6316  pqmks->Fill(float(i), ccc1);
6317  }
6318  // gPad->SetLogy();
6319  pqmks->SetMarkerStyle(20);
6320  pqmks->SetMarkerSize(0.8);
6321  pqmks->GetYaxis()->SetLabelSize(0.04);
6322  pqmks->SetXTitle("Occupancy of channels w/o signal per LS \b");
6323  pqmks->SetMarkerColor(4);
6324  pqmks->SetLineColor(0);
6325  if (sub == 0) {
6326  pqmks->SetMaximum(600.);
6327  pqmks->SetMinimum(200.);
6328  } else if (sub == 1) {
6329  pqmks->SetMaximum(910.);
6330  pqmks->SetMinimum(10.);
6331  } else if (sub == 2) {
6332  pqmks->SetMaximum(200.);
6333  pqmks->SetMinimum(50.);
6334  } else if (sub == 3) {
6335  pqmks->SetMaximum(866.);
6336  pqmks->SetMinimum(856.);
6337  }
6338  gPad->SetGridx();
6339  pqmks->Draw("Error");
6340  cHE->Update();
6341  if (sub == 0)
6342  cHE->Print("NoSignalSummedAmplitudes_HB.png");
6343  if (sub == 1)
6344  cHE->Print("NoSignalSummedAmplitudes_HE.png");
6345  if (sub == 2)
6346  cHE->Print("NoSignalSummedAmplitudes_HO.png");
6347  if (sub == 3)
6348  cHE->Print("NoSignalSummedAmplitudes_HF.png");
6349  cHE->Clear();
6350  if (kslpq)
6351  delete kslpq;
6352  if (pqmks)
6353  delete pqmks;
6354  } //for
6355  // clean-up
6356  //for (unsigned int i=0; i<4; i++) {delete NoSignalSummedAmplitudeHisto[i];delete NoSignalSummedAmplitudeOccupancyHisto[i];}
6358 
6361  //************************* ***** MaxxValues *****
6362  cout << ">>>>>>>>>>>>>>>>>>>>>>>>start Summed Amplitude Plots Maxx " << endl;
6363  TH1F *MaxxSummedAmplitudeHisto[4]; // 1d histogramm for subdet
6364  MaxxSummedAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HB");
6365  MaxxSummedAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HE");
6366  MaxxSummedAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HO");
6367  MaxxSummedAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_maxxSUMAmpl_HF");
6368  TH1F *MaxxSummedAmplitudeOccupancyHisto[4]; // 1d histogramm for subdet
6369  MaxxSummedAmplitudeOccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HB");
6370  MaxxSummedAmplitudeOccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HE");
6371  MaxxSummedAmplitudeOccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HO");
6372  MaxxSummedAmplitudeOccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_maxxOCCUP_HF");
6373  TH1F *SAmplitudeHisto[4]; // 1d histogramm for subdet
6374  SAmplitudeHisto[0] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HB");
6375  SAmplitudeHisto[1] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HE");
6376  SAmplitudeHisto[2] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HO");
6377  SAmplitudeHisto[3] = (TH1F *)dir->FindObjectAny("h_eventamplitude_HF");
6378  TH1F *OccupancyHisto[4]; // 1d histogramm for subdet
6379  OccupancyHisto[0] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HB");
6380  OccupancyHisto[1] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HE");
6381  OccupancyHisto[2] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HO");
6382  OccupancyHisto[3] = (TH1F *)dir->FindObjectAny("h_eventoccupancy_HF");
6383 
6384  int countamplmaxHB = 0;
6385  int countamplmaxHE = 0;
6386  int countamplmaxHO = 0;
6387  int countamplmaxHF = 0;
6388  int countoccumaxHB = 0;
6389  int countoccumaxHE = 0;
6390  int countoccumaxHO = 0;
6391  int countoccumaxHF = 0;
6392  unsigned long int countamplHB = 0;
6393  unsigned long int countamplHE = 0;
6394  unsigned long int countamplHO = 0;
6395  unsigned long int countamplHF = 0;
6396  unsigned long int countoccuHB = 0;
6397  unsigned long int countoccuHE = 0;
6398  unsigned long int countoccuHO = 0;
6399  unsigned long int countoccuHF = 0;
6400  gStyle->SetOptStat(110000);
6401  for (int sub = 0; sub < 4; sub++) {
6402  cFour->Clear();
6403  cFour->Divide(2, 2);
6404 
6405  cFour->cd(1);
6406  TH1F *lpqxc = new TH1F("lpqxc", "", maxbins, 1., maxbins + 1.);
6407  for (int i = 1; i <= lpqxc->GetXaxis()->GetNbins(); i++) {
6408  double ccc1 = 0.;
6409  if (MaxxSummedAmplitudeHisto[sub])
6410  ccc1 = MaxxSummedAmplitudeHisto[sub]->GetBinContent(i);
6411  // if(ccc1>0.) cout<<"111111111111111111111111111 iLS = "<<i<<" LS= "<<ccc1<<endl;
6412  if (ccc1 > 0.)
6413  lpqxc->Fill(float(i), ccc1);
6414  if (sub == 0 && ccc1 > 60000.)
6415  countamplmaxHB++;
6416  if (sub == 1 && ccc1 > 60000.)
6417  countamplmaxHE++;
6418  if (sub == 2 && ccc1 > 150000.)
6419  countamplmaxHO++;
6420  if (sub == 3 && ccc1 > 22000.)
6421  countamplmaxHF++;
6422  }
6423  // gPad->SetLogy();
6424  lpqxc->SetMarkerStyle(20);
6425  lpqxc->SetMarkerSize(0.8);
6426  // lpqxc->GetYaxis()->SetLabelSize(0.08);
6427  if (sub == 0)
6428  lpqxc->SetXTitle("HB: max SA over LS-events per LS \b");
6429  if (sub == 1)
6430  lpqxc->SetXTitle("HE: max SA over LS-events per LS \b");
6431  if (sub == 2)
6432  lpqxc->SetXTitle("HO: max SA over LS-events per LS \b");
6433  if (sub == 3)
6434  lpqxc->SetXTitle("HF: max SA over LS-events per LS \b");
6435  lpqxc->SetMarkerColor(2);
6436  lpqxc->SetLineColor(0);
6437  gPad->SetGridx();
6438  lpqxc->Draw("Error");
6439 
6441  cFour->cd(2);
6442  TH1F *hpzlm = new TH1F("hpzlm", "", maxbins, 1., maxbins + 1.);
6443  for (int i = 1; i <= hpzlm->GetXaxis()->GetNbins(); i++) {
6444  double ccc1 = 0.;
6445  if (MaxxSummedAmplitudeOccupancyHisto[sub])
6446  ccc1 = MaxxSummedAmplitudeOccupancyHisto[sub]->GetBinContent(i);
6447  // if(ccc1>0.) cout<<"2222222222222222222222222 iLS = "<<i<<" LS= "<<ccc1<<endl;
6448  if (ccc1 > 0.)
6449  hpzlm->Fill(float(i), ccc1);
6450  if (sub == 0 && ccc1 > 2000.)
6451  countoccumaxHB++;
6452  if (sub == 1 && ccc1 > 1200.)
6453  countoccumaxHE++;
6454  if (sub == 2 && ccc1 > 2000.)
6455  countoccumaxHO++;
6456  if (sub == 3 && ccc1 > 860.)
6457  countoccumaxHF++;
6458  }
6459  // gPad->SetLogy();
6460  hpzlm->SetMarkerStyle(20);
6461  hpzlm->SetMarkerSize(0.8);
6462  // hpzlm->GetYaxis()->SetLabelSize(0.08);
6463  if (sub == 0)
6464  hpzlm->SetXTitle("HB: max Occupancy over LS-events per LS \b");
6465  if (sub == 1)
6466  hpzlm->SetXTitle("HE: max Occupancy over LS-events per LS \b");
6467  if (sub == 2)
6468  hpzlm->SetXTitle("HO: max Occupancy over LS-events per LS \b");
6469  if (sub == 3)
6470  hpzlm->SetXTitle("HF: max Occupancy over LS-events per LS \b");
6471  hpzlm->SetMarkerColor(4);
6472  hpzlm->SetLineColor(0);
6473  gPad->SetGridx();
6474  if (sub == 3) {
6475  hpzlm->SetMaximum(866.);
6476  hpzlm->SetMinimum(856.);
6477  }
6478  hpzlm->Draw("Error");
6479 
6481  cFour->cd(3);
6482  gPad->SetLogy();
6483  if (SAmplitudeHisto[sub]) {
6484  for (int i = 1; i <= SAmplitudeHisto[sub]->GetXaxis()->GetNbins(); i++) {
6485  // if(sub==0 && i * 800> 60000.) {
6486  // cout<<">=>=>>=> countamplHB= "<<countamplHB<<" content = "<<SAmplitudeHisto[sub]->GetBinContent(i)<<" sub= "<<sub<<" i= "<<i<< endl;
6487  // countamplHB+=SAmplitudeHisto[sub]->GetBinContent(i);
6488  // }
6489  if (sub == 0 && i * 800 > 60000.)
6490  countamplHB += SAmplitudeHisto[sub]->GetBinContent(i);
6491  if (sub == 1 && i * 1000 > 60000.)
6492  countamplHE += SAmplitudeHisto[sub]->GetBinContent(i);
6493  if (sub == 2 && i * 2500 > 150000.)
6494  countamplHO += SAmplitudeHisto[sub]->GetBinContent(i);
6495  if (sub == 3 && i * 1400 > 22000.)
6496  countamplHF += SAmplitudeHisto[sub]->GetBinContent(i);
6497  }
6498  SAmplitudeHisto[sub]->SetMarkerStyle(20);
6499  SAmplitudeHisto[sub]->SetMarkerSize(0.8);
6500  if (sub == 0)
6501  SAmplitudeHisto[sub]->SetTitle("HB event Amplitude\b");
6502  if (sub == 1)
6503  SAmplitudeHisto[sub]->SetTitle("HE event Amplitude\b");
6504  if (sub == 2)
6505  SAmplitudeHisto[sub]->SetTitle("HO event Amplitude\b");
6506  if (sub == 3)
6507  SAmplitudeHisto[sub]->SetTitle("HF event Amplitude\b");
6508  // SAmplitudeHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6509  SAmplitudeHisto[sub]->SetXTitle("event amplitude \b");
6510  SAmplitudeHisto[sub]->SetMarkerColor(2);
6511  SAmplitudeHisto[sub]->SetLineColor(2);
6512  SAmplitudeHisto[sub]->Draw("");
6513  }
6515  cFour->cd(4);
6516  gPad->SetLogy();
6517  if (OccupancyHisto[sub]) {
6518  for (int i = 1; i <= OccupancyHisto[sub]->GetXaxis()->GetNbins(); i++) {
6519  if (sub == 0 && i * 30 > 2000.)
6520  countoccuHB += OccupancyHisto[sub]->GetBinContent(i);
6521  if (sub == 1 && i * 20 > 1200.)
6522  countoccuHE += OccupancyHisto[sub]->GetBinContent(i);
6523  if (sub == 2 && i * 25 > 2000.)
6524  countoccuHO += OccupancyHisto[sub]->GetBinContent(i);
6525  if (sub == 3 && i * 10 > 860.)
6526  countoccuHF += OccupancyHisto[sub]->GetBinContent(i);
6527  }
6528  OccupancyHisto[sub]->SetMarkerStyle(20);
6529  OccupancyHisto[sub]->SetMarkerSize(0.8);
6530  if (sub == 0)
6531  OccupancyHisto[sub]->SetTitle("HB event Occupancy\b");
6532  if (sub == 1)
6533  OccupancyHisto[sub]->SetTitle("HE event Occupancy\b");
6534  if (sub == 2)
6535  OccupancyHisto[sub]->SetTitle("HO event Occupancy\b");
6536  if (sub == 3)
6537  OccupancyHisto[sub]->SetTitle("HF event Occupancy\b");
6538  // OccupancyHisto[sub]->GetYaxis()->SetLabelSize(0.08);
6539  OccupancyHisto[sub]->SetXTitle("event occupancy \b");
6540  OccupancyHisto[sub]->SetMarkerColor(4);
6541  OccupancyHisto[sub]->SetLineColor(4);
6542  OccupancyHisto[sub]->Draw("");
6543  }
6544 
6545  cFour->Update();
6546  if (sub == 0)
6547  cFour->Print("MaxxSummedAmplitudes_HB.png");
6548  if (sub == 1)
6549  cFour->Print("MaxxSummedAmplitudes_HE.png");
6550  if (sub == 2)
6551  cFour->Print("MaxxSummedAmplitudes_HO.png");
6552  if (sub == 3)
6553  cFour->Print("MaxxSummedAmplitudes_HF.png");
6554  cFour->Clear();
6555  if (lpqxc)
6556  delete lpqxc;
6557  if (hpzlm)
6558  delete hpzlm;
6559  } //for
6560  gStyle->SetOptStat(0);
6562  cout << ">=>=>>=> countamplmaxHB= " << countamplmaxHB << " countamplmaxHE= " << countamplmaxHE
6563  << " countamplmaxHO= " << countamplmaxHO << " countamplmaxHF= " << countamplmaxHF << endl;
6564  cout << ">=>=>>=> countoccumaxHB= " << countoccumaxHB << " countoccumaxHE= " << countoccumaxHE
6565  << " countoccumaxHO= " << countoccumaxHO << " countoccumaxHF= " << countoccumaxHF << endl;
6566  cout << ">=>=>>=> countamplHB= " << countamplHB << " countamplHE= " << countamplHE << " countamplHO= " << countamplHO
6567  << " countamplHF= " << countamplHF << endl;
6568  cout << ">=>=>>=> countoccuHB= " << countoccuHB << " countoccuHE= " << countoccuHE << " countoccuHO= " << countoccuHO
6569  << " countoccuHF= " << countoccuHF << endl;
6570 
6573  //************************* ***** channelsummedA over depths *****
6574  cout << ">>>>>>>>>>>>>>>>>>>>>>>>channelsummedA over depths " << endl;
6575  TH1F *ChannelDepthsummedAmplitudesPlots[4]; // 1d histogramm for subdet
6576  ChannelDepthsummedAmplitudesPlots[0] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HB");
6577  ChannelDepthsummedAmplitudesPlots[1] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HE");
6578  ChannelDepthsummedAmplitudesPlots[2] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HO");
6579  ChannelDepthsummedAmplitudesPlots[3] = (TH1F *)dir->FindObjectAny("h_sumamplitudechannel_HF");
6580  TLine *litebdt[4];
6581  if (ChannelDepthsummedAmplitudesPlots[0])
6582  litebdt[0] = new TLine(80., 0.8, 80., ChannelDepthsummedAmplitudesPlots[0]->GetBinContent(4) + 100.);
6583  if (ChannelDepthsummedAmplitudesPlots[1])
6584  litebdt[1] = new TLine(200., 0.8, 200., ChannelDepthsummedAmplitudesPlots[1]->GetBinContent(7) + 100.);
6585  if (ChannelDepthsummedAmplitudesPlots[2])
6586  litebdt[2] = new TLine(1200., 0.8, 1200., ChannelDepthsummedAmplitudesPlots[2]->GetBinContent(17) + 100.);
6587  if (ChannelDepthsummedAmplitudesPlots[3])
6588  litebdt[3] = new TLine(600., 0.8, 600., ChannelDepthsummedAmplitudesPlots[3]->GetBinContent(6) + 100.);
6589 
6590  gStyle->SetOptStat(110000);
6591  cFour1->Clear();
6592  cFour1->Divide(2, 2);
6593  for (int sub = 0; sub < 4; sub++) {
6594  if (sub == 0)
6595  cFour1->cd(1);
6596  if (sub == 1)
6597  cFour1->cd(2);
6598  if (sub == 2)
6599  cFour1->cd(3);
6600  if (sub == 3)
6601  cFour1->cd(4);
6602  gPad->SetLogy();
6603  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerStyle(20);
6604  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerSize(0.8);
6605  if (sub == 0)
6606  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HB channel Amplitudes\b");
6607  if (sub == 1)
6608  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HE channel Amplitudes\b");
6609  if (sub == 2)
6610  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HO channel Amplitudes\b");
6611  if (sub == 3)
6612  ChannelDepthsummedAmplitudesPlots[sub]->SetTitle("HF channel Amplitudes\b");
6613  if (sub == 0)
6614  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HB channel depths summed Amplitudes \b");
6615  if (sub == 1)
6616  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HE channel depths summed Amplitudes \b");
6617  if (sub == 2)
6618  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HO channel depths summed Amplitudes \b");
6619  if (sub == 3)
6620  ChannelDepthsummedAmplitudesPlots[sub]->SetXTitle("HF channel depths summed Amplitudes \b");
6621  ChannelDepthsummedAmplitudesPlots[sub]->SetMarkerColor(2);
6622  ChannelDepthsummedAmplitudesPlots[sub]->SetLineColor(2);
6623  ChannelDepthsummedAmplitudesPlots[sub]->Draw("");
6624  litebdt[sub]->SetLineColor(kBlue);
6625  litebdt[sub]->Draw("s");
6626  } //for
6627  cFour1->Update();
6628  cFour1->Print("ChannelDepthsummedAmplitudes.png");
6629  cFour1->Clear();
6630  gStyle->SetOptStat(0);
6631 
6634  //************************* ***** Ataildepth1_HB *****
6635  cout << ">>>>>>>>>>>>>>>>>>>>>>>>2DAtaildepth " << endl;
6637  cHB->Clear();
6638  cHB->Divide(2, 1);
6639 
6640  TH2F *DAtaildepth1[2]; // 1d histogramm for subdet
6641  DAtaildepth1[0] = (TH2F *)dir->FindObjectAny("h_2DAtaildepth1_HB");
6642  DAtaildepth1[1] = (TH2F *)dir->FindObjectAny("h_2D0Ataildepth1_HB");
6643  cHB->cd(1);
6644  if (!DAtaildepth1[0] || !DAtaildepth1[1]) {
6645  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 1" << endl;
6646  } else {
6647  TH2F *tail1 = (TH2F *)DAtaildepth1[0]->Clone("tail1");
6648  tail1->Divide(DAtaildepth1[0], DAtaildepth1[1], 1, 1, "B");
6649  // tail1->Sumw2();
6650  gPad->SetGridy();
6651  gPad->SetGridx();
6652  gPad->SetLogz();
6653  tail1->SetMarkerStyle(20);
6654  tail1->SetMarkerSize(0.4);
6655  tail1->SetTitle("Amplitudes for tail-events (HBdepth1) \b");
6656  tail1->SetXTitle("#eta \b");
6657  tail1->SetYTitle("#phi \b");
6658  tail1->SetZTitle("2D <A> in the tail - HB Depth1 \b");
6659  tail1->SetMarkerColor(2);
6660  tail1->SetLineColor(2);
6661  tail1->Draw("COLZ");
6662  }
6663  TH2F *DAtaildepth2[2]; // 1d histogramm for subdet
6664  DAtaildepth2[0] = (TH2F *)dir->FindObjectAny("h_2DAtaildepth2_HB");
6665  DAtaildepth2[1] = (TH2F *)dir->FindObjectAny("h_2D0Ataildepth2_HB");
6666  cHB->cd(2);
6667  if (!DAtaildepth2[0] || !DAtaildepth2[1]) {
6668  cout << ">>>>>>>>>>>>>>>>>>>>>>>>Ataildepth1_HB EMPTY histoes for 2DAtaildepth 2" << endl;
6669  } else {
6670  TH2F *tail2 = (TH2F *)DAtaildepth2[0]->Clone("tail2");
6671  tail2->Divide(DAtaildepth2[0], DAtaildepth2[1], 1, 1, "B");
6672  // tail2->Sumw2();
6673  gPad->SetGridy();
6674  gPad->SetGridx();
6675  gPad->SetLogz();
6676  tail2->SetMarkerStyle(20);
6677  tail2->SetMarkerSize(0.4);
6678  tail2->SetTitle("Amplitudes for tail-events (HBdepth2) \b");
6679  tail2->SetXTitle("#eta \b");
6680  tail2->SetYTitle("#phi \b");
6681  tail2->SetZTitle("2D <A> in the tail - HB Depth2 \b");
6682  tail2->SetMarkerColor(2);
6683  tail2->SetLineColor(2);
6684  tail2->Draw("COLZ");
6685  }
6686 
6687  cHB->Update();
6688  cHB->Print("AtaildepthHB.png");
6689  cHB->Clear();
6690 
6693  //************************* ***** sum(Signal+NoSignal) occupancy for HF *****
6694  cout << ">>>>>>>>>>>>>>>>>>>>>>>>sumOccupancyHF " << endl;
6696  cHB->Clear();
6697  cHB->Divide(1, 1);
6698  cHB->cd(1);
6699  if (SummedAmplitudeOccupancyHisto[3]) {
6700  TH1F *ufrew1 = (TH1F *)SummedAmplitudeOccupancyHisto[3]->Clone("ufrew1");
6701  if (SummedAmplitudeOccupancyHisto[3] && NoSignalSummedAmplitudeOccupancyHisto[3])
6702  ufrew1->Add(SummedAmplitudeOccupancyHisto[3], NoSignalSummedAmplitudeOccupancyHisto[3], 1, 1);
6703  ufrew1->GetXaxis()->SetRangeUser(1., maxbins + 1.);
6704  gPad->SetGridx();
6705  ufrew1->SetMarkerStyle(20);
6706  ufrew1->SetMarkerSize(0.8);
6707  ufrew1->GetYaxis()->SetLabelSize(0.04);
6708  ufrew1->SetTitle("HF Occupancy vs LS\b");
6709  ufrew1->SetXTitle("average occupancy per LS HF\b");
6710  ufrew1->SetMarkerColor(4);
6711  ufrew1->SetLineColor(0);
6712  ufrew1->SetMaximum(866.);
6713  ufrew1->SetMinimum(856.);
6714  ufrew1->Draw("Error");
6715  cHB->Update();
6716  cHB->Print("sumOccupancyHF.png");
6717  cHB->Clear();
6718  if (ufrew1)
6719  delete ufrew1;
6720  }
6721 
6729  //====================================================================================================================
6730  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =====================================================================" << endl;
6731 
6732  //=====================================================================================================
6733  cout << ">>>>>>>>>>>>>>>>>>>>>>>> ==================================================" << endl;
6734 
6735  //=====================================================================================
6736  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6737  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6738  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6739  cout << ">>>>>>>>>>>>>>>>>>>>>>>> =================================" << endl;
6740 
6741  cout << ">>>>>>> START NOW CREATING OF HTML PAGES <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<" << endl;
6742  //======================================================================
6743  // Creating each test kind for each subdet html pages:
6744  std::string raw_class;
6745  int ind = 0;
6746  ofstream htmlFile;
6747  for (int test = 0; test <= 5; test++) { //Test: 0,
6748  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
6749 
6750  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
6751  if (test == 0) {
6752  if (sub == 1) {
6753  htmlFile.open("HB_CapID.html");
6754  }
6755  if (sub == 2) {
6756  htmlFile.open("HE_CapID.html");
6757  }
6758  if (sub == 3) {
6759  htmlFile.open("HO_CapID.html");
6760  }
6761  if (sub == 4) {
6762  htmlFile.open("HF_CapID.html");
6763  }
6764  }
6765  if (test == 1) {
6766  if (sub == 1) {
6767  htmlFile.open("HB_ADCampl.html");
6768  }
6769  if (sub == 2) {
6770  htmlFile.open("HE_ADCampl.html");
6771  }
6772  if (sub == 3) {
6773  htmlFile.open("HO_ADCampl.html");
6774  }
6775  if (sub == 4) {
6776  htmlFile.open("HF_ADCampl.html");
6777  }
6778  }
6779  if (test == 2) {
6780  if (sub == 1) {
6781  htmlFile.open("HB_Width.html");
6782  }
6783  if (sub == 2) {
6784  htmlFile.open("HE_Width.html");
6785  }
6786  if (sub == 3) {
6787  htmlFile.open("HO_Width.html");
6788  }
6789  if (sub == 4) {
6790  htmlFile.open("HF_Width.html");
6791  }
6792  }
6793  if (test == 3) {
6794  if (sub == 1) {
6795  htmlFile.open("HB_Ratio.html");
6796  }
6797  if (sub == 2) {
6798  htmlFile.open("HE_Ratio.html");
6799  }
6800  if (sub == 3) {
6801  htmlFile.open("HO_Ratio.html");
6802  }
6803  if (sub == 4) {
6804  htmlFile.open("HF_Ratio.html");
6805  }
6806  }
6807  if (test == 4) {
6808  if (sub == 1) {
6809  htmlFile.open("HB_Tmean.html");
6810  }
6811  if (sub == 2) {
6812  htmlFile.open("HE_Tmean.html");
6813  }
6814  if (sub == 3) {
6815  htmlFile.open("HO_Tmean.html");
6816  }
6817  if (sub == 4) {
6818  htmlFile.open("HF_Tmean.html");
6819  }
6820  }
6821  if (test == 5) {
6822  if (sub == 1) {
6823  htmlFile.open("HB_Tmax.html");
6824  }
6825  if (sub == 2) {
6826  htmlFile.open("HE_Tmax.html");
6827  }
6828  if (sub == 3) {
6829  htmlFile.open("HO_Tmax.html");
6830  }
6831  if (sub == 4) {
6832  htmlFile.open("HF_Tmax.html");
6833  }
6834  }
6835 
6836  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
6837  htmlFile << "<head>" << std::endl;
6838  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
6839  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
6840  htmlFile << "<style type=\"text/css\">" << std::endl;
6841  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
6842  << std::endl;
6843  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
6844  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
6845  "text-align: center;}"
6846  << std::endl;
6847  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
6848  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
6849  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
6850  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
6851  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
6852  htmlFile << "</style>" << std::endl;
6853  htmlFile << "<body>" << std::endl;
6854 
6855  if (test == 0) {
6856  if (sub == 1)
6857  htmlFile << "<h1> Cap ID estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6858  if (sub == 2)
6859  htmlFile << "<h1> Cap ID estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6860  if (sub == 3)
6861  htmlFile << "<h1> Cap ID estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6862  if (sub == 4)
6863  htmlFile << "<h1> Cap ID estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6864  }
6865  if (test == 1) {
6866  if (sub == 1)
6867  htmlFile << "<h1> Mean ADC Amplitude estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6868  if (sub == 2)
6869  htmlFile << "<h1> Mean ADC Amplitude estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6870  if (sub == 3)
6871  htmlFile << "<h1> Mean ADC Amplitude estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6872  if (sub == 4)
6873  htmlFile << "<h1> Mean ADC Amplitude estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6874  }
6875  if (test == 2) {
6876  if (sub == 1)
6877  htmlFile << "<h1> Width estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6878  if (sub == 2)
6879  htmlFile << "<h1> Width estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6880  if (sub == 3)
6881  htmlFile << "<h1> Width estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6882  if (sub == 4)
6883  htmlFile << "<h1> Width estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6884  }
6885  if (test == 3) {
6886  if (sub == 1)
6887  htmlFile << "<h1> Ratio estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6888  if (sub == 2)
6889  htmlFile << "<h1> Ratio estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6890  if (sub == 3)
6891  htmlFile << "<h1> Ratio estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6892  if (sub == 4)
6893  htmlFile << "<h1> Ratio estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6894  }
6895  if (test == 4) {
6896  if (sub == 1)
6897  htmlFile << "<h1> Mean bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6898  if (sub == 2)
6899  htmlFile << "<h1> Mean bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6900  if (sub == 3)
6901  htmlFile << "<h1> Mean bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6902  if (sub == 4)
6903  htmlFile << "<h1> Mean bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6904  }
6905  if (test == 5) {
6906  if (sub == 1)
6907  htmlFile << "<h1> Maximum bin timing estimator for HB, RUN = " << runnumber << " </h1>" << std::endl;
6908  if (sub == 2)
6909  htmlFile << "<h1> Maximum bin timing estimator for HE, RUN = " << runnumber << " </h1>" << std::endl;
6910  if (sub == 3)
6911  htmlFile << "<h1> Maximum bin timing estimator for HO, RUN = " << runnumber << " </h1>" << std::endl;
6912  if (sub == 4)
6913  htmlFile << "<h1> Maximum bin timing estimator for HF, RUN = " << runnumber << " </h1>" << std::endl;
6914  }
6915 
6916  if (test == 1) {
6917  htmlFile << "<a name=\"Top\"></a>\n";
6918  htmlFile << "<b>Contents:<br>\n";
6919  htmlFile << "1. <a href=\"#Aij\">A_ij_LS (averaged over events in LS) </a><br>\n";
6920  htmlFile << "2. <a href=\"#OverflowAij\">A_ij_LS in overflow & underflow</a><br>\n";
6921  htmlFile << "3. <a href=\"#MainEstimator\">Main Estimator !!! </a><br>\n";
6922  htmlFile << "4. <a href=\"#ErrorA\">Error type A </a><br>\n";
6923  htmlFile << "5. <a href=\"#ErrorAaverage\">ErrorA cross check</a><br>\n";
6924  htmlFile << "6. <a href=\"#ErrorAoccupancy\">ErrorA occupancy plots</a><br>\n";
6925  htmlFile << "7. <a href=\"#ErrorB\">Error type B</a><br>\n";
6926  htmlFile << "8. <a href=\"#LSstatus\">Table of Average channel-Amplitude in Depthes over LSs </a><br>\n";
6927  htmlFile << "9. <a href=\"#RBXstatus\">RBX Status </a><br>\n";
6928  htmlFile << "10. <a href=\"#RBXPHItable\">Table of Average RBX-Amplitude in Phi over LSs </a><br>\n";
6929  htmlFile << "11. <a href=\"#RBXETAtable\">Table of Average RBX-Amplitude in Eta over LSs </a><br>\n";
6930  htmlFile << "12. <a href=\"#RBX3plots\">RBX A-Ratio to 1st LS: 3 plots </a><br>\n";
6932  }
6933 
6934  // htmlFile << "<a href=\"#Top\">to top</a><br>\n";
6935 
6936  htmlFile << "<br>" << std::endl;
6937  if (test == 0) {
6938  htmlFile << "<h2> 0. Rate of CapID failures over all events of Run </h2>" << std::endl;
6939  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
6940  if (sub == 1)
6941  htmlFile << " <img src=\"MapCapIdErrorHB.png\" />" << std::endl;
6942  if (sub == 2)
6943  htmlFile << " <img src=\"MapCapIdErrorHE.png\" />" << std::endl;
6944  if (sub == 3)
6945  htmlFile << " <img src=\"MapCapIdErrorHO.png\" />" << std::endl;
6946  if (sub == 4)
6947  htmlFile << " <img src=\"MapCapIdErrorHF.png\" />" << std::endl;
6948  }
6949  if (test == 1)
6950  htmlFile << "<a name=\"Aij\"></a>\n";
6951  if (test != 0)
6952  htmlFile << "<h2> 1. Distribution of estimator averaged over events in LS, histogramed over all channels and "
6953  "all LSs (only few depthes shown as example) </h2>"
6954  << std::endl;
6955  if (test == 0) {
6956  if (sub == 1)
6957  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6958  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6959  if (sub == 2)
6960  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6961  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2), " << CutAb[sub][3]
6962  << " (Depth3).</h2>" << std::endl;
6963  if (sub == 3)
6964  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6965  << CutAb[sub][1] << " (Depth4).</h2>" << std::endl;
6966  if (sub == 4)
6967  htmlFile << "<h2> 1. Average Nbcs for only LS containing events with abnormal number of Bad channels >"
6968  << CutAb[sub][1] << " (Depth1), " << CutAb[sub][2] << " (Depth2).</h2>" << std::endl;
6969  }
6970 
6971  if (test != 0)
6972  htmlFile << "<h3> see Overflow and Underflow </h3>" << std::endl;
6973  if (test == 0)
6974  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
6975 
6976  if (test == 0) {
6977  if (sub == 1)
6978  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HB.png\" />" << std::endl;
6979  if (sub == 2)
6980  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HE.png\" />" << std::endl;
6981  if (sub == 3)
6982  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HO.png\" />" << std::endl;
6983  if (sub == 4)
6984  htmlFile << " <img src=\"Hist_CAPID_Abnorm_HF.png\" />" << std::endl;
6985  }
6986  if (test == 1) {
6987  if (sub == 1)
6988  htmlFile << " <img src=\"H_ADCamplHB.png\" />" << std::endl;
6989  if (sub == 2)
6990  htmlFile << " <img src=\"H_ADCamplHE.png\" />" << std::endl;
6991  if (sub == 3)
6992  htmlFile << " <img src=\"H_ADCamplHO.png\" />" << std::endl;
6993  if (sub == 4)
6994  htmlFile << " <img src=\"H_ADCamplHF.png\" />" << std::endl;
6995  }
6996  if (test == 2) {
6997  if (sub == 1)
6998  htmlFile << " <img src=\"H_WidthHB.png\" />" << std::endl;
6999  if (sub == 2)
7000  htmlFile << " <img src=\"H_WidthHE.png\" />" << std::endl;
7001  if (sub == 3)
7002  htmlFile << " <img src=\"H_WidthHO.png\" />" << std::endl;
7003  if (sub == 4)
7004  htmlFile << " <img src=\"H_WidthHF.png\" />" << std::endl;
7005  }
7006  if (test == 3) {
7007  if (sub == 1)
7008  htmlFile << " <img src=\"H_RatioHB.png\" />" << std::endl;
7009  if (sub == 2)
7010  htmlFile << " <img src=\"H_RatioHE.png\" />" << std::endl;
7011  if (sub == 3)
7012  htmlFile << " <img src=\"H_RatioHO.png\" />" << std::endl;
7013  if (sub == 4)
7014  htmlFile << " <img src=\"H_RatioHF.png\" />" << std::endl;
7015  }
7016  if (test == 4) {
7017  if (sub == 1)
7018  htmlFile << " <img src=\"H_TmeanHB.png\" />" << std::endl;
7019  if (sub == 2)
7020  htmlFile << " <img src=\"H_TmeanHE.png\" />" << std::endl;
7021  if (sub == 3)
7022  htmlFile << " <img src=\"H_TmeanHO.png\" />" << std::endl;
7023  if (sub == 4)
7024  htmlFile << " <img src=\"H_TmeanHF.png\" />" << std::endl;
7025  }
7026  if (test == 5) {
7027  if (sub == 1)
7028  htmlFile << " <img src=\"H_TmaxHB.png\" />" << std::endl;
7029  if (sub == 2)
7030  htmlFile << " <img src=\"H_TmaxHE.png\" />" << std::endl;
7031  if (sub == 3)
7032  htmlFile << " <img src=\"H_TmaxHO.png\" />" << std::endl;
7033  if (sub == 4)
7034  htmlFile << " <img src=\"H_TmaxHF.png\" />" << std::endl;
7035  }
7036  htmlFile << "<br>" << std::endl;
7037  if (test == 1)
7038  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7039 
7040  if (test == 0)
7041  htmlFile << "<h2> 2a. Number of bad channels per event distribution in Run</h2>" << std::endl;
7042  if (test == 0)
7043  htmlFile << "<h3> Legends: dots correspond to BAD LS candidates. </h3>" << std::endl;
7044  if (test == 0) {
7045  if (sub == 1)
7046  htmlFile << " <img src=\"HistNBadChsHB.png\" />" << std::endl;
7047  if (sub == 2)
7048  htmlFile << " <img src=\"HistNBadChsHE.png\" />" << std::endl;
7049  if (sub == 3)
7050  htmlFile << " <img src=\"HistNBadChsHO.png\" />" << std::endl;
7051  if (sub == 4)
7052  htmlFile << " <img src=\"HistNBadChsHF.png\" />" << std::endl;
7053  }
7054 
7055  if (test == 1)
7056  htmlFile << "<a name=\"OverflowAij\"></a>\n";
7057  if (test != 0)
7058  htmlFile << "<h2> 2. Estimator averaged over all events in the RUN for entries in overflow and underflow of "
7059  "corresponding histogram above (only few depthes shown as example) </h2>"
7060  << std::endl;
7061  // if (test !=0) htmlFile << "<h2> 2. Estimator averaged over all events in the RUN </h2>"<< std::endl;
7062  if (test == 0)
7063  htmlFile << "<h2> 2b. Averaged number of bad channels for each LS </h2>" << std::endl;
7064  // if (test !=0) htmlFile << "<h3> Channel legend: white - good, other colour - bad. </h3>"<< std::endl;
7065  if (test == 0) {
7066  if (sub == 1)
7067  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7068  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7069  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7070  if (sub == 2)
7071  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7072  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3) correspond BAD LS.</h3>"
7073  << std::endl;
7074  if (sub == 3)
7075  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7076  << " (Depth4) correspond BAD LS.</h3>" << std::endl;
7077  if (sub == 4)
7078  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7079  << Cut0[test][sub][2] << " (Depth2) correspond BAD LS.</h3>" << std::endl;
7080  }
7081  if (test == 0) {
7082  if (sub == 1)
7083  htmlFile << " <img src=\"HistNBCMNHB.png\" />" << std::endl;
7084  if (sub == 2)
7085  htmlFile << " <img src=\"HistNBCMNHE.png\" />" << std::endl;
7086  if (sub == 3)
7087  htmlFile << " <img src=\"HistNBCMNHO.png\" />" << std::endl;
7088  if (sub == 4)
7089  htmlFile << " <img src=\"HistNBCMNHF.png\" />" << std::endl;
7090  }
7091  if (test == 1) {
7092  if (sub == 1)
7093  htmlFile << " <img src=\"MapADCamplHB.png\" />" << std::endl;
7094  if (sub == 2)
7095  htmlFile << " <img src=\"MapADCamplHE.png\" />" << std::endl;
7096  if (sub == 3)
7097  htmlFile << " <img src=\"MapADCamplHO.png\" />" << std::endl;
7098  if (sub == 4)
7099  htmlFile << " <img src=\"MapADCamplHF.png\" />" << std::endl;
7100  }
7101  if (test == 2) {
7102  if (sub == 1)
7103  htmlFile << " <img src=\"MapWidthHB.png\" />" << std::endl;
7104  if (sub == 2)
7105  htmlFile << " <img src=\"MapWidthHE.png\" />" << std::endl;
7106  if (sub == 3)
7107  htmlFile << " <img src=\"MapWidthHO.png\" />" << std::endl;
7108  if (sub == 4)
7109  htmlFile << " <img src=\"MapWidthHF.png\" />" << std::endl;
7110  }
7111  if (test == 3) {
7112  if (sub == 1)
7113  htmlFile << " <img src=\"MapRatioHB.png\" />" << std::endl;
7114  if (sub == 2)
7115  htmlFile << " <img src=\"MapRatioHE.png\" />" << std::endl;
7116  if (sub == 3)
7117  htmlFile << " <img src=\"MapRatioHO.png\" />" << std::endl;
7118  if (sub == 4)
7119  htmlFile << " <img src=\"MapRatioHF.png\" />" << std::endl;
7120  }
7121  if (test == 4) {
7122  if (sub == 1)
7123  htmlFile << " <img src=\"MapTmeanHB.png\" />" << std::endl;
7124  if (sub == 2)
7125  htmlFile << " <img src=\"MapTmeanHE.png\" />" << std::endl;
7126  if (sub == 3)
7127  htmlFile << " <img src=\"MapTmeanHO.png\" />" << std::endl;
7128  if (sub == 4)
7129  htmlFile << " <img src=\"MapTmeanHF.png\" />" << std::endl;
7130  }
7131  if (test == 5) {
7132  if (sub == 1)
7133  htmlFile << " <img src=\"MapTmaxHB.png\" />" << std::endl;
7134  if (sub == 2)
7135  htmlFile << " <img src=\"MapTmaxHE.png\" />" << std::endl;
7136  if (sub == 3)
7137  htmlFile << " <img src=\"MapTmaxHO.png\" />" << std::endl;
7138  if (sub == 4)
7139  htmlFile << " <img src=\"MapTmaxHF.png\" />" << std::endl;
7140  }
7141  htmlFile << "<br>" << std::endl;
7142  if (test == 1)
7143  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7144 
7145  if (test == 1)
7146  htmlFile << "<a name=\"MainEstimator\"></a>\n";
7147  if (test != 0)
7148  htmlFile
7149  << "<h2> 3. Distribution of estimator averaged over events in LS and over all channels for each LS </h2>"
7150  << std::endl;
7151  if (test == 0) {
7152  if (sub == 1)
7153  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7154  << " (Depth2) in each LS.</h2>" << std::endl;
7155  if (sub == 2)
7156  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7157  << " (Depth2), " << CutPo[sub][3] << " (Depth3) in each LS.</h2>" << std::endl;
7158  if (sub == 3)
7159  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][4] << " (Depth4) in each LS.</h2>"
7160  << std::endl;
7161  if (sub == 4)
7162  htmlFile << "<h2> 3. Portion of events with Nbcs>" << CutPo[sub][1] << " (Depth1), " << CutPo[sub][2]
7163  << " (Depth2) in each LS.</h2>" << std::endl;
7164  htmlFile << "<h3> Legend: dots correspond to BAD LS candidates.</h3>" << std::endl;
7165  }
7166  if (test != 0) {
7167  if (sub == 1)
7168  htmlFile << "<h3> Legends: dots selected with following cuts: <td class=\"s6\" align=\"center\">"
7169  << Cut0[test][sub][1] << " (Depth1), " << Cut0[test][sub][2]
7170  << " (Depth2) correspond BAD LS.</td></h3>" << std::endl;
7171  if (sub == 2)
7172  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7173  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7174  << " (Depth4), " << Cut0[test][sub][5] << " (Depth5), " << Cut0[test][sub][6] << " (Depth6), "
7175  << Cut0[test][sub][7] << " (Depth7) correspond BAD LS. </h3>" << std::endl;
7176  if (sub == 3)
7177  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][4]
7178  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7179  if (sub == 4)
7180  htmlFile << "<h3> Legends: dots selected with following cuts: " << Cut0[test][sub][1] << " (Depth1), "
7181  << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), " << Cut0[test][sub][4]
7182  << " (Depth4) correspond BAD LS. </h3>" << std::endl;
7183  }
7184  if (test == 0) {
7185  if (sub == 1)
7186  htmlFile << " <img src=\"HistPortHB.png\" />" << std::endl;
7187  if (sub == 2)
7188  htmlFile << " <img src=\"HistPortHE.png\" />" << std::endl;
7189  if (sub == 3)
7190  htmlFile << " <img src=\"HistPortHO.png\" />" << std::endl;
7191  if (sub == 4)
7192  htmlFile << " <img src=\"HistPortHF.png\" />" << std::endl;
7193  }
7194  if (test == 1) {
7195  if (sub == 1)
7196  htmlFile << " <img src=\"HistADCamplHB.png\" />" << std::endl;
7197  if (sub == 2)
7198  htmlFile << " <img src=\"HistADCamplHE.png\" />" << std::endl;
7199  if (sub == 3)
7200  htmlFile << " <img src=\"HistADCamplHO.png\" />" << std::endl;
7201  if (sub == 4)
7202  htmlFile << " <img src=\"HistADCamplHF.png\" />" << std::endl;
7203  }
7204  if (test == 2) {
7205  if (sub == 1)
7206  htmlFile << " <img src=\"HistWidthHB.png\" />" << std::endl;
7207  if (sub == 2)
7208  htmlFile << " <img src=\"HistWidthHE.png\" />" << std::endl;
7209  if (sub == 3)
7210  htmlFile << " <img src=\"HistWidthHO.png\" />" << std::endl;
7211  if (sub == 4)
7212  htmlFile << " <img src=\"HistWidthHF.png\" />" << std::endl;
7213  }
7214  if (test == 3) {
7215  if (sub == 1)
7216  htmlFile << " <img src=\"HistRatioHB.png\" />" << std::endl;
7217  if (sub == 2)
7218  htmlFile << " <img src=\"HistRatioHE.png\" />" << std::endl;
7219  if (sub == 3)
7220  htmlFile << " <img src=\"HistRatioHO.png\" />" << std::endl;
7221  if (sub == 4)
7222  htmlFile << " <img src=\"HistRatioHF.png\" />" << std::endl;
7223  }
7224  if (test == 4) {
7225  if (sub == 1)
7226  htmlFile << " <img src=\"HistTmeanHB.png\" />" << std::endl;
7227  if (sub == 2)
7228  htmlFile << " <img src=\"HistTmeanHE.png\" />" << std::endl;
7229  if (sub == 3)
7230  htmlFile << " <img src=\"HistTmeanHO.png\" />" << std::endl;
7231  if (sub == 4)
7232  htmlFile << " <img src=\"HistTmeanHF.png\" />" << std::endl;
7233  }
7234  if (test == 5) {
7235  if (sub == 1)
7236  htmlFile << " <img src=\"HistTmaxHB.png\" />" << std::endl;
7237  if (sub == 2)
7238  htmlFile << " <img src=\"HistTmaxHE.png\" />" << std::endl;
7239  if (sub == 3)
7240  htmlFile << " <img src=\"HistTmaxHO.png\" />" << std::endl;
7241  if (sub == 4)
7242  htmlFile << " <img src=\"HistTmaxHF.png\" />" << std::endl;
7243  }
7244  htmlFile << "<br>" << std::endl;
7245 
7246  if (test == 1) {
7247  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7248  htmlFile << "<a name=\"ErrorA\"></a>\n";
7249  htmlFile << "<h2> 4. Error type A</h2>\n";
7250  htmlFile << "<h3> note: no sence to see plots of this item if max difference is too large(due to very high A "
7251  "of some channels)</h3>\n";
7252  htmlFile << "<br>\n";
7253 
7254  //HB:
7255  if (sub == 1) {
7256  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.6 (p-p collisions) </h3>\n";
7257  htmlFile << " <img src=\"HistErrA_HB.png\" />\n";
7258  htmlFile << "<br>\n";
7259  if (flagErrAB_HB[0] == -1)
7260  htmlFile << "<h3>test was not possible</h3>\n";
7261  else if (flagErrAB_HB[0] == 0)
7262  htmlFile << "<h3> Fine:NoErrorA_HB (Mean of max difference " << avedelta_HB
7263  << " is within 0.1-1.6) </h3>\n";
7264  else if (flagErrAB_HB[0] == 1)
7265  htmlFile << "<<h3> ErrorA_HB is available once Mean of max difference " << avedelta_HB
7266  << " is out 0.1-1.6 (p-p collisions)</font></h3>\n";
7267  else
7268  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7269  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7270 
7271  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7272 
7273  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels (only 2 depthes shown as example) "
7274  "</h2>\n";
7275  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >25), "
7276  "3) with channel Amplitude (A<35); </h2>\n";
7277  htmlFile << " <img src=\"ChkErrA_HB1.png\" /><br><br>\n";
7278  htmlFile << " <img src=\"ChkErrA_HB2.png\" /><br>\n";
7279  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7280 
7281  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7282  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 25 "
7283  "(HBM:neg.eta;HBP:pos.eta) </h2>\n";
7284  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7285  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.6 at least for HF- or "
7286  "HF+ </h2>\n";
7287  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.6 and is the same "
7288  "for HF- and HF+ </h2>\n";
7289  htmlFile << " <img src=\"OccPlots_HB.png\" /><br><br>\n";
7290  htmlFile << "<br>\n";
7291  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7292 
7293  htmlFile << "<a name=\"ErrorB\"></a>\n";
7294  htmlFile << "<h2> 7. Error type B (only 2 depthes shown as example) \n";
7295  htmlFile << "<h3> ErrorB identification: digi-collection size != 8.</h3>\n";
7296  htmlFile << " <img src=\"HistErrB_HB_1.png\" />\n<br>\n";
7297  htmlFile << " <img src=\"HistErrB_HB_2.png\" />\n<br>\n";
7298  htmlFile << "<br>\n";
7299  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HB << " LS </h3>\n";
7300  htmlFile << "<br>\n";
7301  }
7302 
7303  //HE:
7304  if (sub == 2) {
7305  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.2-1.8 (p-p collisions) </h3>\n";
7306  htmlFile << " <img src=\"HistErrA_HE.png\" />\n";
7307  htmlFile << "<br>\n";
7308  if (flagErrAB_HE[0] == -1)
7309  htmlFile << "<h3>test was not possible</h3>\n";
7310  else if (flagErrAB_HE[0] == 0)
7311  htmlFile << "<h3> Fine:NoErrorA_HE (Mean of max difference " << avedelta_HE
7312  << " is within 0.2-1.8) </h3>\n";
7313  else if (flagErrAB_HE[0] == 1)
7314  htmlFile << "<<h3> ErrorA_HE is available once Mean of max difference " << avedelta_HE
7315  << " is out 0.2-1.8 (p-p collisions)</font></h3>\n";
7316  else
7317  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7318  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7319 
7320  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7321 
7322  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels (only 3 depthes shown as example) "
7323  " </h2>\n";
7324  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> "
7325  ">1000.fC), 3) with channel Amplitude (A<500fC); </h2>\n";
7326  htmlFile << " <img src=\"ChkErrA_HE1.png\" /><br><br>\n";
7327  htmlFile << " <img src=\"ChkErrA_HE2.png\" /><br>\n";
7328  htmlFile << " <img src=\"ChkErrA_HE3.png\" /><br>\n";
7329  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7330 
7331  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7332  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 35 "
7333  "(HEM:neg.eta;HEP:pos.eta) </h2>\n";
7334  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7335  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.3 at least for HF- or "
7336  "HF+ </h2>\n";
7337  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.3 and is the same "
7338  "for HF- and HF+ </h2>\n";
7339  htmlFile << " <img src=\"OccPlots_HE.png\" /><br><br>\n";
7340  htmlFile << "<br>\n";
7341  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7342 
7343  htmlFile << "<a name=\"ErrorB\"></a>\n";
7344  htmlFile << "<h2> 7. Error type B (only 3 depthes shown as example) \n";
7345  htmlFile << "<h3> ErrorB identification: digi-collection size != 8.</h3>\n";
7346  htmlFile << " <img src=\"HistErrB_HE_1.png\" />\n<br>\n";
7347  htmlFile << " <img src=\"HistErrB_HE_2.png\" />\n<br>\n";
7348  htmlFile << " <img src=\"HistErrB_HE_3.png\" />\n<br>\n";
7349  htmlFile << "<br>\n";
7350  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HE << " LS </h3>\n";
7351  htmlFile << "<br>\n";
7352  }
7353 
7354  //HO:
7355  if (sub == 3) {
7356  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.1-1.5 (p-p collisions) </h3>\n";
7357  htmlFile << " <img src=\"HistErrA_HO.png\" />\n";
7358  htmlFile << "<br>\n";
7359  if (flagErrAB_HO[0] == -1)
7360  htmlFile << "<h3>test was not possible</h3>\n";
7361  else if (flagErrAB_HO[0] == 0)
7362  htmlFile << "<h3> Fine:NoErrorA_HO (Mean of max difference " << avedelta_HO
7363  << " is within 0.1-1.5) </h3>\n";
7364  else if (flagErrAB_HO[0] == 1)
7365  htmlFile << "<<h3> ErrorA_HO is available once Mean of max difference " << avedelta_HO
7366  << " is out 0.1-1.5 (p-p collisions)</font></h3>\n";
7367  else
7368  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7369  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7370 
7371  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7372 
7373  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels </h2>\n";
7374  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >80), "
7375  "3) with channel Amplitude (A<100); </h2>\n";
7376  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7377  htmlFile << " <img src=\"ChkErrA_HO4.png\" /><br><br>\n";
7378  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7379 
7380  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7381  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 80 "
7382  "(HOM:neg.eta;HOP:pos.eta) </h2>\n";
7383  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7384  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7385  "HF+ </h2>\n";
7386  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7387  "for HF- and HF+ </h2>\n";
7388  htmlFile << " <img src=\"OccPlots_HO.png\" /><br><br>\n";
7389  htmlFile << "<br>\n";
7390  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7391 
7392  htmlFile << "<a name=\"ErrorB\"></a>\n";
7393  htmlFile << "<h2> 7. Error type B\n";
7394  htmlFile << "<h3> ErrorB identification: digi-collection size != 10. </h3>\n";
7395  htmlFile << " <img src=\"HistErrB_HO_4.png\" />\n<br>\n";
7396  htmlFile << "<br>\n";
7397  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HO << " LS </h3>\n";
7398  htmlFile << "<br>\n";
7399  }
7400 
7401  //HF:
7402  if (sub == 4) {
7403  // flagSpecHF+=1;
7404  htmlFile << "<h3>Mean of max difference between dependencies to be within: 0.8-2.4 (p-p collisions) </h3>\n";
7405  htmlFile << " <img src=\"HistErrA_HF.png\" />\n";
7406  htmlFile << "<br>\n";
7407  if (flagErrAB_HF[0] == -1)
7408  htmlFile << "<h3>test was not possible</h3>\n";
7409  else if (flagErrAB_HF[0] == 0)
7410  htmlFile << "<h3> Fine:NoErrorA_HF (Mean of max difference " << avedelta_HF
7411  << " is within 0.8-2.4) </h3>\n";
7412  else if (flagErrAB_HF[0] == 1)
7413  htmlFile << "<<h3> ErrorA_HF is available once Mean of max difference " << avedelta_HF
7414  << " is out 0.8-2.4 (p-p collisions)</font></h3>\n";
7415  else
7416  htmlFile << "<h3>auto-interpretation is not available</h3>\n";
7417  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7418 
7419  htmlFile << "<a name=\"ErrorAaverage\"></a>\n";
7420 
7421  htmlFile << "<h2> 5. Error type A cross check: see 2D pattern of channels (only 2 depthes shown as example) "
7422  "</h2>\n";
7423  htmlFile << "<h2> 1) with average channel Amplitudes(No cut), 2) with average channel Amplitudes(<A> >20), "
7424  "3) with channel Amplitude (A<20); </h2>\n";
7425  // htmlFile << "<h2> 2D. Cross check for error A</h2>\n";
7426  htmlFile << " <img src=\"ChkErrA_HF1.png\" /><br><br>\n";
7427  htmlFile << " <img src=\"ChkErrA_HF2.png\" /><br>\n";
7428  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7429 
7430  htmlFile << "<a name=\"ErrorAoccupancy\"></a>\n";
7431  htmlFile << "<h2> 6. Error type A: min/ave ratio for occupancy distributions with Amplitude bigger 20 "
7432  "(HFM:neg.eta;HFP:pos.eta) </h2>\n";
7433  htmlFile << "<h2> FOR CROSS-CHECK OLNY !!!</h2>\n";
7434  htmlFile << "<h2> TO IDENTIFY A-type errors: for most of LSs the ratio to be lower 0.8 at least for HF- or "
7435  "HF+ </h2>\n";
7436  htmlFile << "<h2> For runs without A-type errors: for most of LSs the ratio is higher 0.8 and is the same "
7437  "for HF- and HF+ </h2>\n";
7438  htmlFile << " <img src=\"OccPlots_HF.png\" /><br><br>\n";
7439  htmlFile << "<br>\n";
7440  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7441 
7442  htmlFile << "<a name=\"ErrorB\"></a>\n";
7443  htmlFile << "<h2> 7. Error type B (only 2 depthes shown as example) \n";
7444  htmlFile << "<h3> ErrorB identification: digi-collection size != 4. </h3>\n";
7445  htmlFile << " <img src=\"HistErrB_HF_1.png\" />\n<br>\n";
7446  htmlFile << " <img src=\"HistErrB_HF_2.png\" />\n<br>\n";
7447  htmlFile << "<br>\n";
7448  htmlFile << "<h3> if Error type B is available, it start from: " << LSofFirstErrB_HF << " LS </h3>\n";
7449  htmlFile << "<br>\n";
7450  }
7451  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7452 
7453  } //test=1 Amplitude
7454 
7455  if (test == 1)
7456  htmlFile << "<a name=\"LSstatus\"></a>\n";
7457  // Continue with common sections
7458  if (sub == 1) {
7459  htmlFile << "<h2> 8.Lumisection Status for HB: </h2>" << std::endl;
7460  // 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;
7461  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7462  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), "
7463  << Cut0[test][sub][4] << " (Depth4), </h3>" << std::endl;
7464  }
7465  if (sub == 2) {
7466  htmlFile << "<h2> 8.Lumisection Status for HE: </h2>" << std::endl;
7467  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7468  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3),"
7469  << Cut0[test][sub][4] << " (Depth4)," << Cut0[test][sub][5] << " (Depth5)," << Cut0[test][sub][6]
7470  << " (Depth6)," << Cut0[test][sub][7] << " (Depth7). </h3>" << std::endl;
7471  }
7472  if (sub == 3) {
7473  // htmlFile << Form("<h2> %d.Lumisection Status for HO </h2>",4+flagSpecHF)<< std::endl;
7474  htmlFile << "<h2> 8.Lumisection Status for HO: </h2>" << std::endl;
7475  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][4]
7476  << " (Depth4). </h3>" << std::endl;
7477  }
7478  if (sub == 4) {
7479  htmlFile << "<h2> 8.Lumisection Status for HF: </h2>" << std::endl;
7480  htmlFile << "<h3> Legends: Red boxes correspond BAD LS selected with following cuts: " << Cut0[test][sub][1]
7481  << " (Depth1), " << Cut0[test][sub][2] << " (Depth2), " << Cut0[test][sub][3] << " (Depth3), "
7482  << Cut0[test][sub][4] << " (Depth4), </h3>" << std::endl;
7483  }
7484  htmlFile << "<br>" << std::endl;
7485  htmlFile << "<table>" << std::endl;
7486  htmlFile << "<tr>";
7487  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7488  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7489  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7491 
7492  int kkkkkkmax = k_max[sub];
7493  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
7494  kkkkkkmax = k_maxupgrade[sub];
7495  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
7496  // if (test==1 && sub==4) kkkkkkmax = k_maxupgrade[sub];
7497 
7498  if (test == 0)
7499  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7500  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > Depth " << k << " </td>" << std::endl;
7501  if (test == 1)
7502  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7503  htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth " << k << " </td>" << std::endl;
7504  if (test == 2)
7505  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7506  htmlFile << "<td class=\"s1\" align=\"center\">< W > Depth " << k << " </td>" << std::endl;
7507  if (test == 3)
7508  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7509  htmlFile << "<td class=\"s1\" align=\"center\">< R > Depth " << k << " </td>" << std::endl;
7510  if (test == 4)
7511  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7512  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > Depth " << k << " </td>" << std::endl;
7513  if (test == 5)
7514  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
7515  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > Depth " << k << " </td>" << std::endl;
7516  htmlFile << "</tr>" << std::endl;
7517 
7518  ind = 0;
7519  for (int i = 1; i <= MaxLum; i++) {
7520  if ((ind % 2) == 1)
7521  raw_class = "<td class=\"s2\" align=\"center\">";
7522  else
7523  raw_class = "<td class=\"s3\" align=\"center\">";
7524  htmlFile << "<tr>" << std::endl;
7525  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7526  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7527  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7528  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
7529  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k]) {
7530  if (test == 1)
7531  htmlFile << "<td class=\"s6\" align=\"center\">"
7532  << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7533  else
7534  htmlFile << "<td class=\"s6\" align=\"center\">" << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i))
7535  << "</td>" << std::endl;
7536  } else {
7537  if (test == 1)
7538  htmlFile << raw_class << int(HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7539  else
7540  htmlFile << raw_class << (HistNumBadChanDepth[test][sub][k]->GetBinContent(i)) << "</td>" << std::endl;
7541  }
7542  }
7543  htmlFile << "</tr>" << std::endl;
7544  ind += 1;
7545  }
7546  htmlFile << "</table>" << std::endl;
7547 
7548  htmlFile << "<br>" << std::endl;
7549  if (test == 1)
7550  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7551  htmlFile << "<br>" << std::endl;
7552 
7553  // Only for Amplitudes (test=1):
7555  if (test == 1) {
7558  htmlFile << "<a name=\"RBXstatus\"></a>\n";
7559 
7560  //HB j = 7,8,9,10 11,12,13,14
7561  if (sub == 1) {
7562  htmlFile << "<h2> 9. Average Amplitudes of RBX for HB: </h2>" << std::endl;
7563  htmlFile << "<h3> where </h3>" << std::endl;
7564  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7565  "(Positive direction); </h3>"
7566  << std::endl;
7567  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7568  // 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;
7569  htmlFile << " <img src=\"RBX-HB-2Dplot.png\" />\n";
7570  htmlFile << "<br>\n";
7571 
7572  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HB: </h2>" << std::endl;
7573  htmlFile << " <img src=\"RBX-HB-1Dplot.png\" />\n";
7574  htmlFile << "<br>\n";
7575 
7576  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HB: </h2>" << std::endl;
7577  htmlFile << " <img src=\"RBX-HB-11Dplot.png\" />\n";
7578  htmlFile << "<br>\n";
7579 
7580  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7581  }
7582  // HE: j = 3,4,5, 6, 7 14,15,16,17,18
7583  if (sub == 2) {
7584  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HE: </h2>" << std::endl;
7585  htmlFile << "<h3> where </h3>" << std::endl;
7586  htmlFile << "<h3> jeta = 3,4,5, 6, 7 (Negative direction); ............&& ............ jeta = "
7587  "14,15,16,17,18 (Positive direction); </h3>"
7588  << std::endl;
7589  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7590  // 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;
7591  htmlFile << " <img src=\"RBX-HE-2Dplot.png\" />\n";
7592  htmlFile << "<br>\n";
7593 
7594  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HE: </h2>" << std::endl;
7595  htmlFile << " <img src=\"RBX-HE-1Dplot.png\" />\n";
7596  htmlFile << "<br>\n";
7597 
7598  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HE: </h2>" << std::endl;
7599  htmlFile << " <img src=\"RBX-HE-11Dplot.png\" />\n";
7600  htmlFile << "<br>\n";
7601 
7602  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7603  }
7604  // HO: j = 7,8,9,10 11,12,13,14
7605  if (sub == 3) {
7606  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HO: </h2>" << std::endl;
7607  htmlFile << "<h3> where </h3>" << std::endl;
7608  htmlFile << "<h3> jeta = 7,8,9,10 (Negative direction); ............&& ............ jeta = 11,12,13,14 "
7609  "(Positive direction); </h3>"
7610  << std::endl;
7611  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7612  // 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;
7613  htmlFile << " <img src=\"RBX-HO-2Dplot.png\" />\n";
7614  htmlFile << "<br>\n";
7615 
7616  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HO: </h2>" << std::endl;
7617  htmlFile << " <img src=\"RBX-HO-1Dplot.png\" />\n";
7618  htmlFile << "<br>\n";
7619 
7620  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HO: </h2>" << std::endl;
7621  htmlFile << " <img src=\"RBX-HO-11Dplot.png\" />\n";
7622  htmlFile << "<br>\n";
7623 
7624  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7625  }
7626  //HF:j = 0,1,2, 3 18,19,20,21
7627  if (sub == 4) {
7628  htmlFile << "<h2> 9. Averaged Amplitudes of RBX for HF: </h2>" << std::endl;
7629  htmlFile << "<h3> where </h3>" << std::endl;
7630  htmlFile << "<h3> jeta = 0,1,2, 3 (Negative direction); ............&& ............ jeta = 18,19,20,21 "
7631  "(Positive direction); </h3>"
7632  << std::endl;
7633  htmlFile << "<h3> jphi = 0, 1,..... 16, 17 </h3>" << std::endl;
7634  // 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;
7635  htmlFile << " <img src=\"RBX-HF-2Dplot.png\" />\n";
7636  htmlFile << "<br>\n";
7637 
7638  htmlFile << "<h2> Average Amplitudes of RBX-PHI for HF: </h2>" << std::endl;
7639  htmlFile << " <img src=\"RBX-HF-1Dplot.png\" />\n";
7640  htmlFile << "<br>\n";
7641 
7642  htmlFile << "<h2> Average Amplitudes of RBX-ETA for HF: </h2>" << std::endl;
7643  htmlFile << " <img src=\"RBX-HF-11Dplot.png\" />\n";
7644  htmlFile << "<br>\n";
7645 
7646  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7647  }
7648  htmlFile << "<br>" << std::endl;
7649 
7652 
7653  htmlFile << "<a name=\"RBXPHItable\"></a>\n";
7654  int cutA_ALL = 0;
7655  // float cutA_HB = 100.;float cutA_HE = 1000000.;float cutA_HO = 150.;float cutA_HF = 500.;
7656  if (sub == 1) {
7657  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HB: </h2>" << std::endl;
7658  htmlFile
7659  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7660  << cutA_HB << std::endl;
7661  cutA_ALL = cutA_HB;
7662  }
7663  if (sub == 2) {
7664  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HE: </h2>" << std::endl;
7665  htmlFile
7666  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7667  << cutA_HE << std::endl;
7668  cutA_ALL = cutA_HE;
7669  }
7670  if (sub == 3) {
7671  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HO: </h2>" << std::endl;
7672  htmlFile
7673  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7674  << cutA_HO << std::endl;
7675  cutA_ALL = cutA_HO;
7676  }
7677  if (sub == 4) {
7678  htmlFile << "<h2> 10. Average RBX-Amplitude in Phi over LSs for HF: </h2>" << std::endl;
7679  htmlFile
7680  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7681  << cutA_HF << std::endl;
7682  cutA_ALL = cutA_HF;
7683  }
7684 
7685  htmlFile << "<br>" << std::endl;
7686  htmlFile << "<table>" << std::endl;
7687  htmlFile << "<tr>";
7688  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7689  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7690  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7692 
7693  // k is jphi
7694  for (int k = 0; k < njphi; k++)
7695  htmlFile << "<td class=\"s1\" align=\"center\"> iPHI " << k << " </td>" << std::endl;
7696  htmlFile << "</tr>" << std::endl;
7698 
7699  ind = 0;
7700  // i is LS
7701  for (int i = 1; i <= MaxLum; i++) {
7702  if ((ind % 2) == 1)
7703  raw_class = "<td class=\"s2\" align=\"center\">";
7704  else
7705  raw_class = "<td class=\"s3\" align=\"center\">";
7706  htmlFile << "<tr>" << std::endl;
7707  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7708  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7709  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7710 
7711  // k is jphi
7712  for (int k = 0; k < njphi; k++) {
7713  if (sub == 1) {
7714  if (int(alexhb[k][i - 1]) > cutA_ALL) {
7715  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7716  } else {
7717  htmlFile << raw_class << int(alexhb[k][i - 1]) << "</td>" << std::endl;
7718  }
7719  } // HB end
7720  if (sub == 2) {
7721  if (int(alexhe[k][i - 1]) > cutA_ALL) {
7722  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7723  } else {
7724  htmlFile << raw_class << int(alexhe[k][i - 1]) << "</td>" << std::endl;
7725  }
7726  } // HE end
7727  if (sub == 3) {
7728  if (int(alexho[k][i - 1]) > cutA_ALL) {
7729  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexho[k][i - 1]) << "</td>" << std::endl;
7730  } else {
7731  htmlFile << raw_class << int(alexho[k][i - 1]) << "</td>" << std::endl;
7732  }
7733  } // HO end
7734  if (sub == 4) {
7735  if (int(alexhf[k][i - 1]) > cutA_ALL) {
7736  htmlFile << "<td class=\"s6\" align=\"center\">" << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7737  } else {
7738  htmlFile << raw_class << int(alexhf[k][i - 1]) << "</td>" << std::endl;
7739  }
7740  } // HF end
7742  } // k over PHI-RBX
7743  htmlFile << "</tr>" << std::endl;
7744  ind += 1;
7745  } // i over LSs
7746  htmlFile << "</table>" << std::endl;
7747  htmlFile << "<br>" << std::endl;
7748  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7749  htmlFile << "<br>" << std::endl;
7751 
7752  htmlFile << "<a name=\"RBXETAtable\"></a>\n";
7753  int cutB_ALL = 0;
7754  // float cutB_HB = 100.;float cutB_HE = 1000000.;float cutB_HO = 150.;float cutB_HF = 500.;
7755  if (sub == 1) {
7756  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HB: </h2>" << std::endl;
7757  htmlFile
7758  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7759  << cutB_HB << std::endl;
7760  cutB_ALL = cutB_HB;
7761  }
7762  if (sub == 2) {
7763  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HE: </h2>" << std::endl;
7764  htmlFile
7765  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7766  << cutB_HE << std::endl;
7767  cutB_ALL = cutB_HE;
7768  }
7769  if (sub == 3) {
7770  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HO: </h2>" << std::endl;
7771  htmlFile
7772  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7773  << cutB_HO << std::endl;
7774  cutB_ALL = cutB_HO;
7775  }
7776  if (sub == 4) {
7777  htmlFile << "<h2> 11. Average RBX-Amplitude in Eta over LSs for HF: </h2>" << std::endl;
7778  htmlFile
7779  << "<h3> Legends: Red boxes correspond BAD LS selected with cut = <td class=\"s6\" align=\"center\">"
7780  << cutB_HF << std::endl;
7781  cutB_ALL = cutB_HF;
7782  }
7783 
7784  htmlFile << "<br>" << std::endl;
7785  htmlFile << "<table>" << std::endl;
7786  htmlFile << "<tr>";
7787  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
7788  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
7789  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
7791 
7792  // k is jeta
7793  for (int k = 0; k < njeta; k++)
7794  htmlFile << "<td class=\"s1\" align=\"center\"> iETA " << k << " </td>" << std::endl;
7795  htmlFile << "</tr>" << std::endl;
7797 
7798  ind = 0;
7799  // i is LS
7800  for (int i = 1; i <= MaxLum; i++) {
7801  if ((ind % 2) == 1)
7802  raw_class = "<td class=\"s2\" align=\"center\">";
7803  else
7804  raw_class = "<td class=\"s3\" align=\"center\">";
7805  htmlFile << "<tr>" << std::endl;
7806  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
7807  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
7808  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
7809 
7810  // k is jeta
7811  for (int k = 0; k < njeta; k++) {
7812  if (sub == 1) {
7813  if (int(blexhb[k][i - 1]) > cutB_ALL) {
7814  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7815  } else {
7816  htmlFile << raw_class << int(blexhb[k][i - 1]) << "</td>" << std::endl;
7817  }
7818  } // HB end
7819  if (sub == 2) {
7820  if (int(blexhe[k][i - 1]) > cutB_ALL) {
7821  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7822  } else {
7823  htmlFile << raw_class << int(blexhe[k][i - 1]) << "</td>" << std::endl;
7824  }
7825  } // HE end
7826  if (sub == 3) {
7827  if (int(blexho[k][i - 1]) > cutB_ALL) {
7828  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexho[k][i - 1]) << "</td>" << std::endl;
7829  } else {
7830  htmlFile << raw_class << int(blexho[k][i - 1]) << "</td>" << std::endl;
7831  }
7832  } // HO end
7833  if (sub == 4) {
7834  if (int(blexhf[k][i - 1]) > cutB_ALL) {
7835  htmlFile << "<td class=\"s6\" align=\"center\">" << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7836  } else {
7837  htmlFile << raw_class << int(blexhf[k][i - 1]) << "</td>" << std::endl;
7838  }
7839  } // HF end
7841  } // k over ETA-RBX
7842  htmlFile << "</tr>" << std::endl;
7843  ind += 1;
7844  } // i over LSs
7845  htmlFile << "</table>" << std::endl;
7846  htmlFile << "<br>" << std::endl;
7847  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7848  htmlFile << "<br>" << std::endl;
7850 
7853  htmlFile << "<a name=\"RBX3plots\"></a>\n";
7854  htmlFile << "<br>\n";
7855  htmlFile << "<h2> 12. (Rij) - RBX-amplitudes normilized on reference LS (~=1st) </h2>" << std::endl;
7856  htmlFile << "<h3> ( Rji . . is ratio of . . . . A_j_i . . to . . A_j_ref . . . . for . . j-RBX . . and . . "
7857  "i-LS . ) </h3>"
7858  << std::endl;
7859 
7860  htmlFile << "<br>\n";
7861  htmlFile << "<h2> . . . . . . . . . . . . . . 1) . average Ri vs iLS:. . . . . . . . . . . . . . . . . . . . . "
7862  ". . 2) . average Rj shown for Rij outside meanValue range either 0.95-1.05 or 3RMS: . . . . . . . "
7863  ". . . . . . . . . . . . . . . . . . 3) . Rij: </h2>"
7864  << std::endl;
7865  htmlFile << "<br>\n";
7866  if (sub == 1) {
7867  htmlFile << " <img src=\"RBX-HB-3plots.png\" />\n";
7868  }
7869  if (sub == 2) {
7870  htmlFile << " <img src=\"RBX-HE-3plots.png\" />\n";
7871  }
7872  if (sub == 3) {
7873  htmlFile << " <img src=\"RBX-HO-3plots.png\" />\n";
7874  }
7875  if (sub == 4) {
7876  htmlFile << " <img src=\"RBX-HF-3plots.png\" />\n";
7877  }
7878  htmlFile << "<br>\n";
7879 
7880  htmlFile << "<br>\n";
7881  htmlFile << "<h2> . 4). average Rj shown for Rij outside meanValue range 0.80-1.20: . . . . . . . .5) . "
7882  "average Rj shown for Rij outside meanValue range 0.70-1.30: . . . . . . . .6). average Rj shown "
7883  "for Rij outside meanValue range 0.60-1.40: </h2>"
7884  << std::endl;
7885  htmlFile << "<br>\n";
7886  if (sub == 1) {
7887  htmlFile << " <img src=\"RBX-HB-3plotsmore.png\" />\n";
7888  }
7889  if (sub == 2) {
7890  htmlFile << " <img src=\"RBX-HE-3plotsmore.png\" />\n";
7891  }
7892  if (sub == 3) {
7893  htmlFile << " <img src=\"RBX-HO-3plotsmore.png\" />\n";
7894  }
7895  if (sub == 4) {
7896  htmlFile << " <img src=\"RBX-HF-3plotsmore.png\" />\n";
7897  }
7898  htmlFile << "<br>\n";
7899 
7900  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
7901 
7902  //=========================================================
7903 
7904  } // test=1
7905 
7906  //===============================================================================
7907 
7908  htmlFile.close();
7909  } // sub main loop
7910  } //test main loop
7911  //===============================================================================
7912  //===============================================================================
7913  //===============================================================================
7914  //===============================================================================
7915  //===============================================================================
7916 
7917  //======================================================================
7918  // Creating tests html pages:
7919 
7920  for (int test = 0; test <= 5; test++) { //Test: 0,
7921  if (test == 0)
7922  htmlFile.open("CapID_GL.html");
7923  if (test == 1)
7924  htmlFile.open("ADCampl_GL.html");
7925  if (test == 2)
7926  htmlFile.open("Width_GL.html");
7927  if (test == 3)
7928  htmlFile.open("Ratio_GL.html");
7929  if (test == 4)
7930  htmlFile.open("Tmean_GL.html");
7931  if (test == 5)
7932  htmlFile.open("Tmax_GL.html");
7933 
7934  // cout<<"Creating tests html pages: test= "<< test << endl;
7935 
7936  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
7937  htmlFile << "<head>" << std::endl;
7938  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
7939  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
7940  htmlFile << "<style type=\"text/css\">" << std::endl;
7941  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
7942  << std::endl;
7943  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
7944  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
7945  "text-align: center;}"
7946  << std::endl;
7947  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
7948  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
7949  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
7950  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
7951  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
7952  htmlFile << "</style>" << std::endl;
7953  htmlFile << "<body>" << std::endl;
7954  if (test == 0)
7955  htmlFile << "<h1> CAP ID ERRORS, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7956  if (test == 1)
7957  htmlFile << "<h1> ADC AMPLITIDE, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7958  if (test == 2)
7959  htmlFile << "<h1> WIDTH, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7960  if (test == 3)
7961  htmlFile << "<h1> RATIO, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7962  if (test == 4)
7963  htmlFile << "<h1> TIMING MEAN, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7964  if (test == 5)
7965  htmlFile << "<h1> TIMING MAX, GLOBAL RUN = " << runnumber << " </h1>" << std::endl;
7966  htmlFile << "<br>" << std::endl;
7967  htmlFile << "<h2> 1. Map of suspicious channels with this criterion for whole HCAL </h2>" << std::endl;
7968  htmlFile << "<h3> Channel legend: green - good, other colour - suspicious </h3>" << std::endl;
7969  htmlFile << "<br>" << std::endl;
7970  if (test == 0)
7971  htmlFile << " <img src=\"MapCapIdError.png\" />" << std::endl;
7972  if (test == 1)
7973  htmlFile << " <img src=\"MapADCAmpl.png\" />" << std::endl;
7974  if (test == 2)
7975  htmlFile << " <img src=\"MapWidth.png\" />" << std::endl;
7976  if (test == 3)
7977  htmlFile << " <img src=\"MapRatio.png\" />" << std::endl;
7978  if (test == 4)
7979  htmlFile << " <img src=\"MapTmean.png\" />" << std::endl;
7980  if (test == 5)
7981  htmlFile << " <img src=\"MapTmax.png\" />" << std::endl;
7982  htmlFile << "<br>" << std::endl;
7983  htmlFile << "<h2> 2. For whole HCAL: </h2>" << std::endl;
7984  htmlFile << "<br>" << std::endl;
7985  if (test == 0)
7986  htmlFile << " <img src=\"HistCapID.png\" />" << std::endl;
7987  if (test == 1)
7988  htmlFile << " <img src=\"HistADCAmpl.png\" />" << std::endl;
7989  if (test == 2)
7990  htmlFile << " <img src=\"HistWidth.png\" />" << std::endl;
7991  if (test == 3)
7992  htmlFile << " <img src=\"HistRatio.png\" />" << std::endl;
7993  if (test == 4)
7994  htmlFile << " <img src=\"HistTmean.png\" />" << std::endl;
7995  if (test == 5)
7996  htmlFile << " <img src=\"HistTmax.png\" />" << std::endl;
7997  htmlFile << "<br>" << std::endl;
7998  htmlFile << "<h2> 3. Status of subdetectors </h2>" << std::endl;
7999  htmlFile << "<table width=\"400\">" << std::endl;
8000  htmlFile << "<tr>" << std::endl;
8001  if (test == 0) {
8002  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8003  << "/HB_CapID.html\">HB</a></td>" << std::endl;
8004  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8005  << "/HE_CapID.html\">HE</a></td>" << std::endl;
8006  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8007  << "/HO_CapID.html\">HO</a></td>" << std::endl;
8008  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8009  << "/HF_CapID.html\">HF</a></td>" << std::endl;
8010  }
8011  if (test == 1) {
8012  // AZ 11.03.2019
8013  /*
8014  htmlFile << " <td><a href=\"HB_ADCampl.html\">HB</a></td>"<< std::endl;
8015  htmlFile << " <td><a href=\"HE_ADCampl.html\">HE</a></td>"<< std::endl;
8016  htmlFile << " <td><a href=\"HO_ADCampl.html\">HO</a></td>"<< std::endl;
8017  htmlFile << " <td><a href=\"HF_ADCampl.html\">HF</a></td>"<< std::endl;
8018 */
8019 
8020  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8021  << "/HB_ADCampl.html\">HB</a></td>" << std::endl;
8022  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8023  << "/HE_ADCampl.html\">HE</a></td>" << std::endl;
8024  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8025  << "/HO_ADCampl.html\">HO</a></td>" << std::endl;
8026  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8027  << "/HF_ADCampl.html\">HF</a></td>" << std::endl;
8028  }
8029  if (test == 2) {
8030  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8031  << "/HB_Width.html\">HB</a></td>" << std::endl;
8032  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8033  << "/HE_Width.html\">HE</a></td>" << std::endl;
8034  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8035  << "/HO_Width.html\">HO</a></td>" << std::endl;
8036  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8037  << "/HF_Width.html\">HF</a></td>" << std::endl;
8038  }
8039  if (test == 3) {
8040  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8041  << "/HB_Ratio.html\">HB</a></td>" << std::endl;
8042  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8043  << "/HE_Ratio.html\">HE</a></td>" << std::endl;
8044  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8045  << "/HO_Ratio.html\">HO</a></td>" << std::endl;
8046  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8047  << "/HF_Ratio.html\">HF</a></td>" << std::endl;
8048  }
8049  if (test == 4) {
8050  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8051  << "/HB_Tmean.html\">HB</a></td>" << std::endl;
8052  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8053  << "/HE_Tmean.html\">HE</a></td>" << std::endl;
8054  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8055  << "/HO_Tmean.html\">HO</a></td>" << std::endl;
8056  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8057  << "/HF_Tmean.html\">HF</a></td>" << std::endl;
8058  }
8059  if (test == 5) {
8060  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8061  << "/HB_Tmax.html\">HB</a></td>" << std::endl;
8062  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8063  << "/HE_Tmax.html\">HE</a></td>" << std::endl;
8064  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8065  << "/HO_Tmax.html\">HO</a></td>" << std::endl;
8066  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8067  << "/HF_Tmax.html\">HF</a></td>" << std::endl;
8068  }
8069 
8070  htmlFile << "</tr>" << std::endl;
8071  htmlFile << "</table>" << std::endl;
8072  htmlFile << "<br>" << std::endl;
8073  // cout<<"Creating tests html pages: 111111" << endl;
8074 
8075  if (test != 0)
8076  htmlFile << "<h2> 4. Table of estimator-values in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8077  if (test == 0)
8078  htmlFile << "<h2> 4. Table of average Nbcs in sub-detectors for ONLY suspicious LSs </h3>" << std::endl;
8079  htmlFile << "<table>" << std::endl;
8080  htmlFile << "<tr>";
8081  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8082  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8083  htmlFile << "<td class=\"s1\" align=\"center\">Number of events</td>" << std::endl;
8085  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
8086 
8087  // cout<<"Creating each test kind for each subdet html pages: test= "<< test << " sub= " << sub << endl;
8088  int kkkkkkmax = k_max[sub];
8089  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8090  kkkkkkmax = k_maxupgrade[sub];
8091  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8092  // if (test==1 && sub==4) kkkkkkmax = k_maxupgrade[sub];
8093  if (sub == 1) {
8094  if (test == 0)
8095  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8096  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HBdep " << k << " </td>" << std::endl;
8097  if (test == 1)
8098  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8099  htmlFile << "<td class=\"s1\" align=\"center\">< A > HBdepth " << k << " </td>" << std::endl;
8100  if (test == 2)
8101  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8102  htmlFile << "<td class=\"s1\" align=\"center\">< W > HBdepth " << k << " </td>" << std::endl;
8103  if (test == 3)
8104  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8105  htmlFile << "<td class=\"s1\" align=\"center\">< R > HBdepth " << k << " </td>" << std::endl;
8106  if (test == 4)
8107  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8108  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HBdep " << k << " </td>" << std::endl;
8109  if (test == 5)
8110  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8111  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HBdep " << k << " </td>" << std::endl;
8112  } //
8113  if (sub == 2) {
8114  if (test == 0)
8115  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8116  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HEdep " << k << " </td>" << std::endl;
8117  if (test == 1)
8118  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8119  htmlFile << "<td class=\"s1\" align=\"center\">< A > HEdepth " << k << " </td>" << std::endl;
8120  if (test == 2)
8121  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8122  htmlFile << "<td class=\"s1\" align=\"center\">< W > HEdepth " << k << " </td>" << std::endl;
8123  if (test == 3)
8124  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8125  htmlFile << "<td class=\"s1\" align=\"center\">< R > HEdepth " << k << " </td>" << std::endl;
8126  if (test == 4)
8127  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8128  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HEdep " << k << " </td>" << std::endl;
8129  if (test == 5)
8130  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8131  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HEdep " << k << " </td>" << std::endl;
8132  } //
8133  if (sub == 3) {
8134  if (test == 0)
8135  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8136  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HOdep " << k << " </td>" << std::endl;
8137  if (test == 1)
8138  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8139  htmlFile << "<td class=\"s1\" align=\"center\">< A > HOdepth " << k << " </td>" << std::endl;
8140  if (test == 2)
8141  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8142  htmlFile << "<td class=\"s1\" align=\"center\">< W > HOdepth " << k << " </td>" << std::endl;
8143  if (test == 3)
8144  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8145  htmlFile << "<td class=\"s1\" align=\"center\">< R > HOdepth " << k << " </td>" << std::endl;
8146  if (test == 4)
8147  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8148  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HOdep " << k << " </td>" << std::endl;
8149  if (test == 5)
8150  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8151  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HOdep " << k << " </td>" << std::endl;
8152  } //
8153  if (sub == 4) {
8154  if (test == 0)
8155  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8156  htmlFile << "<td class=\"s1\" align=\"center\">< Nbcs > HFdep " << k << " </td>" << std::endl;
8157  if (test == 1)
8158  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8159  htmlFile << "<td class=\"s1\" align=\"center\">< A > HFdepth " << k << " </td>" << std::endl;
8160  if (test == 2)
8161  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8162  htmlFile << "<td class=\"s1\" align=\"center\">< W > HFdepth " << k << " </td>" << std::endl;
8163  if (test == 3)
8164  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8165  htmlFile << "<td class=\"s1\" align=\"center\">< R > HFdepth " << k << " </td>" << std::endl;
8166  if (test == 4)
8167  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8168  htmlFile << "<td class=\"s1\" align=\"center\">< TSn > HFdep " << k << " </td>" << std::endl;
8169  if (test == 5)
8170  for (int k = k_min[sub]; k <= kkkkkkmax; k++)
8171  htmlFile << "<td class=\"s1\" align=\"center\">< TSx > HFdep " << k << " </td>" << std::endl;
8172  } //
8173  } // sub
8174  htmlFile << "</tr>" << std::endl;
8175 
8176  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 1</td>"<< std::endl;
8177  // htmlFile << "<td class=\"s1\" align=\"center\">HB Depth 2</td>" << std::endl;
8178  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 1</td>" << std::endl;
8179  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 2</td>" << std::endl;
8180  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 3</td>" << std::endl;
8181  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 4</td>" << std::endl;
8182  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 5</td>" << std::endl;
8183  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 6</td>" << std::endl;
8184  // htmlFile << "<td class=\"s1\" align=\"center\">HE Depth 7</td>" << std::endl;
8185  // htmlFile << "<td class=\"s1\" align=\"center\">HO Depth 4</td>" << std::endl;
8186  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 1</td>" << std::endl;
8187  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 2</td>" << std::endl;
8188  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 3</td>" << std::endl;
8189  // htmlFile << "<td class=\"s1\" align=\"center\">HF Depth 4</td>" << std::endl;
8190  // htmlFile << "</tr>" << std::endl;
8191 
8192  ind = 0;
8193  // cout<<"Creating tests html pages: 222222" << endl;
8194  for (int i = 1; i <= MaxLum; i++) {
8195  // define al least one exceed in any sub-detector
8196  int met = 0;
8197  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8198  int kkkkkkmax = k_max[sub];
8199  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8200  kkkkkkmax = k_maxupgrade[sub];
8201  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8202  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8203  // line below is temporary, just to avoid contribution of HEP(M)17 in depthes 4,5,6,7 but keep in depthes 1,2,3
8204  // if (sub == 2 && k > 3) {
8205  // } else {
8206  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8207  met = 1;
8208  // }
8209  } //depth
8210  } //sub
8211  // if exceed then plot the line for all sub-detectors
8212  if (met == 1) {
8213  if ((ind % 2) == 1)
8214  raw_class = "<td class=\"s2\" align=\"center\">";
8215  else
8216  raw_class = "<td class=\"s3\" align=\"center\">";
8217  htmlFile << "<tr>" << std::endl;
8218  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8219  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8220  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8221  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
8222  int kkkkkkmax = k_max[sub];
8223  if ((sub == 4 || sub == 2 || sub == 1) && test == 1)
8224  kkkkkkmax = k_maxupgrade[sub];
8225  // if ( (sub==4 || sub==2) && test==1) kkkkkkmax = k_maxupgrade[sub];
8226  for (int k = k_min[sub]; k <= kkkkkkmax; k++) {
8227  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8228  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8229  << "</td>" << std::endl;
8230  else
8231  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8232  // htmlFile << "</tr>" << std::endl;
8233  /*
8234  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;
8235  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][1]->GetBinContent(i)<<"</td>"<< std::endl;
8236  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;
8237  else htmlFile <<raw_class<<HistNumBadChanDepth[test][1][2]->GetBinContent(i)<<"</td>"<< std::endl;
8238  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;
8239  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][1]->GetBinContent(i)<<"</td>"<< std::endl;
8240  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;
8241  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][2]->GetBinContent(i)<<"</td>"<< std::endl;
8242  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;
8243  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][3]->GetBinContent(i)<<"</td>"<< std::endl;
8244  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;
8245  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][4]->GetBinContent(i)<<"</td>"<< std::endl;
8246  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;
8247  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][5]->GetBinContent(i)<<"</td>"<< std::endl;
8248  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;
8249  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][6]->GetBinContent(i)<<"</td>"<< std::endl;
8250  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;
8251  else htmlFile <<raw_class<<HistNumBadChanDepth[test][2][7]->GetBinContent(i)<<"</td>"<< std::endl;
8252  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;
8253  else htmlFile <<raw_class<<HistNumBadChanDepth[test][3][4]->GetBinContent(i)<<"</td>"<< std::endl;
8254  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;
8255  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][1]->GetBinContent(i)<<"</td>"<< std::endl;
8256  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;
8257  else htmlFile <<raw_class<<HistNumBadChanDepth[test][4][2]->GetBinContent(i)<<"</td>"<< std::endl;
8258  */
8259  } //k depthes
8260  } //sub
8261  htmlFile << "</tr>" << std::endl;
8262  ind += 1;
8263  } // met=1
8264  } //i bin lines
8265  // cout<<"Creating tests html pages: 333333" << endl;
8266  htmlFile << "</table>" << std::endl;
8267  htmlFile << "<br>" << std::endl;
8268  htmlFile << "</body> " << std::endl;
8269  htmlFile << "</html> " << std::endl;
8270  htmlFile.close();
8271  } //test
8272  //======================================================================
8273  // cout<<"for summed Amplitudes of each sub-detector" << endl;
8274 
8275  // for summed Amplitudes of each sub-detector
8276  htmlFile.open("SummedAmplitudes_GL.html");
8277  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8278  htmlFile << "<head>" << std::endl;
8279  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8280  htmlFile << "<title> for summed Amplitudes of each sub-detector </title>" << std::endl;
8281  htmlFile << "<style type=\"text/css\">" << std::endl;
8282  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8283  << std::endl;
8284  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8285  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8286  "text-align: center;}"
8287  << std::endl;
8288  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8289  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8290  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8291  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8292  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8293 
8294  htmlFile << "</style>" << std::endl;
8295  htmlFile << "<body>" << std::endl;
8296  htmlFile << "<h1> Averaged Summed Amplitudes & corresponding occupancy of each sub-detector in Global Run = "
8297  << runnumber << " </h1>" << std::endl;
8298  htmlFile << "<a name=\"Top\"></a>\n";
8299  htmlFile << "<b>Contents:<br>\n";
8300  htmlFile << "1. <a href=\"#SAhigh\">average SA&Occupancy for Signal </a><br>\n";
8301  htmlFile << "2. <a href=\"#SAlow\">average SA&Occupancy for NoSignal </a><br>\n";
8302  htmlFile << "3. <a href=\"#SAmax\"> maxSA & maxOccupancy; SA & Occupancy; </a><br>\n";
8303  htmlFile << "4. <a href=\"#FullTable\">Table(avA; avSA; avOccupancy; maxSA; maxOccupancy;) </a><br>\n";
8304 
8305  htmlFile << "<h2> Clarifying on averaged Summed Amplitude (avSA) : </h2>" << std::endl;
8306  htmlFile << "<h3> Summed Amplitudes (SA) are averaged over all events of each LS: avSA_LS = SUM (SA_eventsInLS) / "
8307  "N_eventsInLS ,</h3>"
8308  << std::endl;
8309  htmlFile << "<h3> where SA = SUM(A_i) ,and means that Amplitude is summed over all sub-detector channels, </h3>"
8310  << std::endl;
8311  htmlFile << "<h3> where A_i = SUM(A_depth) denotes channel amplitude summed over depths; </h3>" << std::endl;
8312  // htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
8313  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/SAwriteup.html\"> see "
8314  "more details for SummedAmplitudes</a></td>"
8315  << std::endl;
8316  htmlFile << "<h2> Apply cuts on A_i to take into account channels with or/and without a'la Signal: </h2>"
8317  << std::endl;
8318  htmlFile << " <img src=\"ChannelDepthsummedAmplitudes.png\" />" << std::endl;
8319  htmlFile << "<br>" << std::endl;
8320  htmlFile << "<br>" << std::endl;
8321  htmlFile << "<a name=\"SAhigh\"></a>\n";
8322  htmlFile << "<h1> 1. for channels with signal </h1>" << std::endl;
8323  htmlFile << "<br>" << std::endl;
8324  htmlFile << "<h2> for HB: A_i> 80; </h2>" << std::endl;
8325  htmlFile << " <img src=\"SummedAmplitudesSignal_HB.png\" />" << std::endl;
8326  htmlFile << "<br>" << std::endl;
8327  htmlFile << "<h2> for HE: A_i> 200;</h2>" << std::endl;
8328  htmlFile << " <img src=\"SummedAmplitudesSignal_HE.png\" />" << std::endl;
8329  htmlFile << "<br>" << std::endl;
8330  htmlFile << "<h2> for HO: A_i> 1200;</h2>" << std::endl;
8331  htmlFile << " <img src=\"SummedAmplitudesSignal_HO.png\" />" << std::endl;
8332  htmlFile << "<br>" << std::endl;
8333  htmlFile << "<h2> for HF: A_i> 600;</h2>" << std::endl;
8334  htmlFile << " <img src=\"SummedAmplitudesSignal_HF.png\" />" << std::endl;
8335  htmlFile << "<br>" << std::endl;
8336  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8337 
8338  htmlFile << "<a name=\"SAlow\"></a>\n";
8339  htmlFile << "<h1> 2. for channels w/o signal </h1>" << std::endl;
8340  htmlFile << "<br>" << std::endl;
8341  htmlFile << "<h2> for HB: A_i< 80;</h2>" << std::endl;
8342  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HB.png\" />" << std::endl;
8343  htmlFile << "<br>" << std::endl;
8344  htmlFile << "<h2> for HE: A_i< 200;</h2>" << std::endl;
8345  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HE.png\" />" << std::endl;
8346  htmlFile << "<br>" << std::endl;
8347  htmlFile << "<h2> for HO: A_i< 1200;</h2>" << std::endl;
8348  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HO.png\" />" << std::endl;
8349  htmlFile << "<br>" << std::endl;
8350  htmlFile << "<h2> for HF: A_i< 600;</h2>" << std::endl;
8351  htmlFile << " <img src=\"NoSignalSummedAmplitudes_HF.png\" />" << std::endl;
8352  htmlFile << "<br>" << std::endl;
8353  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8354 
8355  htmlFile << "<br>" << std::endl;
8356  htmlFile << "<br>" << std::endl;
8357  htmlFile << "<a name=\"SAmax\"></a>\n";
8358  htmlFile << "<h1> 3. four plots: ---1---> max SA ---2---> max Occupancy ---3---> SA ---4---> Occupancy over all "
8359  "events of LS </h1>"
8360  << std::endl;
8361  htmlFile << "<br>" << std::endl;
8362 
8363  htmlFile << "<h2> for HB: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8364  htmlFile << " <img src=\"MaxxSummedAmplitudes_HB.png\" />" << std::endl;
8365  htmlFile << "<h2>"
8366  " ......(forCut:SAmax>60000) N= "
8367  << countamplmaxHB << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHB << " </h2>" << std::endl;
8368  htmlFile << "<h2>"
8369  " ......(forCut:SA>60000) N= "
8370  << countamplHB << " ...... (forCut:OCCUP>2000) N= " << countoccuHB << " </h2>" << std::endl;
8371  htmlFile << "<br>" << std::endl;
8372  htmlFile << "<h3> ONLY for HB (cross-check): channel Amplitudes for events in the Tail (averaged): </h3>"
8373  << std::endl;
8374  htmlFile << " <img src=\"AtaildepthHB.png\" />" << std::endl;
8375  htmlFile << "<br>" << std::endl;
8376 
8377  htmlFile << "<h2> for HE: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8378  htmlFile << " <img src=\"MaxxSummedAmplitudes_HE.png\" />" << std::endl;
8379  htmlFile << "<h2>"
8380  " ......(forCut:SAmax>60000) N= "
8381  << countamplmaxHE << " ...... (forCut:OCCUPmax>1200) N= " << countoccumaxHE << " </h2>" << std::endl;
8382  htmlFile << "<h2>"
8383  " ......(forCut:SA>60000) N= "
8384  << countamplHE << " ...... (forCut:OCCUP>1200) N= " << countoccuHE << " </h2>" << std::endl;
8385  htmlFile << "<br>" << std::endl;
8386 
8387  htmlFile << "<h2> for HO: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8388  htmlFile << " <img src=\"MaxxSummedAmplitudes_HO.png\" />" << std::endl;
8389  htmlFile << "<h2>"
8390  " ......(forCut:SAmax>150000) N= "
8391  << countamplmaxHO << " ...... (forCut:OCCUPmax>2000) N= " << countoccumaxHO << " </h2>" << std::endl;
8392  htmlFile << "<h2>"
8393  " ......(forCut:SA>150000) N= "
8394  << countamplHO << " ...... (forCut:OCCUP>2000) N= " << countoccuHO << " </h2>" << std::endl;
8395  htmlFile << "<br>" << std::endl;
8396 
8397  htmlFile << "<h2> for HF: maxSA vs LS, masOccupancy vs LS, SA, Occupancy </h2>" << std::endl;
8398  htmlFile << " <img src=\"MaxxSummedAmplitudes_HF.png\" />" << std::endl;
8399  htmlFile << "<h2>"
8400  " ......(forCut:SAmax>22000) N= "
8401  << countamplmaxHF << " ...... (forCut:OCCUPmax>860) N= " << countoccumaxHF << " </h2>" << std::endl;
8402  htmlFile << "<h2>"
8403  " ......(forCut:SA>22000) N= "
8404  << countamplHF << " ...... (forCut:OCCUP>860) N= " << countoccuHF << " </h2>" << std::endl;
8405  htmlFile << "<br>" << std::endl;
8406  htmlFile << "<h2> Occupancy HF (ONLY) vs LS </h2>" << std::endl;
8407  htmlFile << " <img src=\"sumOccupancyHF.png\" />" << std::endl;
8408  htmlFile << "<br>" << std::endl;
8409  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8410 
8411  htmlFile << "<a name=\"FullTable\"></a>\n";
8412  htmlFile << "<h2> 4.Lumisection Status: </h2>" << std::endl;
8413  htmlFile << "<h3> Legends: HBdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8414  << Cut0[1][1][1] << std::endl;
8415  htmlFile << "<h3> Legends: HEdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8416  << Cut0[1][2][1] << std::endl;
8417  htmlFile << "<h3> Legends: HOdepth4 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8418  << Cut0[1][3][4] << std::endl;
8419  htmlFile << "<h3> Legends: HFdepth1 red boxes correspond LSs selected with cut: <td class=\"s6\" align=\"center\">"
8420  << Cut0[1][4][1] << std::endl;
8421  htmlFile << "<br>" << std::endl;
8422  // SummedAmplitudeHisto[i] SummedAmplitudeOccupancyHisto[i] NoSignalSummedAmplitudeHisto[i] NoSignalSummedAmplitudeOccupancyHisto[i]; i=0-3;(HF:i=3)
8423  htmlFile << "<br>" << std::endl;
8424  htmlFile << "<table>" << std::endl;
8425  htmlFile << "<tr>";
8426  htmlFile << "<td class=\"s4\" align=\"center\">LS</td>" << std::endl;
8427  // htmlFile << "<td class=\"s1\" align=\"center\">LS</td>" << std::endl;
8428  htmlFile << "<td class=\"s1\" align=\"center\"> Num.of ev.</td>" << std::endl;
8429 
8430  // for (int k=k_min[sub];k<=k_max[sub]; k++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth "<< k <<" </td>" << std::endl;
8431  // for (int sub=1;sub<=4;sub++) htmlFile << "<td class=\"s1\" align=\"center\">< A > Depth1, sub "<< sub <<" </td>" << std::endl;
8432 
8433  htmlFile << "<td class=\"s1\" align=\"center\">< A >HB Depth1</td>" << std::endl;
8434  htmlFile << "<td class=\"s1\" align=\"center\">< A >HE Depth1</td>" << std::endl;
8435  htmlFile << "<td class=\"s1\" align=\"center\">< A >HO Depth4</td>" << std::endl;
8436  htmlFile << "<td class=\"s1\" align=\"center\">< A >HF Depth1</td>" << std::endl;
8437 
8438  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (Signal) </td>" << std::endl;
8439  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (Signal) </td>" << std::endl;
8440  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (Signal) </td>" << std::endl;
8441  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (Signal) </td>" << std::endl;
8442 
8443  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HB (NoSignal) </td>" << std::endl;
8444  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HB (NoSignal) </td>" << std::endl;
8445  htmlFile << "<td class=\"s1\" align=\"center\">< SA >HF (NoSignal) </td>" << std::endl;
8446  htmlFile << "<td class=\"s1\" align=\"center\">< Occup. > HF (NoSignal) </td>" << std::endl;
8447 
8448  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HB </td>" << std::endl;
8449  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HB </td>" << std::endl;
8450  htmlFile << "<td class=\"s1\" align=\"center\"> maxSA HF </td>" << std::endl;
8451  htmlFile << "<td class=\"s1\" align=\"center\"> maxOccup. HF </td>" << std::endl;
8452 
8453  htmlFile << "</tr>" << std::endl;
8454 
8455  ind = 0;
8456  for (int i = 1; i <= MaxLum; i++) {
8457  if ((ind % 2) == 1)
8458  raw_class = "<td class=\"s2\" align=\"center\">";
8459  else
8460  raw_class = "<td class=\"s3\" align=\"center\">";
8461  htmlFile << "<tr>" << std::endl;
8462 
8463  htmlFile << "<td class=\"s4\" align=\"center\">" << i << "</td>" << std::endl;
8464 
8465  // htmlFile << raw_class<< LumLum->GetBinContent(i)<<"</td>"<< std::endl;
8466  htmlFile << raw_class << LumiEv->GetBinContent(i) << "</td>" << std::endl;
8467 
8468  // (test==1) <Amplitude>
8469  int test = 1;
8470  // for (int k=k_min[sub];k<=k_max[sub]; k++) {
8471  for (int sub = 1; sub <= 4; sub++) {
8472  for (int k = k_min[sub]; k <= k_min[sub]; k++) {
8473  if (HistNumBadChanDepth[test][sub][k]->GetBinContent(i) > Cut0[test][sub][k])
8474  htmlFile << "<td class=\"s6\" align=\"center\">" << HistNumBadChanDepth[test][sub][k]->GetBinContent(i)
8475  << "</td>" << std::endl;
8476 
8477  else
8478  htmlFile << raw_class << HistNumBadChanDepth[test][sub][k]->GetBinContent(i) << "</td>" << std::endl;
8479  }
8480  }
8481  if (SummedAmplitudeHisto[0]) {
8482  htmlFile << raw_class << SummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8483  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8484  htmlFile << raw_class << SummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8485  htmlFile << raw_class << SummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8486 
8487  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8488  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8489  htmlFile << raw_class << NoSignalSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8490  htmlFile << raw_class << NoSignalSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8491 
8492  htmlFile << raw_class << MaxxSummedAmplitudeHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8493  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[0]->GetBinContent(i) << "</td>" << std::endl;
8494  htmlFile << raw_class << MaxxSummedAmplitudeHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8495  htmlFile << raw_class << MaxxSummedAmplitudeOccupancyHisto[3]->GetBinContent(i) << "</td>" << std::endl;
8496  }
8497  htmlFile << "</tr>" << std::endl;
8498  ind += 1;
8499  }
8500  htmlFile << "</table>" << std::endl;
8501  htmlFile << "<a href=\"#Top\">to top</a><br>\n";
8502 
8503  htmlFile << "<br>" << std::endl;
8504  htmlFile << "</body> " << std::endl;
8505  htmlFile << "</html> " << std::endl;
8506  htmlFile.close();
8507 
8508  //====================================================================== // Creating description of html-files
8509 
8510  /*
8511  //======================================================================
8512  // Creating description HELP.html file:
8513  htmlFile.open("HELP.html");
8514  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">"<< std::endl;
8515  htmlFile << "<head>"<< std::endl;
8516  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>"<< std::endl;
8517  htmlFile << "<title> Certification Monitoring Tool </title>"<< std::endl;
8518  htmlFile << "<style type=\"text/css\">"<< std::endl;
8519  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"<< std::endl;
8520  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }"<< std::endl;
8521  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; text-align: center;}"<< std::endl;
8522  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }"<< std::endl;
8523  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }"<< std::endl;
8524  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }"<< std::endl;
8525  htmlFile << "</style>"<< std::endl;
8526  htmlFile << "<body>"<< std::endl;
8527  htmlFile << "<h1> Description of Remote Monitoring Tool criteria for bad channel selection</h1>"<< std::endl;
8528  htmlFile << "<br>"<< std::endl;
8529  htmlFile << "<h3> - CAPID Errors assuming we inspect CAPID non-rotation,error & validation bits, and for this criterion - no need to apply any cuts to select bcs.</h3> "<< std::endl;
8530  htmlFile << "<br>"<< std::endl;
8531  htmlFile << "<h3> - Amplitude is full amplitude collected over all time slices </h3> "<< std::endl;
8532  htmlFile << "<h3> - Ratio criterion is where we define as a bad, the channels, for which the signal portion in 4 middle TSs(plus one, minus two around TS with maximal amplitude) is out of some range of reasonable values </h3> "<< std::endl;
8533  htmlFile << "<br>"<< std::endl;
8534  htmlFile << "<h3> - Width of shape distribution. Width is defined as square root from dispersion. </h3> "<< std::endl;
8535  htmlFile << "<br>"<< std::endl;
8536  htmlFile << "<h3> - Mean TS time slice position of adc signal. </h3> "<< std::endl;
8537  htmlFile << "<br>"<< std::endl;
8538  htmlFile << "<h3> - TS number of maximum signal </h3> "<< std::endl;
8539  htmlFile << "<br>"<< std::endl;
8540  htmlFile << "<h3> For more details see https://twiki.cern.ch/twiki/bin/viewauth/CMS/HcalRemoteCertificationMonitoring </h3> "<< std::endl;
8541  htmlFile << "</body> " << std::endl;
8542  htmlFile << "</html> " << std::endl;
8543  htmlFile.close();
8544 */
8545  //======================================================================
8546  // Creating description CMTresults.html file:
8547  htmlFile.open("CMTresults.html");
8548  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8549  htmlFile << "<head>" << std::endl;
8550  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8551  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8552  htmlFile << "<style type=\"text/css\">" << std::endl;
8553  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8554  << std::endl;
8555  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8556  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8557  "text-align: center;}"
8558  << std::endl;
8559  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8560  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8561  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8562  htmlFile << "</style>" << std::endl;
8563  htmlFile << "<body>" << std::endl;
8564  htmlFile << "<h1> LS-certification (recommendation) from analysis of CMT-dependencies of THIS run </h1>"
8565  << std::endl;
8566  htmlFile << "<br>" << std::endl;
8567  htmlFile << "<br>" << std::endl;
8568  htmlFile << "<h2> - List of suspicious LSs: </h2> " << std::endl;
8569  htmlFile << "<br>" << std::endl;
8570  htmlFile << "<h3> to be added </h3> " << std::endl;
8571  htmlFile << "<br>" << std::endl;
8572  htmlFile << "<br>" << std::endl;
8573  htmlFile << "<br>" << std::endl;
8574  htmlFile << "<h2> - Comments: </h2> " << std::endl;
8575  htmlFile << "<br>" << std::endl;
8576  htmlFile << "<h3> to be added </h3> " << std::endl;
8577  htmlFile << "<br>" << std::endl;
8578  htmlFile << "<br>" << std::endl;
8579  htmlFile << "<br>" << std::endl;
8580  htmlFile << "</body> " << std::endl;
8581  htmlFile << "</html> " << std::endl;
8582  htmlFile.close();
8583 
8584  //======================================================================
8585  // Creating main html file:
8586 
8587  htmlFile.open("LumiList.html");
8588  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
8589  htmlFile << "<head>" << std::endl;
8590  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
8591  htmlFile << "<title> Certification Monitoring Tool </title>" << std::endl;
8592  htmlFile << "<style type=\"text/css\">" << std::endl;
8593  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
8594  << std::endl;
8595  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
8596  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
8597  "text-align: center;}"
8598  << std::endl;
8599  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
8600  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
8601  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
8602  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #00FF00; }" << std::endl;
8603  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #FF0000; }" << std::endl;
8604 
8605  htmlFile << "</style>" << std::endl;
8606  htmlFile << "<body>" << std::endl;
8607 
8608  htmlFile << "<h1> Certification Monitoring Tool, GLOBAL RUN = " << runnumber << ". </h1>" << std::endl;
8609  htmlFile << "<br>" << std::endl;
8610  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8611  << "/CMTresults.html\"> CMT-analysis RESULTS (for this run) </a></td>" << std::endl;
8612  htmlFile << "<br>" << std::endl;
8613  htmlFile << "<br>" << std::endl;
8614 
8615  // htmlFile << "<h2> 1. General information </h2>"<< std::endl;
8616  htmlFile << "<h2> 1. General information (Full number of LS = " << MaxLum << " ). </h2>" << std::endl;
8617  htmlFile << " <img src=\"LumiEvent.png\" />" << std::endl;
8618  htmlFile << "<br>" << std::endl;
8619 
8620  htmlFile << "<h2> 2. HCAL status for different criteria </h2>" << std::endl;
8621  // htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_"<<runnumber<<"/HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
8622  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/HELP.html\"> "
8623  "Description of criteria for bad channel selection</a></td>"
8624  << std::endl;
8625  htmlFile << "<br>" << std::endl;
8626  htmlFile << "<table width=\"600\">" << std::endl;
8627  htmlFile << "<tr>" << std::endl;
8628  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8629  << "/CapID_GL.html\">Cap ID errors</a></td>" << std::endl;
8630  // AZ 11.03.2019
8631  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8632  << "/ADCampl_GL.html\">Amplitude</a></td>" << std::endl;
8633  // htmlFile << " <td><a href=\"ADCampl_GL.html\">Amplitude</a></td>"<< std::endl;
8634  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8635  << "/Width_GL.html\">Width</a></td>" << std::endl;
8636  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8637  << "/Ratio_GL.html\">Ratio</a></td>" << std::endl;
8638  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8639  << "/Tmean_GL.html\">TS mean</a></td>" << std::endl;
8640  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8641  << "/Tmax_GL.html\">TS max</a></td>" << std::endl;
8642 
8643  htmlFile << " <td><a href=\"https://cms-conddb.cern.ch/eosweb/hcal/HcalRemoteMonitoring/CMT/GLOBAL_" << runnumber
8644  << "/SummedAmplitudes_GL.html\">SummedAmplitudes</a></td>" << std::endl;
8645 
8646  htmlFile << "</tr>" << std::endl;
8647  htmlFile << "</table>" << std::endl;
8648  htmlFile << "<br>" << std::endl;
8649  htmlFile << "</body> " << std::endl;
8650  htmlFile << "</html> " << std::endl;
8651  htmlFile.close();
8652  //======================================================================
8653 
8654  //======================================================================
8655  // Close and delete all possible things:
8656  hfile->Close();
8657  // hfile->Delete();
8658  // Exit Root
8659  gSystem->Exit(0);
8660  //======================================================================
8661 }
8662 
8663 // ------------------------------------------------------------
8664 
8665 int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin) {
8666  if (lastBin > hSrc->GetNbinsX()) {
8667  std::cout << "copyContents from " << hSrc->GetName() << ": histo has " << hSrc->GetNbinsX()
8668  << " bins, when lastBin=" << lastBin << " was requested\n";
8669  return 0;
8670  }
8671 
8672  (*hDest) = new TH1F(hname, htitle, lastBin, 0, lastBin);
8673  (*hDest)->SetDirectory(0);
8674  (*hDest)->SetStats(0);
8675 
8676  for (int ibin = 1; ibin <= lastBin; ibin++) {
8677  (*hDest)->SetBinContent(ibin, hSrc->GetBinContent(ibin));
8678  (*hDest)->SetBinError(ibin, hSrc->GetBinError(ibin));
8679  }
8680  return 1;
8681 }
8682 
8683 // ------------------------------------------------------------
mps_fire.i
i
Definition: mps_fire.py:429
remoteMonitoring_LASER_era2018_cfg.lsmax
lsmax
Definition: remoteMonitoring_LASER_era2018_cfg.py:278
main
int main(int argc, char *argv[])
Definition: RemoteMonitoringGLOBAL.cc:37
NULL
#define NULL
Definition: scimark2.h:8
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
ctpps_dqm_sourceclient-live_cfg.test
test
Definition: ctpps_dqm_sourceclient-live_cfg.py:7
change_name.diff
diff
Definition: change_name.py:13
copyContents
int copyContents(TH1F **hDest, TString hname, TString htitle, const TH1F *hSrc, int lastBin)
Definition: RemoteMonitoringGLOBAL.cc:8665
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