CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Functions
RemoteMonitoringMAPnoPSM.cc File Reference
#include "LogEleMapdb.h"
#include <iostream>
#include <fstream>
#include "TH1.h"
#include "TH2.h"
#include "TCanvas.h"
#include "TROOT.h"
#include <TMath.h>
#include "TStyle.h"
#include "TSystem.h"
#include "TLegend.h"
#include "TText.h"
#include "TAxis.h"
#include "TFile.h"
#include "TLine.h"
#include "TGraph.h"

Go to the source code of this file.

Functions

int main (int argc, char *argv[])
 

Function Documentation

int main ( int  argc,
char *  argv[] 
)

Prepare maps of good/bad channels:

Definition at line 31 of file RemoteMonitoringMAPnoPSM.cc.

References funct::abs(), gather_cfg::cout, EcalCondDB::db, g4TestOverlap_cfg::Depth, DeadROC_duringRun::dir, CellDB::find(), alignmentValidation::fname, mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, MAX, MIN, ndepth, neta, nphi, nsub, colinearityKinematic::Phi, cond::runnumber, SiStripCommissioningClient_cfg::runtype, CellDB::size(), str, AlCaHLTBitMon_QueryRunRegistry::string, ctpps_dqm_sourceclient-live_cfg::test, and x.

31  {
32  std::string dirnm = "Analyzer";
33  gROOT->Reset();
34  gROOT->SetStyle("Plain");
35  gStyle->SetOptStat(0);
36  gStyle->SetOptTitle(1);
37  // ok change
38  if (argc < 3)
39  return 1;
40  char fname[300];
41  char refname[300];
42  char runtypeC[300];
43  sprintf(fname, "%s", argv[1]);
44  sprintf(refname, "%s", argv[2]);
45  sprintf(runtypeC, "%s", argv[3]);
46  std::cout << fname << " " << refname << " " << runtypeC << std::endl;
47  // ok change
48 
49  //======================================================================
50  // Connect the input files, parameters and get the 2-d histogram in memory
51  // TFile *hfile= new TFile("GlobalHist.root", "READ");
52  string promt = (string)fname;
53  string runtype = (string)runtypeC;
54  string runnumber = "";
55  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
56  runnumber += fname[i];
57  string refrunnumber = "";
58  promt = (string)refname;
59  for (unsigned int i = promt.size() - 11; i < promt.size() - 5; i++)
60  refrunnumber += refname[i];
61 
62  TFile *hfile = new TFile(fname, "READ");
63  hfile->ls();
64  TDirectory *dir = (TDirectory *)hfile->FindObjectAny(dirnm.c_str());
65  TFile *hreffile = new TFile(refname, "READ");
66  hreffile->ls();
67  TDirectory *refdir = (TDirectory *)hreffile->FindObjectAny(dirnm.c_str());
68 
69  // with TfileService implementation, change everywhere below: hreffile->Get to refdir->FindObjectAny
70  // with TfileService implementation, change everywhere below: hfile->Get to dir->FindObjectAny
71 
72  double MIN_M[7][5];
73  double MAX_M[7][5];
74  double MIN_C[7][5];
75  double MAX_C[7][5];
76  double porog[5];
77  double Pedest[2][5];
78 
79  if (runtype == "LED") {
80  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
81  double MIN_M_LED[7][5] = {{0., 0., 0., 0., 0.},
82  {0., 0., 0., 0., 0.},
83  {0, 100., 70., 40., 40.},
84  {0, 0.7, 0.7, 0.1, 0.1},
85  {0, 0.7, 0.6, 0.40, 0.45},
86  {0, 2.5, 1.0, 1.0, 1.0},
87  {0, 1.5, 1.5, 0.5, 0.5}};
88  double MAX_M_LED[7][5] = {{0., 0., 0., 0., 0.},
89  {0., 0., 0., 0., 0.},
90  {0, 3000, 500000, 3000, 150000},
91  {0, 2.5, 2.5, 2.8, 2.6},
92  {0, 0.94, 0.95, 1.04, 1.02},
93  {0, 5.5, 5.2, 4.8, 4.2},
94  {0, 6.5, 6.5, 8.5, 8.5}};
95  double MIN_C_LED[7][5] = {{0., 0., 0., 0., 0.},
96  {0., 0., 0., 0., 0.},
97  {0, 1000., 1000., 1000., 100.},
98  {0, 1.3, 1.3, 0.7, 0.3},
99  {0, 0.76, 0.76, 0.85, 0.5},
100  {0, 2.4, 2.4, 1.5, 3.5},
101  {0, 1.5, 1.5, 1.5, 3.5}};
102  double MAX_C_LED[7][5] = {{0., 0., 0., 0., 0.},
103  {0., 0., 0., 0., 0.},
104  {0, 1E20, 1E20, 1E20, 1E20},
105  {0, 1.9, 1.9, 1.65, 1.5},
106  {0, 0.94, 0.94, 0.99, 0.8},
107  {0, 3.7, 3.7, 2.7, 4.5},
108  {0, 2.5, 2.5, 2.5, 4.5}};
109  double porog_LED[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
110  double Pedest_LED[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
111  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
112  for (int i = 0; i <= 6; i++)
113  for (int j = 0; j <= 4; j++) {
114  MIN_M[i][j] = MIN_M_LED[i][j];
115  MAX_M[i][j] = MAX_M_LED[i][j];
116  MIN_C[i][j] = MIN_C_LED[i][j];
117  MAX_C[i][j] = MAX_C_LED[i][j];
118  }
119  for (int i = 0; i <= 4; i++) {
120  porog[i] = porog_LED[i];
121  Pedest[0][i] = Pedest_LED[0][i];
122  Pedest[1][i] = Pedest_LED[1][i];
123  }
124  }
125 
126  if (runtype == "LASER") {
127  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
128  double MIN_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
129  {0., 0., 0., 0., 0.},
130  {0, 40., 40., 100., 40.},
131  {0, 0.3, 0.9, 0.2, 0.2},
132  {0, 0.5, 0.55, 0.55, 0.60},
133  {0, 5.0, 2.5, 1.1, 5.5},
134  {0, 1.5, 1.5, 1.5, 1.5}};
135  double MAX_M_LASER[7][5] = {{0., 0., 0., 0., 0.},
136  {0., 0., 0., 0., 0.},
137  {0, 3500, 350000, 3500, 150000},
138  {0, 2.5, 3.6, 2.6, 2.1},
139  {0, 1.00, 1.00, 1.04, 1.02},
140  {0, 7.5, 6.5, 4.4, 8.5},
141  {0, 8.5, 8.5, 6.5, 8.5}};
142  double MIN_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
143  {0., 0., 0., 0., 0.},
144  {0, 1000., 1000., 1000., 100.},
145  {0, 1.3, 1.3, 0.7, 0.3},
146  {0, 0.76, 0.76, 0.85, 0.5},
147  {0, 2.4, 2.4, 1.5, 3.5},
148  {0, 1.5, 1.5, 1.5, 3.5}};
149  double MAX_C_LASER[7][5] = {{0., 0., 0., 0., 0.},
150  {0., 0., 0., 0., 0.},
151  {0, 1E20, 1E20, 1E20, 1E20},
152  {0, 1.9, 1.9, 1.65, 1.5},
153  {0, 0.94, 0.94, 1.0, 0.8},
154  {0, 3.7, 3.7, 2.7, 4.5},
155  {0, 2.5, 2.5, 2.5, 4.5}};
156  double porog_LASER[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
157  // double porog_LASER[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
158  double Pedest_LASER[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
159  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
160  for (int i = 0; i <= 6; i++)
161  for (int j = 0; j <= 4; j++) {
162  MIN_M[i][j] = MIN_M_LASER[i][j];
163  MAX_M[i][j] = MAX_M_LASER[i][j];
164  MIN_C[i][j] = MIN_C_LASER[i][j];
165  MAX_C[i][j] = MAX_C_LASER[i][j];
166  }
167  for (int i = 0; i <= 4; i++) {
168  porog[i] = porog_LASER[i];
169  Pedest[0][i] = Pedest_LASER[0][i];
170  Pedest[1][i] = Pedest_LASER[1][i];
171  }
172  }
173  if (runtype == "PEDESTAL") {
174  //CUTS: [test][subdetector] ADC amplitude Am Width for Wm Ratio cut for Rm TS mean for TNm TS max for TXm
175  double MIN_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
176  {0., 0., 0., 0., 0.},
177  {0, 10., 10., 200., 5.},
178  {0, 2.7, 2.7, 2.7, 0.2},
179  {0, 0.31, 0.31, 0.05, 0.15},
180  {0, 4.5, 4.5, 4.5, 2.0},
181  {0, 0.5, 0.5, 0.5, 0.5}};
182  double MAX_M_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
183  {0., 0., 0., 0., 0.},
184  {0, 2500., 250000., 2500., 150000.},
185  {0, 3.0, 3.0, 5.0, 3.0},
186  {0, 0.95, 0.95, 1.00, 0.98},
187  {0, 4.6, 4.6, 4.6, 7.0},
188  {0, 9.5, 9.5, 8.5, 8.5}};
189  double MIN_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
190  {0., 0., 0., 0., 0.},
191  {0, 1000., 1000., 1000., 100.},
192  {0, 1.3, 1.3, 0.7, 0.3},
193  {0, 0.76, 0.76, 0.85, 0.5},
194  {0, 2.4, 2.4, 1.5, 3.5},
195  {0, 1.5, 1.5, 1.5, 3.5}};
196  double MAX_C_PEDESTAL[7][5] = {{0., 0., 0., 0., 0.},
197  {0., 0., 0., 0., 0.},
198  {0, 1E20, 1E20, 1E20, 1E20},
199  {0, 1.9, 1.9, 1.65, 1.5},
200  {0, 0.94, 0.94, 1.0, 0.8},
201  {0, 3.7, 3.7, 2.7, 4.5},
202  {0, 2.5, 2.5, 2.5, 4.5}};
203  double porog_PEDESTAL[5] = {0., 2., 2., 2., 2.}; // Cut for GS test in pro cents
204  // double porog_PEDESTAL[5] = {0., 200., 200., 100., 100.}; // Cut for GS test in pro cents
205  double Pedest_PEDESTAL[2][5] = {{0., 0.1, 0.6, 0.1, 0.8},
206  {0., 0.1, 0.1, 0.1, 0.4}}; //Cuts for Pedestal and pedestal Width
207  for (int i = 0; i <= 6; i++)
208  for (int j = 0; j <= 4; j++) {
209  MIN_M[i][j] = MIN_M_PEDESTAL[i][j];
210  MAX_M[i][j] = MAX_M_PEDESTAL[i][j];
211  MIN_C[i][j] = MIN_C_PEDESTAL[i][j];
212  MAX_C[i][j] = MAX_C_PEDESTAL[i][j];
213  }
214  for (int i = 0; i <= 4; i++) {
215  porog[i] = porog_PEDESTAL[i];
216  Pedest[0][i] = Pedest_PEDESTAL[0][i];
217  Pedest[1][i] = Pedest_PEDESTAL[1][i];
218  }
219  }
220 
221  //======================================================================
222 
223  cout << endl;
224  cout << MIN_M[2][1] << endl;
225 
226  //======================================================================
227  // Prepare histograms and plot them to .png files
228 
229  //TCanvas *cHB = new TCanvas("cHB","cHB",1000,500);
230  TCanvas *cHB = new TCanvas("cHB", "cHB", 1000, 1000);
231  //TCanvas *cHE = new TCanvas("cHE","cHE",1500,500);
232  TCanvas *cHE = new TCanvas("cHE", "cHE", 1500, 1500);
233  //TCanvas *cONE = new TCanvas("cONE","cONE",500,500);
234  TCanvas *cONE = new TCanvas("cONE", "cONE", 1500, 500);
235  TCanvas *cPED = new TCanvas("cPED", "cPED", 1000, 500);
236  //TCanvas *cHF = new TCanvas("cHF","cHF",1000,1000);
237  TCanvas *cHF = new TCanvas("cHF", "cHF", 1000, 1000);
238 
239  // Iteration Method for Calibration Group:
240 
241  TCanvas *c1x0 = new TCanvas("c1x0", "c1x0", 300, 10, 800, 700);
242 
243  TCanvas *c1x1 = new TCanvas("c1x1", "c1x1", 100, 10, 600, 700);
244 
245  TCanvas *c3x5 = new TCanvas("c3x5", "c3x5", 1000, 1500);
246  //
247 
248  char *str = (char *)alloca(10000);
249 
250  // before upgrade 2017:
251  // depth: HB depth1,2; HE depth1,2,3; HO depth4; HF depth1,2
252  // 5 depthes: 0(empty), 1,2,3,4
253 
254  // upgrade 2017:
255  // depth: HB depth1,2; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
256  // 8 depthes: 0(empty), 1,2,3,4,5,6,7
257 
258  // upgrade 2021:
259  // depth: HB depth1,2,3,4; HE depth1,2,3,4,5,6,7; HO depth4; HF depth1,2,3,4
260  // 10 depthes: 0(empty), 1,2,3,4,5,6,7,8,9
261 
262  // Int_t ALLDEPTH = 5;
263  // Int_t ALLDEPTH = 8;
264  Int_t ALLDEPTH = 10;
265 
266  int k_min[5] = {0, 1, 1, 4, 1}; // minimum depth for each subdet
267  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
268  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
269  int k_max[5] = {0, 4, 7, 4, 4}; // maximum depth for each subdet
270 
271  TH2F *Map_Ampl[33][5][ALLDEPTH]; // 2D histogramm for test,subdet,depth
272  TH2F *Map_SUB[5][ALLDEPTH]; // 2d histogramm for subdet, depth
273  TH1F *HistAmplDepth[22][5][ALLDEPTH]; // 1d histogramm for test,subdet, depth
274  TH1F *HistAmpl[22][5]; // 1d histogramm for test,subdet
275 
276  TH1F *HistPed[3][5][4]; // 1d histogramm for test,subdet, CapID
277  TH2F *Map_Ped[3][5]; // 2d histogramm for test,subdet -> test 33
278  TH1F *hist_GoodTSshape[5]; // 1d histogramm for TS shape subdet -> test 41
279  TH1F *hist_GoodTSshape0[5]; // 1d histogramm for TS shape subdet -> test 41
280  TH1F *hist_BadTSshape[5]; // 1d histogramm for TS shape subdet -> test 41
281  TH1F *hist_BadTSshape0[5]; // 1d histogramm for TS shape subdet -> test 41
282  TH1F *hist_ADC_All[5]; // 1d histogramm for TS shape subdet -> test 42
283  TH1F *hist_ADC_DS[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 42
284  TH1F *hist_SumADC[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
285  TH1F *hist_SumADC0[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
286  TH1F *hist_SumADC1[5][ALLDEPTH]; // 1d histogramm for TS shape subdet, depth -> test 43
287 
288  Map_SUB[1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HB");
289  Map_SUB[1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HB");
290  Map_SUB[2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HE");
291  Map_SUB[2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HE");
292  Map_SUB[2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HE");
293  Map_SUB[3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HO");
294  Map_SUB[4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1_HF");
295  Map_SUB[4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2_HF");
296 
297  Map_SUB[1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HB");
298  Map_SUB[1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HB");
299  Map_SUB[2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HE");
300  Map_SUB[2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5_HE");
301  Map_SUB[2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6_HE");
302  Map_SUB[2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7_HE");
303  Map_SUB[4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3_HF");
304  Map_SUB[4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4_HF");
305 
306  //+++++++++++++++++++++++++++++
307  //Test 0 Entries
308  //+++++++++++++++++++++++++++++
309 
310  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
311  // if (sub==1) cHB->Divide(2,1);
312  if (sub == 1)
313  cHB->Divide(2, 2);
314  // if (sub==2) cHE->Divide(3,1);
315  if (sub == 2)
316  cHE->Divide(3, 3);
317  if (sub == 3)
318  cONE->Divide(1, 1);
319  // if (sub==4) cHF->Divide(2,1);
320  if (sub == 4)
321  cHF->Divide(2, 2);
322  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
323  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
324  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
325  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
326  if (sub == 1)
327  cHB->cd(k);
328  if (sub == 2)
329  cHE->cd(k);
330  if (sub == 3)
331  cONE->cd(k - 3);
332  if (sub == 4)
333  cHF->cd(k);
334  gPad->SetGridy();
335  gPad->SetGridx();
336  gPad->SetLogz();
337  if (sub == 1)
338  sprintf(str, "HB, Depth%d \b", k);
339  if (sub == 2)
340  sprintf(str, "HE, Depth%d \b", k);
341  if (sub == 3)
342  sprintf(str, "HO, Depth%d \b", k);
343  if (sub == 4)
344  sprintf(str, "HF, Depth%d \b", k);
345  Map_SUB[sub][k]->SetTitle(str);
346  Map_SUB[sub][k]->SetXTitle("#eta \b");
347  Map_SUB[sub][k]->SetYTitle("#phi \b");
348  Map_SUB[sub][k]->SetZTitle("Number of events \b");
349  if (sub == 3)
350  Map_SUB[sub][k]->SetTitleOffset(0.8, "Z");
351  Map_SUB[sub][k]->Draw("COLZ");
352  Map_SUB[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
353  // Map_SUB[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
354  if (sub == 1) {
355  cHB->Modified();
356  cHB->Update();
357  }
358  if (sub == 2) {
359  cHE->Modified();
360  cHE->Update();
361  }
362  if (sub == 3) {
363  cONE->Modified();
364  cONE->Update();
365  }
366  if (sub == 4) {
367  cHF->Modified();
368  cHF->Update();
369  }
370  } //end depth
371 
372  if (sub == 1) {
373  cHB->Print("MapRateEntryHB.png");
374  cHB->Clear();
375  }
376  if (sub == 2) {
377  cHE->Print("MapRateEntryHE.png");
378  cHE->Clear();
379  }
380  if (sub == 3) {
381  cONE->Print("MapRateEntryHO.png");
382  cONE->Clear();
383  }
384  if (sub == 4) {
385  cHF->Print("MapRateEntryHF.png");
386  cHF->Clear();
387  }
388  } // end sub
389 
390  //+++++++++++++++++++++++++++++
391  //Test 1 (Cm) Rate of Cap ID errors
392  //+++++++++++++++++++++++++++++
393 
394  Map_Ampl[1][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HB");
395  Map_Ampl[1][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HB");
396  Map_Ampl[1][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HE");
397  Map_Ampl[1][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HE");
398  Map_Ampl[1][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HE");
399  Map_Ampl[1][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HO");
400  Map_Ampl[1][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Error_HF");
401  Map_Ampl[1][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Error_HF");
402 
403  Map_Ampl[1][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HB");
404  Map_Ampl[1][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HB");
405  Map_Ampl[1][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HE");
406  Map_Ampl[1][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Error_HE");
407  Map_Ampl[1][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Error_HE");
408  Map_Ampl[1][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Error_HE");
409  Map_Ampl[1][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Error_HF");
410  Map_Ampl[1][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Error_HF");
411 
412  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
413  // if (sub==1) cHB->Divide(2,1);
414  if (sub == 1)
415  cHB->Divide(2, 2);
416  // if (sub==2) cHE->Divide(3,1);
417  if (sub == 2)
418  cHE->Divide(3, 3);
419  if (sub == 3)
420  cONE->Divide(1, 1);
421  // if (sub==4) cHF->Divide(2,1);
422  if (sub == 4)
423  cHF->Divide(2, 2);
424  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
425  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
426  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
427  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
428  if (sub == 1)
429  cHB->cd(k);
430  if (sub == 2)
431  cHE->cd(k);
432  if (sub == 3)
433  cONE->cd(k - 3);
434  if (sub == 4)
435  cHF->cd(k);
436  Map_Ampl[1][sub][k]->Divide(Map_Ampl[1][sub][k], Map_SUB[sub][k], 1, 1, "B");
437  gPad->SetGridy();
438  gPad->SetGridx();
439  gPad->SetLogz();
440  if (sub == 1)
441  sprintf(str, "HB, Depth%d \b", k);
442  if (sub == 2)
443  sprintf(str, "HE, Depth%d \b", k);
444  if (sub == 3)
445  sprintf(str, "HO, Depth%d \b", k);
446  if (sub == 4)
447  sprintf(str, "HF, Depth%d \b", k);
448  Map_Ampl[1][sub][k]->SetTitle(str);
449  Map_Ampl[1][sub][k]->SetXTitle("#eta \b");
450  Map_Ampl[1][sub][k]->SetYTitle("#phi \b");
451  Map_Ampl[1][sub][k]->SetZTitle("Rate \b");
452  if (sub == 3)
453  Map_Ampl[1][sub][k]->SetTitleOffset(0.8, "Z");
454  Map_Ampl[1][sub][k]->Draw("COLZ");
455  Map_Ampl[1][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
456  Map_Ampl[1][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
457  if (sub == 1) {
458  cHB->Modified();
459  cHB->Update();
460  }
461  if (sub == 2) {
462  cHE->Modified();
463  cHE->Update();
464  }
465  if (sub == 3) {
466  cONE->Modified();
467  cONE->Update();
468  }
469  if (sub == 4) {
470  cHF->Modified();
471  cHF->Update();
472  }
473  } //end depth
474 
475  if (sub == 1) {
476  cHB->Print("MapRateCapIDHB.png");
477  cHB->Clear();
478  }
479  if (sub == 2) {
480  cHE->Print("MapRateCapIDHE.png");
481  cHE->Clear();
482  }
483  if (sub == 3) {
484  cONE->Print("MapRateCapIDHO.png");
485  cONE->Clear();
486  }
487  if (sub == 4) {
488  cHF->Print("MapRateCapIDHF.png");
489  cHF->Clear();
490  }
491  } // end sub
492 
493  //+++++++++++++++++++++++++++++
494  //Test 2 (Am) ADC amplitude
495  //+++++++++++++++++++++++++++++
496 
497  Map_Ampl[2][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HB");
498  Map_Ampl[2][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HB");
499  Map_Ampl[2][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HE");
500  Map_Ampl[2][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HE");
501  Map_Ampl[2][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HE");
502  Map_Ampl[2][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HO");
503  Map_Ampl[2][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1ADCAmpl225_HF");
504  Map_Ampl[2][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2ADCAmpl225_HF");
505 
506  Map_Ampl[2][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HB");
507  Map_Ampl[2][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HB");
508  Map_Ampl[2][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HE");
509  Map_Ampl[2][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5ADCAmpl225_HE");
510  Map_Ampl[2][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6ADCAmpl225_HE");
511  Map_Ampl[2][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7ADCAmpl225_HE");
512  Map_Ampl[2][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3ADCAmpl225_HF");
513  Map_Ampl[2][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4ADCAmpl225_HF");
514 
515  HistAmpl[2][1] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HB");
516  HistAmpl[2][2] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HE");
517  HistAmpl[2][3] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HO");
518  HistAmpl[2][4] = (TH1F *)dir->FindObjectAny("h_ADCAmpl_HF");
519 
520  //+++++++++++++++++++++++++++++
521  //Test 3 (Wm) Rate of RMS
522  //+++++++++++++++++++++++++++++
523 
524  Map_Ampl[3][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HB");
525  Map_Ampl[3][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HB");
526  Map_Ampl[3][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HE");
527  Map_Ampl[3][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HE");
528  Map_Ampl[3][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HE");
529  Map_Ampl[3][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HO");
530  Map_Ampl[3][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Amplitude225_HF");
531  Map_Ampl[3][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Amplitude225_HF");
532 
533  Map_Ampl[3][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HB");
534  Map_Ampl[3][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HB");
535  Map_Ampl[3][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HE");
536  Map_Ampl[3][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Amplitude225_HE");
537  Map_Ampl[3][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Amplitude225_HE");
538  Map_Ampl[3][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Amplitude225_HE");
539  Map_Ampl[3][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Amplitude225_HF");
540  Map_Ampl[3][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Amplitude225_HF");
541 
542  HistAmpl[3][1] = (TH1F *)dir->FindObjectAny("h_Amplitude_HB");
543  HistAmpl[3][2] = (TH1F *)dir->FindObjectAny("h_Amplitude_HE");
544  HistAmpl[3][3] = (TH1F *)dir->FindObjectAny("h_Amplitude_HO");
545  HistAmpl[3][4] = (TH1F *)dir->FindObjectAny("h_Amplitude_HF");
546 
547  //+++++++++++++++++++++++++++++
548  //Test 4 (Rm) Rate of ratio 4 near max TS/ All TS
549  //+++++++++++++++++++++++++++++
550 
551  Map_Ampl[4][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HB");
552  Map_Ampl[4][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HB");
553  Map_Ampl[4][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HE");
554  Map_Ampl[4][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HE");
555  Map_Ampl[4][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HE");
556  Map_Ampl[4][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HO");
557  Map_Ampl[4][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1Ampl047_HF");
558  Map_Ampl[4][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2Ampl047_HF");
559 
560  Map_Ampl[4][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HB");
561  Map_Ampl[4][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HB");
562  Map_Ampl[4][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HE");
563  Map_Ampl[4][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5Ampl047_HE");
564  Map_Ampl[4][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6Ampl047_HE");
565  Map_Ampl[4][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7Ampl047_HE");
566  Map_Ampl[4][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3Ampl047_HF");
567  Map_Ampl[4][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4Ampl047_HF");
568 
569  HistAmpl[4][1] = (TH1F *)dir->FindObjectAny("h_Ampl_HB");
570  HistAmpl[4][2] = (TH1F *)dir->FindObjectAny("h_Ampl_HE");
571  HistAmpl[4][3] = (TH1F *)dir->FindObjectAny("h_Ampl_HO");
572  HistAmpl[4][4] = (TH1F *)dir->FindObjectAny("h_Ampl_HF");
573 
574  //+++++++++++++++++++++++++++++
575  //Test 5 (TNm) Mean position in 1-8 TS range
576  //+++++++++++++++++++++++++++++
577 
578  Map_Ampl[5][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HB");
579  Map_Ampl[5][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HB");
580  Map_Ampl[5][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HE");
581  Map_Ampl[5][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HE");
582  Map_Ampl[5][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HE");
583  Map_Ampl[5][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HO");
584  Map_Ampl[5][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmeanA225_HF");
585  Map_Ampl[5][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmeanA225_HF");
586 
587  Map_Ampl[5][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HB");
588  Map_Ampl[5][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HB");
589  Map_Ampl[5][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HE");
590  Map_Ampl[5][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmeanA225_HE");
591  Map_Ampl[5][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmeanA225_HE");
592  Map_Ampl[5][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmeanA225_HE");
593  Map_Ampl[5][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmeanA225_HF");
594  Map_Ampl[5][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmeanA225_HF");
595 
596  HistAmpl[5][1] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HB");
597  HistAmpl[5][2] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HE");
598  HistAmpl[5][3] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HO");
599  HistAmpl[5][4] = (TH1F *)dir->FindObjectAny("h_TSmeanA_HF");
600 
601  //+++++++++++++++++++++++++++++
602  //Test 6 (TXm) Maximum position in 1-8 TS range
603  //+++++++++++++++++++++++++++++
604 
605  Map_Ampl[6][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HB");
606  Map_Ampl[6][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HB");
607  Map_Ampl[6][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HE");
608  Map_Ampl[6][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HE");
609  Map_Ampl[6][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HE");
610  Map_Ampl[6][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HO");
611  Map_Ampl[6][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1TSmaxA225_HF");
612  Map_Ampl[6][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2TSmaxA225_HF");
613 
614  Map_Ampl[6][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HB");
615  Map_Ampl[6][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HB");
616  Map_Ampl[6][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HE");
617  Map_Ampl[6][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5TSmaxA225_HE");
618  Map_Ampl[6][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6TSmaxA225_HE");
619  Map_Ampl[6][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7TSmaxA225_HE");
620  Map_Ampl[6][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3TSmaxA225_HF");
621  Map_Ampl[6][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4TSmaxA225_HF");
622 
623  HistAmpl[6][1] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HB");
624  HistAmpl[6][2] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HE");
625  HistAmpl[6][3] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HO");
626  HistAmpl[6][4] = (TH1F *)dir->FindObjectAny("h_TSmaxA_HF");
627 
628  for (int test = 2; test <= 6; test++) { //Test: 2-Am, 3-Wm, 4-Rm, 5-TNm, 6-TXm,
629  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
630  // if (sub==1) cHB->Divide(2,1);
631  if (sub == 1)
632  cHB->Divide(2, 2);
633  // if (sub==2) cHE->Divide(3,1);
634  if (sub == 2)
635  cHE->Divide(3, 3);
636  if (sub == 3)
637  cONE->Divide(1, 1);
638  // if (sub==4) cHF->Divide(2,1);
639  if (sub == 4)
640  cHF->Divide(2, 2);
641  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
642  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
643  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
644  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
645  if (sub == 1)
646  cHB->cd(k);
647  if (sub == 2)
648  cHE->cd(k);
649  if (sub == 3)
650  cONE->cd(k - 3);
651  if (sub == 4)
652  cHF->cd(k);
653  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_SUB[sub][k], 1, 1, "B");
654  gPad->SetGridy();
655  gPad->SetGridx();
656  gPad->SetLogz();
657  if (sub == 1)
658  sprintf(str, "HB, Depth%d \b", k);
659  if (sub == 2)
660  sprintf(str, "HE, Depth%d \b", k);
661  if (sub == 3)
662  sprintf(str, "HO, Depth%d \b", k);
663  if (sub == 4)
664  sprintf(str, "HF, Depth%d \b", k);
665  Map_Ampl[test][sub][k]->SetTitle(str);
666  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
667  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
668  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
669  if (sub == 3)
670  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
671  Map_Ampl[test][sub][k]->Draw("COLZ");
672  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
673  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
674  if (sub == 1) {
675  cHB->Modified();
676  cHB->Update();
677  }
678  if (sub == 2) {
679  cHE->Modified();
680  cHE->Update();
681  }
682  if (sub == 3) {
683  cONE->Modified();
684  cONE->Update();
685  }
686  if (sub == 4) {
687  cHF->Modified();
688  cHF->Update();
689  }
690  } //end depth
691  if (test == 2) {
692  if (sub == 1) {
693  cHB->Print("MapRateAmplHB.png");
694  cHB->Clear();
695  }
696  if (sub == 2) {
697  cHE->Print("MapRateAmplHE.png");
698  cHE->Clear();
699  }
700  if (sub == 3) {
701  cONE->Print("MapRateAmplHO.png");
702  cONE->Clear();
703  }
704  if (sub == 4) {
705  cHF->Print("MapRateAmplHF.png");
706  cHF->Clear();
707  }
708  }
709  if (test == 3) {
710  if (sub == 1) {
711  cHB->Print("MapRateRMSHB.png");
712  cHB->Clear();
713  }
714  if (sub == 2) {
715  cHE->Print("MapRateRMSHE.png");
716  cHE->Clear();
717  }
718  if (sub == 3) {
719  cONE->Print("MapRateRMSHO.png");
720  cONE->Clear();
721  }
722  if (sub == 4) {
723  cHF->Print("MapRateRMSHF.png");
724  cHF->Clear();
725  }
726  }
727  if (test == 4) {
728  if (sub == 1) {
729  cHB->Print("MapRate43TStoAllTSHB.png");
730  cHB->Clear();
731  }
732  if (sub == 2) {
733  cHE->Print("MapRate43TStoAllTSHE.png");
734  cHE->Clear();
735  }
736  if (sub == 3) {
737  cONE->Print("MapRate43TStoAllTSHO.png");
738  cONE->Clear();
739  }
740  if (sub == 4) {
741  cHF->Print("MapRate43TStoAllTSHF.png");
742  cHF->Clear();
743  }
744  }
745  if (test == 5) {
746  if (sub == 1) {
747  cHB->Print("MapRateMeanPosHB.png");
748  cHB->Clear();
749  }
750  if (sub == 2) {
751  cHE->Print("MapRateMeanPosHE.png");
752  cHE->Clear();
753  }
754  if (sub == 3) {
755  cONE->Print("MapRateMeanPosHO.png");
756  cONE->Clear();
757  }
758  if (sub == 4) {
759  cHF->Print("MapRateMeanPosHF.png");
760  cHF->Clear();
761  }
762  }
763  if (test == 6) {
764  if (sub == 1) {
765  cHB->Print("MapRateMaxPosHB.png");
766  cHB->Clear();
767  }
768  if (sub == 2) {
769  cHE->Print("MapRateMaxPosHE.png");
770  cHE->Clear();
771  }
772  if (sub == 3) {
773  cONE->Print("MapRateMaxPosHO.png");
774  cONE->Clear();
775  }
776  if (sub == 4) {
777  cHF->Print("MapRateMaxPosHF.png");
778  cHF->Clear();
779  }
780  }
781 
782  // cONE->Divide(1,1);
783  cONE->Divide(3, 1);
784  if (test == 2 && sub == 2) {
785  cONE->cd(2);
786  TH1F *kjkjkhj2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest1");
787  kjkjkhj2->Draw("");
788  kjkjkhj2->SetTitle("HE, All Depth: shunt1");
789  cONE->cd(3);
790  TH1F *kjkjkhj3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHEtest6");
791  kjkjkhj3->Draw("");
792  kjkjkhj3->SetTitle("HE, All Depth: shunt6");
793  }
794  if (test == 2 && sub == 1) {
795  cONE->cd(2);
796  TH1F *kjkjkhb2 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest1");
797  kjkjkhb2->Draw("");
798  kjkjkhb2->SetTitle("HB, All Depth: shunt1");
799  cONE->cd(3);
800  TH1F *kjkjkhb3 = (TH1F *)dir->FindObjectAny("h_AmplitudeHBtest6");
801  kjkjkhb3->Draw("");
802  kjkjkhb3->SetTitle("HB, All Depth: shunt6");
803  }
804  cONE->cd(1);
805  gPad->SetGridy();
806  gPad->SetGridx();
807  gPad->SetLogy();
808  if (sub == 1)
809  HistAmpl[test][sub]->SetTitle("HB, All Depth: shunt6");
810  if (sub == 2)
811  HistAmpl[test][sub]->SetTitle("HE, All Depth: shunt6");
812  if (sub == 3)
813  HistAmpl[test][sub]->SetTitle("HO, All Depth");
814  if (sub == 4)
815  HistAmpl[test][sub]->SetTitle("HF, All Depth");
816  if (test == 2)
817  HistAmpl[test][sub]->SetXTitle("ADC Amlitude in each event & cell \b");
818  if (test == 3)
819  HistAmpl[test][sub]->SetXTitle("RMS in each event & cell \b");
820  if (test == 4)
821  HistAmpl[test][sub]->SetXTitle("Ratio in each event & cell \b");
822  if (test == 5)
823  HistAmpl[test][sub]->SetXTitle("Mean TS position in each event & cell \b");
824  if (test == 6)
825  HistAmpl[test][sub]->SetXTitle("Max TS position in each event & cell \b");
826  HistAmpl[test][sub]->SetYTitle("Number of cell-events \b");
827  HistAmpl[test][sub]->SetLineColor(4);
828  HistAmpl[test][sub]->SetLineWidth(2);
829  HistAmpl[test][sub]->SetTitleOffset(1.4, "Y");
830  HistAmpl[test][sub]->Draw("");
831  // // HistAmpl[test][sub]->GetYaxis()->SetRangeUser(1., 100.);
832  // if (test==2) {gPad->SetLogx(); HistAmpl[test][sub]->GetXaxis()->SetRangeUser(1., 10000.);}
833  if (test == 2) {
834  gPad->SetLogx();
835  }
836  if (test == 3)
837  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 5.); // width
838  if (test == 4)
839  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 1.); // R
840  if (test == 5)
841  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.); //Tn
842  if (test == 6)
843  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.); //Tx
844  cONE->Modified();
845  cONE->Update();
846  double min_x[] = {MIN_M[test][sub], MIN_M[test][sub]};
847  double min_y[] = {0., 100000000.};
848  TGraph *MIN = new TGraph(2, min_x, min_y);
849  MIN->SetLineStyle(2);
850  MIN->SetLineColor(2);
851  MIN->SetLineWidth(2 + 100 * 100);
852  MIN->SetFillStyle(3005);
853  MIN->SetFillColor(2);
854  MIN->Draw("L");
855  double max_x[] = {MAX_M[test][sub], MAX_M[test][sub]};
856  double max_y[] = {0., 100000000.};
857  TGraph *MAX = new TGraph(2, max_x, max_y);
858  MAX->SetLineStyle(2);
859  MAX->SetLineColor(2);
860  MAX->SetLineWidth(-2 - 100 * 100);
861  MAX->SetFillStyle(3004);
862  MAX->SetFillColor(2);
863  MAX->Draw("L");
864  if (test == 2) {
865  if (sub == 1) {
866  cONE->Print("HistAmplHB.png");
867  cONE->Clear();
868  }
869  if (sub == 2) {
870  cONE->Print("HistAmplHE.png");
871  cONE->Clear();
872  }
873  if (sub == 3) {
874  cONE->Print("HistAmplHO.png");
875  cONE->Clear();
876  }
877  if (sub == 4) {
878  cONE->Print("HistAmplHF.png");
879  cONE->Clear();
880  }
881  }
882  if (test == 3) {
883  if (sub == 1) {
884  cONE->Print("HistRMSHB.png");
885  cONE->Clear();
886  }
887  if (sub == 2) {
888  cONE->Print("HistRMSHE.png");
889  cONE->Clear();
890  }
891  if (sub == 3) {
892  cONE->Print("HistRMSHO.png");
893  cONE->Clear();
894  }
895  if (sub == 4) {
896  cONE->Print("HistRMSHF.png");
897  cONE->Clear();
898  }
899  }
900  if (test == 4) {
901  if (sub == 1) {
902  cONE->Print("Hist43TStoAllTSHB.png");
903  cONE->Clear();
904  }
905  if (sub == 2) {
906  cONE->Print("Hist43TStoAllTSHE.png");
907  cONE->Clear();
908  }
909  if (sub == 3) {
910  cONE->Print("Hist43TStoAllTSHO.png");
911  cONE->Clear();
912  }
913  if (sub == 4) {
914  cONE->Print("Hist43TStoAllTSHF.png");
915  cONE->Clear();
916  }
917  }
918  if (test == 5) {
919  if (sub == 1) {
920  cONE->Print("HistMeanPosHB.png");
921  cONE->Clear();
922  }
923  if (sub == 2) {
924  cONE->Print("HistMeanPosHE.png");
925  cONE->Clear();
926  }
927  if (sub == 3) {
928  cONE->Print("HistMeanPosHO.png");
929  cONE->Clear();
930  }
931  if (sub == 4) {
932  cONE->Print("HistMeanPosHF.png");
933  cONE->Clear();
934  }
935  }
936  if (test == 6) {
937  if (sub == 1) {
938  cONE->Print("HistMaxPosHB.png");
939  cONE->Clear();
940  }
941  if (sub == 2) {
942  cONE->Print("HistMaxPosHE.png");
943  cONE->Clear();
944  }
945  if (sub == 3) {
946  cONE->Print("HistMaxPosHO.png");
947  cONE->Clear();
948  }
949  if (sub == 4) {
950  cONE->Print("HistMaxPosHF.png");
951  cONE->Clear();
952  }
953  }
954  } // end sub
955  } //end test
956 
957  TH2F *Map_Calib[5][5]; // 2d histogramm for subdet, depth
958 
959  Map_Calib[1][1] = (TH2F *)dir->FindObjectAny("h_map_HB");
960  Map_Calib[1][2] = (TH2F *)dir->FindObjectAny("h_map_HB");
961  Map_Calib[2][1] = (TH2F *)dir->FindObjectAny("h_map_HE");
962  Map_Calib[2][2] = (TH2F *)dir->FindObjectAny("h_map_HE");
963  Map_Calib[2][3] = (TH2F *)dir->FindObjectAny("h_map_HE");
964  Map_Calib[3][4] = (TH2F *)dir->FindObjectAny("h_map_HO");
965  Map_Calib[4][1] = (TH2F *)dir->FindObjectAny("h_map_HF");
966  Map_Calib[4][2] = (TH2F *)dir->FindObjectAny("h_map_HF");
967 
968  //+++++++++++++++++++++++++++++
969  //Test 0 Entries
970  //+++++++++++++++++++++++++++++
971 
972  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
973  // if (sub==1) cHB->Divide(2,1);
974  // if (sub==2) cHE->Divide(3,1);
975  cONE->Divide(1, 1);
976  // if (sub==4) cHB->Divide(2,1);
977  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
978  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
979  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
980  int k = 1;
981  cONE->cd(k);
982  // if (sub==1) cHB->cd(k);
983  // if (sub==2) cHE->cd(k);
984  if (sub == 3)
985  k = 4;
986  // if (sub==4) cHB->cd(k);
987  gPad->SetGridy();
988  gPad->SetGridx();
989  gPad->SetLogz();
990  if (sub == 1)
991  sprintf(str, "HB");
992  if (sub == 2)
993  sprintf(str, "HE");
994  if (sub == 3)
995  sprintf(str, "HO");
996  if (sub == 4)
997  sprintf(str, "HF");
998  Map_Calib[sub][k]->SetTitle(str);
999  Map_Calib[sub][k]->SetXTitle("#eta \b");
1000  Map_Calib[sub][k]->SetYTitle("#phi \b");
1001  Map_Calib[sub][k]->SetZTitle("Number of events\b");
1002  if (sub == 3)
1003  Map_Calib[sub][k]->SetTitleOffset(0.8, "Z");
1004  Map_Calib[sub][k]->Draw("COLZ");
1005  Map_Calib[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1006  // Map_Calib[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
1007  // if (sub==1) {cHB->Modified(); cHB->Update();}
1008  // if (sub==2) {cHE->Modified(); cHE->Update();}
1009  cONE->Modified();
1010  cONE->Update();
1011  // if (sub==4) {cHB->Modified(); cHB->Update();}
1012  // }//end depth
1013 
1014  if (sub == 1) {
1015  cONE->Print("MapRateCalibEntryHB.png");
1016  cONE->Clear();
1017  }
1018  if (sub == 2) {
1019  cONE->Print("MapRateCalibEntryHE.png");
1020  cONE->Clear();
1021  }
1022  if (sub == 3) {
1023  cONE->Print("MapRateCalibEntryHO.png");
1024  cONE->Clear();
1025  }
1026  if (sub == 4) {
1027  cONE->Print("MapRateCalibEntryHF.png");
1028  cONE->Clear();
1029  }
1030  } // end sub
1031 
1032  //+++++++++++++++++++++++++++++
1033  //Test 11 (Cc) Rate of Cap ID errors for calibration channels
1034  //+++++++++++++++++++++++++++++
1035 
1036  Map_Ampl[11][1][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HB");
1037  Map_Ampl[11][1][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HB");
1038  Map_Ampl[11][2][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1039  Map_Ampl[11][2][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1040  Map_Ampl[11][2][3] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HE");
1041  Map_Ampl[11][3][4] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HO");
1042  Map_Ampl[11][4][1] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HF");
1043  Map_Ampl[11][4][2] = (TH2F *)dir->FindObjectAny("h_mapCapCalib047_HF");
1044 
1045  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1046  // if (sub==1) cHB->Divide(2,1);
1047  // if (sub==2) cHE->Divide(3,1);
1048  cONE->Divide(1, 1);
1049  // if (sub==4) cHB->Divide(2,1);
1050  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1051  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1052  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
1053  int k = 1;
1054  cONE->cd(k);
1055  // if (sub==1) cHB->cd(k);
1056  // if (sub==2) cHE->cd(k);
1057  if (sub == 3)
1058  k = 4;
1059  // if (sub==4) cHB->cd(k);
1060  Map_Ampl[11][sub][k]->Divide(Map_Ampl[11][sub][k], Map_Calib[sub][k], 1, 1, "B");
1061  gPad->SetGridy();
1062  gPad->SetGridx();
1063  gPad->SetLogz();
1064  if (sub == 1)
1065  sprintf(str, "HB");
1066  if (sub == 2)
1067  sprintf(str, "HE");
1068  if (sub == 3)
1069  sprintf(str, "HO");
1070  if (sub == 4)
1071  sprintf(str, "HF");
1072  Map_Ampl[11][sub][k]->SetTitle(str);
1073  Map_Ampl[11][sub][k]->SetXTitle("#eta \b");
1074  Map_Ampl[11][sub][k]->SetYTitle("#phi \b");
1075  Map_Ampl[11][sub][k]->SetZTitle("Rate \b");
1076  Map_Ampl[11][sub][k]->SetTitleOffset(0.75, "Z");
1077  Map_Ampl[11][sub][k]->Draw("COLZ");
1078  Map_Ampl[11][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1079  Map_Ampl[11][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
1080  // if (sub==1) {cHB->Modified(); cHB->Update();}
1081  // if (sub==2) {cHE->Modified(); cHE->Update();}
1082  cONE->Modified();
1083  cONE->Update();
1084  // if (sub==4) {cHB->Modified(); cHB->Update();}
1085  // }//end depth
1086 
1087  if (sub == 1) {
1088  cONE->Print("MapRateCapCalibHB.png");
1089  cONE->Clear();
1090  }
1091  if (sub == 2) {
1092  cONE->Print("MapRateCapCalibHE.png");
1093  cONE->Clear();
1094  }
1095  if (sub == 3) {
1096  cONE->Print("MapRateCapCalibHO.png");
1097  cONE->Clear();
1098  }
1099  if (sub == 4) {
1100  cONE->Print("MapRateCapCalibHF.png");
1101  cONE->Clear();
1102  }
1103  } // end sub
1104 
1105  //+++++++++++++++++++++++++++++
1106  //Test 12 (Ac) ADC amplitude for calibration chanels
1107  //+++++++++++++++++++++++++++++
1108 
1109  Map_Ampl[12][1][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HB");
1110  Map_Ampl[12][1][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HB");
1111  Map_Ampl[12][2][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1112  Map_Ampl[12][2][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1113  Map_Ampl[12][2][3] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HE");
1114  Map_Ampl[12][3][4] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HO");
1115  Map_Ampl[12][4][1] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HF");
1116  Map_Ampl[12][4][2] = (TH2F *)dir->FindObjectAny("h_mapADCCalib047_HF");
1117 
1118  HistAmpl[12][1] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HB");
1119  HistAmpl[12][2] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HE");
1120  HistAmpl[12][3] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HO");
1121  HistAmpl[12][4] = (TH1F *)dir->FindObjectAny("h_ADCCalib_HF");
1122 
1123  //+++++++++++++++++++++++++++++
1124  //Test 13 (Wc) Rate of RMS
1125  //+++++++++++++++++++++++++++++
1126 
1127  Map_Ampl[13][1][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HB");
1128  Map_Ampl[13][1][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HB");
1129  Map_Ampl[13][2][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1130  Map_Ampl[13][2][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1131  Map_Ampl[13][2][3] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HE");
1132  Map_Ampl[13][3][4] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HO");
1133  Map_Ampl[13][4][1] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HF");
1134  Map_Ampl[13][4][2] = (TH2F *)dir->FindObjectAny("h_mapWidthCalib047_HF");
1135 
1136  HistAmpl[13][1] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HB");
1137  HistAmpl[13][2] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HE");
1138  HistAmpl[13][3] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HO");
1139  HistAmpl[13][4] = (TH1F *)dir->FindObjectAny("h_WidthCalib_HF");
1140 
1141  //+++++++++++++++++++++++++++++
1142  //Test 14 (Rc) Rate of ratio 4 near max TS/ All TS
1143  //+++++++++++++++++++++++++++++
1144 
1145  Map_Ampl[14][1][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HB");
1146  Map_Ampl[14][1][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HB");
1147  Map_Ampl[14][2][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1148  Map_Ampl[14][2][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1149  Map_Ampl[14][2][3] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HE");
1150  Map_Ampl[14][3][4] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HO");
1151  Map_Ampl[14][4][1] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HF");
1152  Map_Ampl[14][4][2] = (TH2F *)dir->FindObjectAny("h_mapRatioCalib047_HF");
1153 
1154  HistAmpl[14][1] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HB");
1155  HistAmpl[14][2] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HE");
1156  HistAmpl[14][3] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HO");
1157  HistAmpl[14][4] = (TH1F *)dir->FindObjectAny("h_RatioCalib_HF");
1158 
1159  //+++++++++++++++++++++++++++++
1160  //Test 15 (TNc) Mean position in 1-8 TS range
1161  //+++++++++++++++++++++++++++++
1162 
1163  Map_Ampl[15][1][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HB");
1164  Map_Ampl[15][1][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HB");
1165  Map_Ampl[15][2][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1166  Map_Ampl[15][2][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1167  Map_Ampl[15][2][3] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HE");
1168  Map_Ampl[15][3][4] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HO");
1169  Map_Ampl[15][4][1] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HF");
1170  Map_Ampl[15][4][2] = (TH2F *)dir->FindObjectAny("h_mapTSmeanCalib047_HF");
1171 
1172  HistAmpl[15][1] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HB");
1173  HistAmpl[15][2] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HE");
1174  HistAmpl[15][3] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HO");
1175  HistAmpl[15][4] = (TH1F *)dir->FindObjectAny("h_TSmeanCalib_HF");
1176 
1177  //+++++++++++++++++++++++++++++
1178  //Test 16 (TXc) Maximum position in 1-8 TS range
1179  //+++++++++++++++++++++++++++++
1180 
1181  Map_Ampl[16][1][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HB");
1182  Map_Ampl[16][1][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HB");
1183  Map_Ampl[16][2][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1184  Map_Ampl[16][2][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1185  Map_Ampl[16][2][3] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HE");
1186  Map_Ampl[16][3][4] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HO");
1187  Map_Ampl[16][4][1] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HF");
1188  Map_Ampl[16][4][2] = (TH2F *)dir->FindObjectAny("h_mapTSmaxCalib047_HF");
1189 
1190  HistAmpl[16][1] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HB");
1191  HistAmpl[16][2] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HE");
1192  HistAmpl[16][3] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HO");
1193  HistAmpl[16][4] = (TH1F *)dir->FindObjectAny("h_TSmaxCalib_HF");
1194 
1195  for (int test = 12; test <= 16; test++) { //Test: 2-Am, 3-Wm, 4-Rm, 5-TNm, 6-TXm,
1196  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1197  if (sub == 1)
1198  cONE->Divide(1, 1); //cHB->Divide(2,1);
1199  if (sub == 2)
1200  cONE->Divide(1, 1); //cHE->Divide(3,1);
1201  if (sub == 3)
1202  cONE->Divide(1, 1);
1203  if (sub == 4)
1204  cONE->Divide(1, 1); //cHB->Divide(2,1);
1205  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1206  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1207  // for (int k=k_min[sub];k<=k_max[sub];k++) { //Depth
1208  int k = 1;
1209  if (sub == 1) {
1210  k = 1;
1211  cONE->cd(k);
1212  } //cHB->cd(k); }
1213  if (sub == 2) {
1214  k = 1;
1215  cONE->cd(k);
1216  } //cHE->cd(k); }
1217  if (sub == 3) {
1218  k = 4;
1219  cONE->cd(k - 3);
1220  }
1221  if (sub == 4) {
1222  k = 1;
1223  cONE->cd(k);
1224  } //cHB->cd(k); }
1225  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_Calib[sub][k], 1, 1, "B");
1226  gPad->SetGridy();
1227  gPad->SetGridx();
1228  gPad->SetLogz();
1229  if (sub == 1)
1230  sprintf(str, "HB");
1231  if (sub == 2)
1232  sprintf(str, "HE");
1233  if (sub == 3)
1234  sprintf(str, "HO");
1235  if (sub == 4)
1236  sprintf(str, "HF");
1237  Map_Ampl[test][sub][k]->SetTitle(str);
1238  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
1239  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
1240  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
1241  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
1242  Map_Ampl[test][sub][k]->Draw("COLZ");
1243  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1244  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.00001, 1.);
1245  // if (sub==1) {cHB->Modified(); cHB->Update();}
1246  // if (sub==2) {cHE->Modified(); cHE->Update();}
1247  cONE->Modified();
1248  cONE->Update();
1249  // if (sub==4) {cHB->Modified(); cHB->Update();}
1250  // }//end depth
1251  if (test == 12) {
1252  if (sub == 1) {
1253  cONE->Print("MapRateAmplCalibHB.png");
1254  cONE->Clear();
1255  }
1256  if (sub == 2) {
1257  cONE->Print("MapRateAmplCalibHE.png");
1258  cONE->Clear();
1259  }
1260  if (sub == 3) {
1261  cONE->Print("MapRateAmplCalibHO.png");
1262  cONE->Clear();
1263  }
1264  if (sub == 4) {
1265  cONE->Print("MapRateAmplCalibHF.png");
1266  cONE->Clear();
1267  }
1268  }
1269  if (test == 13) {
1270  if (sub == 1) {
1271  cONE->Print("MapRateRMSCalibHB.png");
1272  cONE->Clear();
1273  }
1274  if (sub == 2) {
1275  cONE->Print("MapRateRMSCalibHE.png");
1276  cONE->Clear();
1277  }
1278  if (sub == 3) {
1279  cONE->Print("MapRateRMSCalibHO.png");
1280  cONE->Clear();
1281  }
1282  if (sub == 4) {
1283  cONE->Print("MapRateRMSCalibHF.png");
1284  cONE->Clear();
1285  }
1286  }
1287  if (test == 14) {
1288  if (sub == 1) {
1289  cONE->Print("MapRate43TStoAllTSCalibHB.png");
1290  cONE->Clear();
1291  }
1292  if (sub == 2) {
1293  cONE->Print("MapRate43TStoAllTSCalibHE.png");
1294  cONE->Clear();
1295  }
1296  if (sub == 3) {
1297  cONE->Print("MapRate43TStoAllTSCalibHO.png");
1298  cONE->Clear();
1299  }
1300  if (sub == 4) {
1301  cONE->Print("MapRate43TStoAllTSCalibHF.png");
1302  cONE->Clear();
1303  }
1304  }
1305  if (test == 15) {
1306  if (sub == 1) {
1307  cONE->Print("MapRateMeanPosCalibHB.png");
1308  cONE->Clear();
1309  }
1310  if (sub == 2) {
1311  cONE->Print("MapRateMeanPosCalibHE.png");
1312  cONE->Clear();
1313  }
1314  if (sub == 3) {
1315  cONE->Print("MapRateMeanPosCalibHO.png");
1316  cONE->Clear();
1317  }
1318  if (sub == 4) {
1319  cONE->Print("MapRateMeanPosCalibHF.png");
1320  cONE->Clear();
1321  }
1322  }
1323  if (test == 16) {
1324  if (sub == 1) {
1325  cONE->Print("MapRateMaxPosCalibHB.png");
1326  cONE->Clear();
1327  }
1328  if (sub == 2) {
1329  cONE->Print("MapRateMaxPosCalibHE.png");
1330  cONE->Clear();
1331  }
1332  if (sub == 3) {
1333  cONE->Print("MapRateMaxPosCalibHO.png");
1334  cONE->Clear();
1335  }
1336  if (sub == 4) {
1337  cONE->Print("MapRateMaxPosCalibHF.png");
1338  cONE->Clear();
1339  }
1340  }
1341 
1342  cONE->Divide(1, 1);
1343  cONE->cd(1);
1344  gPad->SetGridy();
1345  gPad->SetGridx();
1346  gPad->SetLogy();
1347  if (sub == 1)
1348  HistAmpl[test][sub]->SetTitle("HB, All Depth");
1349  if (sub == 2)
1350  HistAmpl[test][sub]->SetTitle("HE, All Depth");
1351  if (sub == 3)
1352  HistAmpl[test][sub]->SetTitle("HO, All Depth");
1353  if (sub == 4)
1354  HistAmpl[test][sub]->SetTitle("HF, All Depth");
1355  if (test == 12)
1356  HistAmpl[test][sub]->SetXTitle("ADC Amlitude in each event & cell \b");
1357  if (test == 13)
1358  HistAmpl[test][sub]->SetXTitle("Amplitude RMS in each event & cell \b");
1359  if (test == 14)
1360  HistAmpl[test][sub]->SetXTitle("Ratio in each event & cell \b");
1361  if (test == 15)
1362  HistAmpl[test][sub]->SetXTitle("Mean TS position in each event & cell \b");
1363  if (test == 16)
1364  HistAmpl[test][sub]->SetXTitle("Max TS position in each event & cell \b");
1365  HistAmpl[test][sub]->SetYTitle("Number of cell-events \b");
1366  HistAmpl[test][sub]->SetLineColor(4);
1367  HistAmpl[test][sub]->SetLineWidth(2);
1368  HistAmpl[test][sub]->SetTitleOffset(1.4, "Y");
1369  HistAmpl[test][sub]->Draw("");
1370  // HistAmpl[test][sub]->GetYaxis()->SetRangeUser(1., 100.);
1371  if (test == 12) {
1372  gPad->SetLogx();
1373  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(1., 10000.);
1374  }
1375  if (test == 13)
1376  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 5.);
1377  if (test == 14)
1378  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 1.);
1379  if (test == 15)
1380  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);
1381  if (test == 16)
1382  HistAmpl[test][sub]->GetXaxis()->SetRangeUser(0., 9.);
1383  cONE->Modified();
1384  cONE->Update();
1385  double min_x[] = {MIN_C[test - 10][sub], MIN_C[test - 10][sub]};
1386  double min_y[] = {0., 100000000.};
1387  TGraph *MIN = new TGraph(2, min_x, min_y);
1388  MIN->SetLineStyle(2);
1389  MIN->SetLineColor(2);
1390  MIN->SetLineWidth(2 + 100 * 100);
1391  MIN->SetFillStyle(3005);
1392  MIN->SetFillColor(2);
1393  MIN->Draw("L");
1394  double max_x[] = {MAX_C[test - 10][sub], MAX_C[test - 10][sub]};
1395  double max_y[] = {0., 100000000.};
1396  TGraph *MAX = new TGraph(2, max_x, max_y);
1397  MAX->SetLineStyle(2);
1398  MAX->SetLineColor(2);
1399  MAX->SetLineWidth(-2 - 100 * 100);
1400  MAX->SetFillStyle(3004);
1401  MAX->SetFillColor(2);
1402  MAX->Draw("L");
1403  if (test == 12) {
1404  if (sub == 1) {
1405  cONE->Print("HistAmplCalibHB.png");
1406  cONE->Clear();
1407  }
1408  if (sub == 2) {
1409  cONE->Print("HistAmplCalibHE.png");
1410  cONE->Clear();
1411  }
1412  if (sub == 3) {
1413  cONE->Print("HistAmplCalibHO.png");
1414  cONE->Clear();
1415  }
1416  if (sub == 4) {
1417  cONE->Print("HistAmplCalibHF.png");
1418  cONE->Clear();
1419  }
1420  }
1421  if (test == 13) {
1422  if (sub == 1) {
1423  cONE->Print("HistRMSCalibHB.png");
1424  cONE->Clear();
1425  }
1426  if (sub == 2) {
1427  cONE->Print("HistRMSCalibHE.png");
1428  cONE->Clear();
1429  }
1430  if (sub == 3) {
1431  cONE->Print("HistRMSCalibHO.png");
1432  cONE->Clear();
1433  }
1434  if (sub == 4) {
1435  cONE->Print("HistRMSCalibHF.png");
1436  cONE->Clear();
1437  }
1438  }
1439  if (test == 14) {
1440  if (sub == 1) {
1441  cONE->Print("Hist43TStoAllTSCalibHB.png");
1442  cONE->Clear();
1443  }
1444  if (sub == 2) {
1445  cONE->Print("Hist43TStoAllTSCalibHE.png");
1446  cONE->Clear();
1447  }
1448  if (sub == 3) {
1449  cONE->Print("Hist43TStoAllTSCalibHO.png");
1450  cONE->Clear();
1451  }
1452  if (sub == 4) {
1453  cONE->Print("Hist43TStoAllTSCalibHF.png");
1454  cONE->Clear();
1455  }
1456  }
1457  if (test == 15) {
1458  if (sub == 1) {
1459  cONE->Print("HistMeanPosCalibHB.png");
1460  cONE->Clear();
1461  }
1462  if (sub == 2) {
1463  cONE->Print("HistMeanPosCalibHE.png");
1464  cONE->Clear();
1465  }
1466  if (sub == 3) {
1467  cONE->Print("HistMeanPosCalibHO.png");
1468  cONE->Clear();
1469  }
1470  if (sub == 4) {
1471  cONE->Print("HistMeanPosCalibHF.png");
1472  cONE->Clear();
1473  }
1474  }
1475  if (test == 16) {
1476  if (sub == 1) {
1477  cONE->Print("HistMaxPosCalibHB.png");
1478  cONE->Clear();
1479  }
1480  if (sub == 2) {
1481  cONE->Print("HistMaxPosCalibHE.png");
1482  cONE->Clear();
1483  }
1484  if (sub == 3) {
1485  cONE->Print("HistMaxPosCalibHO.png");
1486  cONE->Clear();
1487  }
1488  if (sub == 4) {
1489  cONE->Print("HistMaxPosCalibHF.png");
1490  cONE->Clear();
1491  }
1492  }
1493  } // end sub
1494  } //end test
1495 
1496  //+++++++++++++++++++++++++++++
1497  //Test 21 (GS) Amplitude drift
1498  //+++++++++++++++++++++++++++++
1499 
1500  Map_Ampl[21][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HB");
1501  Map_Ampl[21][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HB");
1502  Map_Ampl[21][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HB");
1503  Map_Ampl[21][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HB");
1504  Map_Ampl[21][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HE");
1505  Map_Ampl[21][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HE");
1506  Map_Ampl[21][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HE");
1507  Map_Ampl[21][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HE");
1508  Map_Ampl[21][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5AmplE34_HE");
1509  Map_Ampl[21][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6AmplE34_HE");
1510  Map_Ampl[21][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7AmplE34_HE");
1511  Map_Ampl[21][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HO");
1512  Map_Ampl[21][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1AmplE34_HF");
1513  Map_Ampl[21][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2AmplE34_HF");
1514  Map_Ampl[21][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3AmplE34_HF");
1515  Map_Ampl[21][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4AmplE34_HF");
1516 
1517  TH2F *Map_RefAmpl[5][ALLDEPTH]; // 2D histogramm for subdet, depth
1518  TH2F *Map_RefSUB[5][ALLDEPTH]; // 2d histogramm for subdet, depth
1519 
1520  Map_RefAmpl[1][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HB");
1521  Map_RefAmpl[1][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HB");
1522  Map_RefAmpl[1][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HB");
1523  Map_RefAmpl[1][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HB");
1524  Map_RefAmpl[2][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HE");
1525  Map_RefAmpl[2][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HE");
1526  Map_RefAmpl[2][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HE");
1527  Map_RefAmpl[2][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HE");
1528  Map_RefAmpl[2][5] = (TH2F *)refdir->FindObjectAny("h_mapDepth5AmplE34_HE");
1529  Map_RefAmpl[2][6] = (TH2F *)refdir->FindObjectAny("h_mapDepth6AmplE34_HE");
1530  Map_RefAmpl[2][7] = (TH2F *)refdir->FindObjectAny("h_mapDepth7AmplE34_HE");
1531  Map_RefAmpl[3][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HO");
1532  Map_RefAmpl[4][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1AmplE34_HF");
1533  Map_RefAmpl[4][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2AmplE34_HF");
1534  Map_RefAmpl[4][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3AmplE34_HF");
1535  Map_RefAmpl[4][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4AmplE34_HF");
1536 
1537  Map_RefSUB[1][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HB");
1538  Map_RefSUB[1][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HB");
1539  Map_RefSUB[1][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HB");
1540  Map_RefSUB[1][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HB");
1541  Map_RefSUB[2][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HE");
1542  Map_RefSUB[2][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HE");
1543  Map_RefSUB[2][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HE");
1544  Map_RefSUB[2][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HE");
1545  Map_RefSUB[2][5] = (TH2F *)refdir->FindObjectAny("h_mapDepth5_HE");
1546  Map_RefSUB[2][6] = (TH2F *)refdir->FindObjectAny("h_mapDepth6_HE");
1547  Map_RefSUB[2][7] = (TH2F *)refdir->FindObjectAny("h_mapDepth7_HE");
1548  Map_RefSUB[3][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HO");
1549  Map_RefSUB[4][1] = (TH2F *)refdir->FindObjectAny("h_mapDepth1_HF");
1550  Map_RefSUB[4][2] = (TH2F *)refdir->FindObjectAny("h_mapDepth2_HF");
1551  Map_RefSUB[4][3] = (TH2F *)refdir->FindObjectAny("h_mapDepth3_HF");
1552  Map_RefSUB[4][4] = (TH2F *)refdir->FindObjectAny("h_mapDepth4_HF");
1553 
1554  HistAmplDepth[21][1][1] = new TH1F("diffAmpl_Depth1_HB", "", 100, -10., 10.);
1555  HistAmplDepth[21][1][2] = new TH1F("diffAmpl_Depth2_HB", "", 100, -10., 10.);
1556  HistAmplDepth[21][1][3] = new TH1F("diffAmpl_Depth3_HB", "", 100, -10., 10.);
1557  HistAmplDepth[21][1][4] = new TH1F("diffAmpl_Depth4_HB", "", 100, -10., 10.);
1558  HistAmplDepth[21][2][1] = new TH1F("diffAmpl_Depth1_HE", "", 100, -10., 10.);
1559  HistAmplDepth[21][2][2] = new TH1F("diffAmpl_Depth2_HE", "", 100, -10., 10.);
1560  HistAmplDepth[21][2][3] = new TH1F("diffAmpl_Depth3_HE", "", 100, -10., 10.);
1561  HistAmplDepth[21][2][4] = new TH1F("diffAmpl_Depth4_HE", "", 100, -10., 10.);
1562  HistAmplDepth[21][2][5] = new TH1F("diffAmpl_Depth5_HE", "", 100, -10., 10.);
1563  HistAmplDepth[21][2][6] = new TH1F("diffAmpl_Depth6_HE", "", 100, -10., 10.);
1564  HistAmplDepth[21][2][7] = new TH1F("diffAmpl_Depth7_HE", "", 100, -10., 10.);
1565  HistAmplDepth[21][3][4] = new TH1F("diffAmpl_Depth4_HO", "", 100, -10., 10.);
1566  HistAmplDepth[21][4][1] = new TH1F("diffAmpl_Depth1_HF", "", 100, -10., 10.);
1567  HistAmplDepth[21][4][2] = new TH1F("diffAmpl_Depth2_HF", "", 100, -10., 10.);
1568  HistAmplDepth[21][4][3] = new TH1F("diffAmpl_Depth3_HF", "", 100, -10., 10.);
1569  HistAmplDepth[21][4][4] = new TH1F("diffAmpl_Depth4_HF", "", 100, -10., 10.);
1570 
1571  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
1572  // if (sub==1) cHB->Divide(2,1);
1573  if (sub == 1)
1574  cHB->Divide(2, 2);
1575  // if (sub==2) cHE->Divide(3,1);
1576  if (sub == 2)
1577  cHE->Divide(3, 3);
1578  if (sub == 3)
1579  cONE->Divide(1, 1);
1580  // if (sub==4) cHF->Divide(2,1);
1581  if (sub == 4)
1582  cHF->Divide(2, 2);
1583  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1584  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1585  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
1586  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1587  if (sub == 1)
1588  cHB->cd(k);
1589  if (sub == 2)
1590  cHE->cd(k);
1591  if (sub == 3)
1592  cONE->cd(k - 3);
1593  if (sub == 4)
1594  cHF->cd(k);
1595  Map_Ampl[21][sub][k]->Divide(Map_Ampl[21][sub][k], Map_SUB[sub][k], 1, 1, "B");
1596  gPad->SetGridy();
1597  gPad->SetGridx();
1598  gPad->SetLogz();
1599  if (sub == 1)
1600  sprintf(str, "HB, Depth%d \b", k);
1601  if (sub == 2)
1602  sprintf(str, "HE, Depth%d \b", k);
1603  if (sub == 3)
1604  sprintf(str, "HO, Depth%d \b", k);
1605  if (sub == 4)
1606  sprintf(str, "HF, Depth%d \b", k);
1607  Map_Ampl[21][sub][k]->SetTitle(str);
1608  Map_Ampl[21][sub][k]->SetXTitle("#eta \b");
1609  Map_Ampl[21][sub][k]->SetYTitle("#phi \b");
1610  Map_Ampl[21][sub][k]->SetZTitle("Response \b");
1611  Map_Ampl[21][sub][k]->SetTitleOffset(1.1, "Z");
1612  Map_Ampl[21][sub][k]->Draw("COLZ");
1613  Map_Ampl[21][sub][k]->GetYaxis()->SetRangeUser(0, 71.);
1614  // Map_Ampl[21][sub][k]->GetZaxis()->SetRangeUser(1., 10.);
1615  if (sub == 1) {
1616  cHB->Modified();
1617  cHB->Update();
1618  }
1619  if (sub == 2) {
1620  cHE->Modified();
1621  cHE->Update();
1622  }
1623  if (sub == 3) {
1624  cONE->Modified();
1625  cONE->Update();
1626  }
1627  if (sub == 4) {
1628  cHF->Modified();
1629  cHF->Update();
1630  }
1631  } //end depth
1632  if (sub == 1) {
1633  cHB->Print("MapRateAmpl1HB.png");
1634  cHB->Clear();
1635  }
1636  if (sub == 2) {
1637  cHE->Print("MapRateAmpl1HE.png");
1638  cHE->Clear();
1639  }
1640  if (sub == 3) {
1641  cONE->Print("MapRateAmpl1HO.png");
1642  cONE->Clear();
1643  }
1644  if (sub == 4) {
1645  cHF->Print("MapRateAmpl1HF.png");
1646  cHF->Clear();
1647  }
1648 
1649  // if (sub==1) cHB->Divide(2,1);
1650  if (sub == 1)
1651  cHB->Divide(2, 2);
1652  // if (sub==2) cHE->Divide(3,1);
1653  if (sub == 2)
1654  cHE->Divide(3, 3);
1655  if (sub == 3)
1656  cONE->Divide(1, 1);
1657  // if (sub==4) cHF->Divide(2,1);
1658  if (sub == 4)
1659  cHF->Divide(2, 2);
1660 
1661  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1662  if (sub == 1)
1663  cHB->cd(k);
1664  if (sub == 2)
1665  cHE->cd(k);
1666  if (sub == 3)
1667  cONE->cd(k - 3);
1668  if (sub == 4)
1669  cHF->cd(k);
1670  Map_RefAmpl[sub][k]->Divide(Map_RefAmpl[sub][k], Map_RefSUB[sub][k], 1, 1, "B");
1671  gPad->SetGridy();
1672  gPad->SetGridx();
1673  gPad->SetLogz();
1674  if (sub == 1)
1675  sprintf(str, "HB, Depth%d \b", k);
1676  if (sub == 2)
1677  sprintf(str, "HE, Depth%d \b", k);
1678  if (sub == 3)
1679  sprintf(str, "HO, Depth%d \b", k);
1680  if (sub == 4)
1681  sprintf(str, "HF, Depth%d \b", k);
1682  Map_RefAmpl[sub][k]->SetTitle(str);
1683  Map_RefAmpl[sub][k]->SetXTitle("#eta \b");
1684  Map_RefAmpl[sub][k]->SetYTitle("#phi \b");
1685  Map_RefAmpl[sub][k]->SetZTitle("Response\b");
1686  Map_RefAmpl[sub][k]->SetTitleOffset(1.1, "Z");
1687  Map_RefAmpl[sub][k]->Draw("COLZ");
1688  Map_RefAmpl[sub][k]->GetYaxis()->SetRangeUser(0, 71.);
1689  // Map_RefAmpl[21][sub][k]->GetZaxis()->SetRangeUser(1., 10.);
1690  if (sub == 1) {
1691  cHB->Modified();
1692  cHB->Update();
1693  }
1694  if (sub == 2) {
1695  cHE->Modified();
1696  cHE->Update();
1697  }
1698  if (sub == 3) {
1699  cONE->Modified();
1700  cONE->Update();
1701  }
1702  if (sub == 4) {
1703  cHF->Modified();
1704  cHF->Update();
1705  }
1706  } //end depth
1707  if (sub == 1) {
1708  cHB->Print("MapRateAmpl2HB.png");
1709  cHB->Clear();
1710  }
1711  if (sub == 2) {
1712  cHE->Print("MapRateAmpl2HE.png");
1713  cHE->Clear();
1714  }
1715  if (sub == 3) {
1716  cONE->Print("MapRateAmpl2HO.png");
1717  cONE->Clear();
1718  }
1719  if (sub == 4) {
1720  cHF->Print("MapRateAmpl2HF.png");
1721  cHF->Clear();
1722  }
1723 
1724  // if (sub==1) cHB->Divide(2,1);
1725  if (sub == 1)
1726  cHB->Divide(2, 2);
1727  // if (sub==2) cHE->Divide(3,1);
1728  if (sub == 2)
1729  cHE->Divide(3, 3);
1730  if (sub == 3)
1731  cONE->Divide(1, 1);
1732  // if (sub==4) cHF->Divide(2,1);
1733  if (sub == 4)
1734  cHF->Divide(2, 2);
1735 
1736  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1737  if (sub == 1)
1738  cHB->cd(k);
1739  if (sub == 2)
1740  cHE->cd(k);
1741  if (sub == 3)
1742  cONE->cd(k - 3);
1743  if (sub == 4)
1744  cHF->cd(k);
1745  TH2F *TTT = new TH2F("Map", "Map", 82, -41, 40, 72, 0, 71);
1746  for (int x = 1; x <= Map_Ampl[21][sub][k]->GetXaxis()->GetNbins(); x++) {
1747  for (int y = 1; y <= Map_Ampl[21][sub][k]->GetYaxis()->GetNbins(); y++) {
1748  if (Map_Ampl[21][sub][k]->GetBinContent(x, y) != 0 && Map_RefAmpl[sub][k]->GetBinContent(x, y) != 0) {
1749  double ccc1 = Map_Ampl[21][sub][k]->GetBinContent(x, y) - Map_RefAmpl[sub][k]->GetBinContent(x, y);
1750  ccc1 = 100. * ccc1 / Map_Ampl[21][sub][k]->GetBinContent(x, y); // in %
1751  HistAmplDepth[21][sub][k]->Fill(ccc1);
1752  Map_Ampl[21][sub][k]->SetBinContent(x, y, fabs(ccc1));
1753  if (fabs(ccc1) > porog[sub])
1754  TTT->SetBinContent(x, y, fabs(ccc1));
1755  else
1756  TTT->SetBinContent(x, y, 0);
1757  }
1758  } //end y
1759  } //esnd x
1760  gPad->SetGridy();
1761  gPad->SetGridx();
1762  // gPad->SetLogz();
1763  if (sub == 1)
1764  sprintf(str, "HB, Depth%d \b", k);
1765  if (sub == 2)
1766  sprintf(str, "HE, Depth%d \b", k);
1767  if (sub == 3)
1768  sprintf(str, "HO, Depth%d \b", k);
1769  if (sub == 4)
1770  sprintf(str, "HF, Depth%d \b", k);
1771  TTT->SetTitle(str);
1772  TTT->SetXTitle("#eta \b");
1773  TTT->SetYTitle("#phi \b");
1774  TTT->SetZTitle("Relative difference, % \b");
1775  TTT->SetTitleOffset(0.9, "Z");
1776  TTT->Draw("COLZ");
1777  TTT->GetYaxis()->SetRangeUser(0, 71.);
1778  TTT->GetZaxis()->SetRangeUser(0, 10.);
1779  if (sub == 1) {
1780  cHB->Modified();
1781  cHB->Update();
1782  }
1783  if (sub == 2) {
1784  cHE->Modified();
1785  cHE->Update();
1786  }
1787  if (sub == 3) {
1788  cONE->Modified();
1789  cONE->Update();
1790  }
1791  if (sub == 4) {
1792  cHF->Modified();
1793  cHF->Update();
1794  }
1795  } //end depth
1796 
1797  if (sub == 1) {
1798  cHB->Print("MapRateAmplDriftHB.png");
1799  cHB->Clear();
1800  }
1801  if (sub == 2) {
1802  cHE->Print("MapRateAmplDriftHE.png");
1803  cHE->Clear();
1804  }
1805  if (sub == 3) {
1806  cONE->Print("MapRateAmplDriftHO.png");
1807  cONE->Clear();
1808  }
1809  if (sub == 4) {
1810  cHF->Print("MapRateAmplDriftHF.png");
1811  cHF->Clear();
1812  }
1814 
1815  // if (sub==1) cHB->Divide(2,1);
1816  if (sub == 1)
1817  cHB->Divide(2, 2);
1818  // if (sub==2) cHE->Divide(3,1);
1819  if (sub == 2)
1820  cHE->Divide(3, 3);
1821  if (sub == 3)
1822  cONE->Divide(1, 1);
1823  // if (sub==4) cHF->Divide(2,1);
1824  if (sub == 4)
1825  cHF->Divide(2, 2);
1826 
1827  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
1828  if (sub == 1)
1829  cHB->cd(k);
1830  if (sub == 2)
1831  cHE->cd(k);
1832  if (sub == 3)
1833  cONE->cd(k - 3);
1834  if (sub == 4)
1835  cHF->cd(k);
1836  gPad->SetGridy();
1837  gPad->SetGridx();
1838  gPad->SetLogy();
1839  if (sub == 1)
1840  sprintf(str, "HB, Depth%d \b", k);
1841  if (sub == 2)
1842  sprintf(str, "HE, Depth%d \b", k);
1843  if (sub == 3)
1844  sprintf(str, "HO, Depth%d \b", k);
1845  if (sub == 4)
1846  sprintf(str, "HF, Depth%d \b", k);
1847  HistAmplDepth[21][sub][k]->SetTitle(str);
1848  HistAmplDepth[21][sub][k]->SetYTitle("Number of cell-events \b");
1849  HistAmplDepth[21][sub][k]->SetXTitle("Per cent \b");
1850  HistAmplDepth[21][sub][k]->SetLineColor(4);
1851  HistAmplDepth[21][sub][k]->SetLineWidth(2);
1852  HistAmplDepth[21][sub][k]->SetTitleOffset(1.4, "Y");
1853  HistAmplDepth[21][sub][k]->Draw();
1854  // HistAmplDepth[21][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
1855  HistAmplDepth[21][sub][k]->GetXaxis()->SetRangeUser(-10., 10.);
1856  if (sub == 1) {
1857  cHB->Modified();
1858  cHB->Update();
1859  }
1860  if (sub == 2) {
1861  cHE->Modified();
1862  cHE->Update();
1863  }
1864  if (sub == 3) {
1865  cONE->Modified();
1866  cONE->Update();
1867  }
1868  if (sub == 4) {
1869  cHF->Modified();
1870  cHF->Update();
1871  }
1872  double min_x[] = {-1 * porog[sub], -1 * porog[sub]};
1873  double min_y[] = {0., 100000000.};
1874  TGraph *MIN = new TGraph(2, min_x, min_y);
1875  MIN->SetLineStyle(2);
1876  MIN->SetLineColor(2);
1877  MIN->SetLineWidth(2 + 100 * 100);
1878  MIN->SetFillStyle(3005);
1879  MIN->SetFillColor(2);
1880  MIN->Draw("L");
1881  double max_x[] = {porog[sub], porog[sub]};
1882  double max_y[] = {0., 100000000.};
1883  TGraph *MAX = new TGraph(2, max_x, max_y);
1884  MAX->SetLineStyle(2);
1885  MAX->SetLineColor(2);
1886  MAX->SetLineWidth(-2 - 100 * 100);
1887  MAX->SetFillStyle(3004);
1888  MAX->SetFillColor(2);
1889  MAX->Draw("L");
1890  } // end depth
1891  if (sub == 1) {
1892  cHB->Print("HistAmplDriftDepthHB.png");
1893  cHB->Clear();
1894  }
1895  if (sub == 2) {
1896  cHE->Print("HistAmplDriftDepthHE.png");
1897  cHE->Clear();
1898  }
1899  if (sub == 3) {
1900  cONE->Print("HistAmplDriftDepthHO.png");
1901  cONE->Clear();
1902  }
1903  if (sub == 4) {
1904  cHF->Print("HistAmplDriftDepthHF.png");
1905  cHF->Clear();
1906  }
1907  } //end sub
1908 
1909  //+++++++++++++++++++++++++++++++++++
1910  //Test 31, 32 Pedestal, pedestalWidths
1911  //++++++++++++++++++++++++++++++++++++
1912 
1913  Map_Ampl[31][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HB");
1914  Map_Ampl[31][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HB");
1915  Map_Ampl[31][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HB");
1916  Map_Ampl[31][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HB");
1917  Map_Ampl[31][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HE");
1918  Map_Ampl[31][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HE");
1919  Map_Ampl[31][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HE");
1920  Map_Ampl[31][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HE");
1921  Map_Ampl[31][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5pedestal_HE");
1922  Map_Ampl[31][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6pedestal_HE");
1923  Map_Ampl[31][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7pedestal_HE");
1924  Map_Ampl[31][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HO");
1925  Map_Ampl[31][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestal_HF");
1926  Map_Ampl[31][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestal_HF");
1927  Map_Ampl[31][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestal_HF");
1928  Map_Ampl[31][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestal_HF");
1929 
1930  Map_Ampl[32][1][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HB");
1931  Map_Ampl[32][1][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HB");
1932  Map_Ampl[32][1][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HB");
1933  Map_Ampl[32][1][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HB");
1934  Map_Ampl[32][2][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HE");
1935  Map_Ampl[32][2][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HE");
1936  Map_Ampl[32][2][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HE");
1937  Map_Ampl[32][2][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HE");
1938  Map_Ampl[32][2][5] = (TH2F *)dir->FindObjectAny("h_mapDepth5pedestalw_HE");
1939  Map_Ampl[32][2][6] = (TH2F *)dir->FindObjectAny("h_mapDepth6pedestalw_HE");
1940  Map_Ampl[32][2][7] = (TH2F *)dir->FindObjectAny("h_mapDepth7pedestalw_HE");
1941  Map_Ampl[32][3][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HO");
1942  Map_Ampl[32][4][1] = (TH2F *)dir->FindObjectAny("h_mapDepth1pedestalw_HF");
1943  Map_Ampl[32][4][2] = (TH2F *)dir->FindObjectAny("h_mapDepth2pedestalw_HF");
1944  Map_Ampl[32][4][3] = (TH2F *)dir->FindObjectAny("h_mapDepth3pedestalw_HF");
1945  Map_Ampl[32][4][4] = (TH2F *)dir->FindObjectAny("h_mapDepth4pedestalw_HF");
1946 
1947  HistPed[1][1][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HB");
1948  HistPed[1][1][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HB");
1949  HistPed[1][1][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HB");
1950  HistPed[1][1][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HB");
1951  HistPed[2][1][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HB");
1952  HistPed[2][1][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HB");
1953  HistPed[2][1][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HB");
1954  HistPed[2][1][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HB");
1955 
1956  HistPed[1][2][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HE");
1957  HistPed[1][2][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HE");
1958  HistPed[1][2][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HE");
1959  HistPed[1][2][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HE");
1960  HistPed[2][2][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HE");
1961  HistPed[2][2][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HE");
1962  HistPed[2][2][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HE");
1963  HistPed[2][2][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HE");
1964 
1965  HistPed[1][3][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HO");
1966  HistPed[1][3][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HO");
1967  HistPed[1][3][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HO");
1968  HistPed[1][3][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HO");
1969  HistPed[2][3][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HO");
1970  HistPed[2][3][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HO");
1971  HistPed[2][3][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HO");
1972  HistPed[2][3][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HO");
1973 
1974  HistPed[1][4][0] = (TH1F *)dir->FindObjectAny("h_pedestal0_HF");
1975  HistPed[1][4][1] = (TH1F *)dir->FindObjectAny("h_pedestal1_HF");
1976  HistPed[1][4][2] = (TH1F *)dir->FindObjectAny("h_pedestal2_HF");
1977  HistPed[1][4][3] = (TH1F *)dir->FindObjectAny("h_pedestal3_HF");
1978  HistPed[2][4][0] = (TH1F *)dir->FindObjectAny("h_pedestalw0_HF");
1979  HistPed[2][4][1] = (TH1F *)dir->FindObjectAny("h_pedestalw1_HF");
1980  HistPed[2][4][2] = (TH1F *)dir->FindObjectAny("h_pedestalw2_HF");
1981  HistPed[2][4][3] = (TH1F *)dir->FindObjectAny("h_pedestalw3_HF");
1982 
1983  for (int test = 31; test <= 32; test++) { //Test: 31-Pedestals, 32-pedestal Widths,
1984  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
1985  // if (sub==1) cHB->Divide(2,1);
1986  if (sub == 1)
1987  cHB->Divide(2, 2);
1988  // if (sub==2) cHE->Divide(3,1);
1989  if (sub == 2)
1990  cHE->Divide(3, 3);
1991  if (sub == 3)
1992  cONE->Divide(1, 1);
1993  // if (sub==4) cHF->Divide(2,1);
1994  if (sub == 4)
1995  cHF->Divide(2, 2);
1996  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
1997  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
1998  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
1999  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depths
2000  if (sub == 1)
2001  cHB->cd(k);
2002  if (sub == 2)
2003  cHE->cd(k);
2004  if (sub == 3)
2005  cONE->cd(k - 3);
2006  if (sub == 4)
2007  cHF->cd(k);
2008  Map_Ampl[test][sub][k]->Divide(Map_Ampl[test][sub][k], Map_SUB[sub][k], 1, 1, "B");
2009  gPad->SetGridy();
2010  gPad->SetGridx();
2011  gPad->SetLogz();
2012  if (sub == 1)
2013  sprintf(str, "HB, Depth%d \b", k);
2014  if (sub == 2)
2015  sprintf(str, "HE, Depth%d \b", k);
2016  if (sub == 3)
2017  sprintf(str, "HO, Depth%d \b", k);
2018  if (sub == 4)
2019  sprintf(str, "HF, Depth%d \b", k);
2020  Map_Ampl[test][sub][k]->SetTitle(str);
2021  Map_Ampl[test][sub][k]->SetXTitle("#eta \b");
2022  Map_Ampl[test][sub][k]->SetYTitle("#phi \b");
2023  Map_Ampl[test][sub][k]->SetZTitle("Rate \b");
2024  if (sub == 3)
2025  Map_Ampl[test][sub][k]->SetTitleOffset(0.8, "Z");
2026  Map_Ampl[test][sub][k]->Draw("COLZ");
2027  Map_Ampl[test][sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2028  Map_Ampl[test][sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2029  if (sub == 1) {
2030  cHB->Modified();
2031  cHB->Update();
2032  }
2033  if (sub == 2) {
2034  cHE->Modified();
2035  cHE->Update();
2036  }
2037  if (sub == 3) {
2038  cONE->Modified();
2039  cONE->Update();
2040  }
2041  if (sub == 4) {
2042  cHF->Modified();
2043  cHF->Update();
2044  }
2045  } //end depth
2046  if (test == 31) {
2047  if (sub == 1) {
2048  cHB->Print("MapRatePedHB.png");
2049  cHB->Clear();
2050  }
2051  if (sub == 2) {
2052  cHE->Print("MapRatePedHE.png");
2053  cHE->Clear();
2054  }
2055  if (sub == 3) {
2056  cONE->Print("MapRatePedHO.png");
2057  cONE->Clear();
2058  }
2059  if (sub == 4) {
2060  cHF->Print("MapRatePedHF.png");
2061  cHF->Clear();
2062  }
2063  }
2064  if (test == 32) {
2065  if (sub == 1) {
2066  cHB->Print("MapRatePedWidthsHB.png");
2067  cHB->Clear();
2068  }
2069  if (sub == 2) {
2070  cHE->Print("MapRatePedWidthsHE.png");
2071  cHE->Clear();
2072  }
2073  if (sub == 3) {
2074  cONE->Print("MapRatePedWidthsHO.png");
2075  cONE->Clear();
2076  }
2077  if (sub == 4) {
2078  cHF->Print("MapRatePedWidthsHF.png");
2079  cHF->Clear();
2080  }
2081  }
2082 
2084 
2085  cPED->Divide(2, 2);
2086  for (int cap = 0; cap <= 3; cap++) {
2087  cPED->cd(cap + 1);
2088  gPad->SetGridy();
2089  gPad->SetGridx();
2090  gPad->SetLogy();
2091 
2092  if (sub == 1)
2093  sprintf(str, "HB, Cap%d, all depth\b", cap);
2094  if (sub == 2)
2095  sprintf(str, "HE, Cap%d, all depth\b", cap);
2096  if (sub == 3)
2097  sprintf(str, "HO, Cap%d, all depth\b", cap);
2098  if (sub == 4)
2099  sprintf(str, "HF, Cap%d, all depth\b", cap);
2100 
2101  HistPed[test - 30][sub][cap]->SetTitle(str);
2102 
2103  if (test == 31)
2104  HistPed[test - 30][sub][cap]->SetXTitle("Pedestals in each event & cell \b");
2105  if (test == 32)
2106  HistPed[test - 30][sub][cap]->SetXTitle("Pedestal Widths in each event & cell \b");
2107 
2108  HistPed[test - 30][sub][cap]->SetYTitle("Number of channel-events \b");
2109  HistPed[test - 30][sub][cap]->SetLineColor(4);
2110  HistPed[test - 30][sub][cap]->SetLineWidth(2);
2111  HistPed[test - 30][sub][cap]->SetTitleOffset(1.4, "Y");
2112  HistPed[test - 30][sub][cap]->Draw("");
2113  // HistPed[test-30][sub][cap]->GetYaxis()->SetRangeUser(1., 100.);
2114  // if (test==31) {gPad->SetLogx(); HistPed[test-30][sub][cap]->GetXaxis()->SetRangeUser(1., 10000.);}
2115  // if (test==32) HistPed[test-30][sub][cap]->GetXaxis()->SetRangeUser(0., 5.);
2116 
2117  cPED->Modified();
2118  cPED->Update();
2119  double min_x[] = {Pedest[test - 31][sub], Pedest[test - 31][sub]};
2120  double min_y[] = {0., 100000000.};
2121  TGraph *MIN = new TGraph(2, min_x, min_y);
2122  MIN->SetLineStyle(2);
2123  MIN->SetLineColor(2);
2124  MIN->SetLineWidth(2 + 100 * 100);
2125  MIN->SetFillStyle(3005);
2126  MIN->SetFillColor(2);
2127  MIN->Draw("L");
2128  }
2129  if (test == 31) {
2130  if (sub == 1) {
2131  cPED->Print("HistPedestalsHB.png");
2132  cPED->Clear();
2133  }
2134  if (sub == 2) {
2135  cPED->Print("HistPedestalsHE.png");
2136  cPED->Clear();
2137  }
2138  if (sub == 3) {
2139  cPED->Print("HistPedestalsHO.png");
2140  cPED->Clear();
2141  }
2142  if (sub == 4) {
2143  cPED->Print("HistPedestalsHF.png");
2144  cPED->Clear();
2145  }
2146  }
2147  if (test == 32) {
2148  if (sub == 1) {
2149  cPED->Print("HistPedestalWidthsHB.png");
2150  cPED->Clear();
2151  }
2152  if (sub == 2) {
2153  cPED->Print("HistPedestalWidthsHE.png");
2154  cPED->Clear();
2155  }
2156  if (sub == 3) {
2157  cPED->Print("HistPedestalWidthsHO.png");
2158  cPED->Clear();
2159  }
2160  if (sub == 4) {
2161  cPED->Print("HistPedestalWidthsHF.png");
2162  cPED->Clear();
2163  }
2164  }
2165  } // end sub
2166  } //end test 31,32
2167 
2168  //+++++++++++++++++++++++++++++++++++
2169  //Test 33 Correlation of Pedestal, pedestalWidths Vs fullAmplitude
2170  //++++++++++++++++++++++++++++++++++++
2171 
2172  cPED->Clear();
2173  Map_Ped[1][1] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HB");
2174  Map_Ped[1][2] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HE");
2175  Map_Ped[1][3] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HO");
2176  Map_Ped[1][4] = (TH2F *)dir->FindObjectAny("h2_pedvsampl_HF");
2177  Map_Ped[2][1] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HB");
2178  Map_Ped[2][2] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HE");
2179  Map_Ped[2][3] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HO");
2180  Map_Ped[2][4] = (TH2F *)dir->FindObjectAny("h2_pedwvsampl_HF");
2181  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2182  cPED->Divide(2, 1);
2183  for (int test = 1; test <= 2; test++) {
2184  cPED->cd(test);
2185  gPad->SetGridy();
2186  gPad->SetGridx();
2187  gPad->SetLogz();
2188  if (test == 1)
2189  Map_Ped[test][sub]->SetXTitle("Pedestal, fC \b");
2190  if (test == 2)
2191  Map_Ped[test][sub]->SetXTitle("pedestal Width, fC \b");
2192  Map_Ped[test][sub]->SetYTitle("Amplitude, fC \b");
2193  Map_Ped[test][sub]->SetZTitle("entries \b");
2194  if (test == 1)
2195  sprintf(str, "Cap0 Pedestal vs Amplitude \b");
2196  if (test == 2)
2197  sprintf(str, "Cap0 pedestalWidth vs Amplitude \b");
2198  Map_Ped[test][sub]->SetTitle(str);
2199  Map_Ped[test][sub]->Draw("COLZ");
2200  // Map_Ped[test][sub]->GetYaxis()->SetRangeUser(0, 72.);
2201  // Map_Ped[test][sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2202  cPED->Modified();
2203  cPED->Update();
2204  } // test 1,2
2205  if (sub == 1) {
2206  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHB.png");
2207  cPED->Clear();
2208  }
2209  if (sub == 2) {
2210  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHE.png");
2211  cPED->Clear();
2212  }
2213  if (sub == 3) {
2214  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHO.png");
2215  cPED->Clear();
2216  }
2217  if (sub == 4) {
2218  cPED->Print("CorrelationsMapPedestalVsfullAmplitudeHF.png");
2219  cPED->Clear();
2220  }
2221  } // end sub
2222 
2223  //+++++++++++++++++++++++++++++++++++
2224  //Test 41 Time Slices shape for good and bad channels
2225  //++++++++++++++++++++++++++++++++++++
2226 
2227  cONE->Clear();
2228  hist_GoodTSshape[1] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HB");
2229  hist_GoodTSshape[2] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HE");
2230  hist_GoodTSshape[3] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HO");
2231  hist_GoodTSshape[4] = (TH1F *)dir->FindObjectAny("h_shape_good_channels_HF");
2232 
2233  hist_GoodTSshape0[1] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HB");
2234  hist_GoodTSshape0[2] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HE");
2235  hist_GoodTSshape0[3] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HO");
2236  hist_GoodTSshape0[4] = (TH1F *)dir->FindObjectAny("h_shape0_good_channels_HF");
2237 
2238  hist_BadTSshape[1] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HB");
2239  hist_BadTSshape[2] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HE");
2240  hist_BadTSshape[3] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HO");
2241  hist_BadTSshape[4] = (TH1F *)dir->FindObjectAny("h_shape_bad_channels_HF");
2242 
2243  hist_BadTSshape0[1] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HB");
2244  hist_BadTSshape0[2] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HE");
2245  hist_BadTSshape0[3] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HO");
2246  hist_BadTSshape0[4] = (TH1F *)dir->FindObjectAny("h_shape0_bad_channels_HF");
2247 
2248  cONE->cd(1);
2249 
2250  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2251 
2252  gPad->SetGridy();
2253  gPad->SetGridx();
2254  gPad->SetLogz();
2255  hist_GoodTSshape[sub]->Divide(hist_GoodTSshape[sub], hist_GoodTSshape0[sub], 1, 1, "B");
2256  hist_GoodTSshape[sub]->SetXTitle("Time slice \b");
2257  hist_GoodTSshape[sub]->SetYTitle("ADC counts \b");
2258  sprintf(str, "Mean ADC Shape \b");
2259  hist_GoodTSshape[sub]->SetTitle(str);
2260  hist_GoodTSshape[sub]->Draw("");
2261  // hist_GoodTSshape[sub]->GetYaxis()->SetRangeUser(0, 72.);
2262  // hist_GoodTSshape[sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2263  cONE->Modified();
2264  cONE->Update();
2265  if (sub == 1) {
2266  cONE->Print("HistGoodTSshapesHB.png");
2267  cONE->Clear();
2268  }
2269  if (sub == 2) {
2270  cONE->Print("HistGoodTSshapesHE.png");
2271  cONE->Clear();
2272  }
2273  if (sub == 3) {
2274  cONE->Print("HistGoodTSshapesHO.png");
2275  cONE->Clear();
2276  }
2277  if (sub == 4) {
2278  cONE->Print("HistGoodTSshapesHF.png");
2279  cONE->Clear();
2280  }
2281  } // end sub
2282 
2283  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2284 
2285  gPad->SetGridy();
2286  gPad->SetGridx();
2287  gPad->SetLogz();
2288  hist_BadTSshape[sub]->Divide(hist_BadTSshape[sub], hist_BadTSshape0[sub], 1, 1, "B");
2289  hist_BadTSshape[sub]->SetXTitle("Time slice \b");
2290  hist_BadTSshape[sub]->SetYTitle("ADC counts \b");
2291  sprintf(str, "Mean ADC Shape \b");
2292  hist_BadTSshape[sub]->SetTitle(str);
2293  hist_BadTSshape[sub]->Draw("");
2294  // hist_BadTSshape[sub]->GetYaxis()->SetRangeUser(0, 72.);
2295  // hist_BadTSshape[sub]->GetZaxis()->SetRangeUser(0.0001, 1.);
2296  cONE->Modified();
2297  cONE->Update();
2298  if (sub == 1) {
2299  cONE->Print("HistBadTSshapesHB.png");
2300  cONE->Clear();
2301  }
2302  if (sub == 2) {
2303  cONE->Print("HistBadTSshapesHE.png");
2304  cONE->Clear();
2305  }
2306  if (sub == 3) {
2307  cONE->Print("HistBadTSshapesHO.png");
2308  cONE->Clear();
2309  }
2310  if (sub == 4) {
2311  cONE->Print("HistBadTSshapesHF.png");
2312  cONE->Clear();
2313  }
2314  } // end sub
2315 
2316  /*
2317  //+++++++++++++++++++++++++++++++++++
2318 //Test 42 ADC in TS distributions
2319 //++++++++++++++++++++++++++++++++++++
2320 
2321 std::cout<<" We are here to print ADC "<<std::endl;
2322 
2323  hist_ADC_All[1] = (TH1F*)dir->FindObjectAny("h_ADC_HB");
2324  hist_ADC_All[2] = (TH1F*)dir->FindObjectAny("h_ADC_HE");
2325  hist_ADC_All[3] = (TH1F*)dir->FindObjectAny("h_ADC_HO");
2326  hist_ADC_All[4] = (TH1F*)dir->FindObjectAny("h_ADC_HF");
2327 
2328 
2329  hist_ADC_DS[1][1] = (TH1F*)dir->FindObjectAny("h_ADC_HBdepth1");
2330  hist_ADC_DS[1][2] = (TH1F*)dir->FindObjectAny("h_ADC_HBdepth2");
2331  hist_ADC_DS[2][1] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth1");
2332  hist_ADC_DS[2][2] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth2");
2333  hist_ADC_DS[2][3] = (TH1F*)dir->FindObjectAny("h_ADC_HEdepth3");
2334  hist_ADC_DS[3][4] = (TH1F*)dir->FindObjectAny("h_ADC_HOdepth4");
2335  hist_ADC_DS[4][1] = (TH1F*)dir->FindObjectAny("h_ADC_HFdepth1");
2336  hist_ADC_DS[4][2] = (TH1F*)dir->FindObjectAny("h_ADC_HFdepth2");
2337 
2338 
2339  cONE->Clear();
2340  cONE->Divide(1,1);
2341  cONE->cd(1);
2342 
2343  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2344  gPad->SetGridy();
2345  gPad->SetGridx();
2346  gPad->SetLogy();
2347  hist_ADC_All[sub]->SetXTitle("ADC counts \b");
2348  hist_ADC_All[sub]->SetYTitle("Number of channels-events \b");
2349  if (sub==1) sprintf(str,"ADC counts Distribution HB\b");
2350  if (sub==2) sprintf(str,"ADC counts Distribution HE\b");
2351  if (sub==3) sprintf(str,"ADC counts Distribution HO\b");
2352  if (sub==4) sprintf(str,"ADC counts Distribution HF\b");
2353  hist_ADC_All[sub]->SetTitle(str);
2354  hist_ADC_All[sub]->Draw("");
2355  // hist_ADC_All[sub]->GetYaxis()->SetRangeUser(0, 72.);
2356  hist_ADC_All[sub]->GetXaxis()->SetRangeUser(0.000, 1000.);
2357  cONE->Modified(); cONE->Update();
2358  if (sub==1) {cONE->Print("Hist_ADC_HB_All.png"); cONE->Clear();}
2359  if (sub==2) {cONE->Print("Hist_ADC_HE_All.png"); cONE->Clear();}
2360  if (sub==3) {cONE->Print("Hist_ADC_HO_All.png"); cONE->Clear();}
2361  if (sub==4) {cONE->Print("Hist_ADC_HF_All.png"); cONE->Clear();}
2362  }// end sub
2363 
2364 
2365  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2366  if (sub==1) cHB->Divide(2,1);
2367  if (sub==2) cHE->Divide(3,1);
2368  if (sub==3) cONE->Divide(1,1);
2369  if (sub==4) cHB->Divide(2,1);
2370  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2371  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2372  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2373  if (sub==1) cHB->cd(k);
2374  if (sub==2) cHE->cd(k);
2375  if (sub==3) cONE->cd(k-3);
2376  if (sub==4) cHB->cd(k);
2377  gPad->SetGridy();
2378  gPad->SetGridx();
2379  gPad->SetLogy();
2380  hist_ADC_DS[sub][k]->SetXTitle("ADC counts \b");
2381  hist_ADC_DS[sub][k]->SetYTitle("Number of channels-events \b");
2382  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2383  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2384  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2385  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2386  hist_ADC_DS[sub][k]->SetTitle(str);
2387  hist_ADC_DS[sub][k]->Draw("");
2388  // hist_ADC_DS[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2389  hist_ADC_DS[sub][k]->GetXaxis()->SetRangeUser(0.000, 1000.);
2390  if (sub==1) {cHB->Modified(); cHB->Update();}
2391  if (sub==2) {cHE->Modified(); cHE->Update();}
2392  if (sub==3) {cONE->Modified();cONE->Update();}
2393  if (sub==4) {cHB->Modified(); cHB->Update();}
2394  }//end depth
2395  if (sub==1) {cHB->Print("Hist_ADC_HB_DS.png"); cHB->Clear();}
2396  if (sub==2) {cHE->Print("Hist_ADC_HE_DS.png"); cHE->Clear();}
2397  if (sub==3) {cONE->Print("Hist_ADC_HO_DS.png"); cONE->Clear();}
2398  if (sub==4) {cHB->Print("Hist_ADC_HF_DS.png"); cHB->Clear();}
2399  }// end sub
2400 
2401 
2402  //+++++++++++++++++++++++++++++++++++
2403 //Test 43 Sum ADC in TS distributions
2404 //++++++++++++++++++++++++++++++++++++
2405 
2406  hist_SumADC[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB");
2407  hist_SumADC[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB");
2408  hist_SumADC[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE");
2409  hist_SumADC[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE");
2410  hist_SumADC[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE");
2411  hist_SumADC[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO");
2412  hist_SumADC[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF");
2413  hist_SumADC[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF");
2414 
2415  hist_SumADC0[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB0");
2416  hist_SumADC0[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB0");
2417  hist_SumADC0[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE0");
2418  hist_SumADC0[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE0");
2419  hist_SumADC0[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE0");
2420  hist_SumADC0[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO0");
2421  hist_SumADC0[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF0");
2422  hist_SumADC0[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF0");
2423 
2424  hist_SumADC1[1][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HB1");
2425  hist_SumADC1[1][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HB1");
2426  hist_SumADC1[2][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HE1");
2427  hist_SumADC1[2][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HE1");
2428  hist_SumADC1[2][3] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth3_HE1");
2429  hist_SumADC1[3][4] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth4_HO1");
2430  hist_SumADC1[4][1] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth1_HF1");
2431  hist_SumADC1[4][2] = (TH1F*)dir->FindObjectAny("h_sumamplitude_depth2_HF1");
2432 
2433  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2434  if (sub==1) cHB->Divide(2,1);
2435  if (sub==2) cHE->Divide(3,1);
2436  if (sub==3) cONE->Divide(1,1);
2437  if (sub==4) cHB->Divide(2,1);
2438  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2439  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2440  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2441  if (sub==1) cHB->cd(k);
2442  if (sub==2) cHE->cd(k);
2443  if (sub==3) cONE->cd(k-3);
2444  if (sub==4) cHB->cd(k);
2445  gPad->SetGridy();
2446  gPad->SetGridx();
2447  gPad->SetLogy();
2448  hist_SumADC[sub][k]->SetXTitle("ADC sum \b");
2449  hist_SumADC[sub][k]->SetYTitle("Number of channels-events \b");
2450  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2451  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2452  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2453  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2454  hist_SumADC[sub][k]->SetTitle(str);
2455  hist_SumADC[sub][k]->Draw("");
2456  // hist_SumADC[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2457  // hist_SumADC[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2458  if (sub==1) {cHB->Modified(); cHB->Update();}
2459  if (sub==2) {cHE->Modified(); cHE->Update();}
2460  if (sub==3) {cONE->Modified();cONE->Update();}
2461  if (sub==4) {cHB->Modified(); cHB->Update();}
2462  }//end depth
2463  if (sub==1) {cHB->Print("Hist_SumADC_HB.png"); cHB->Clear();}
2464  if (sub==2) {cHE->Print("Hist_SumADC_HE.png"); cHE->Clear();}
2465  if (sub==3) {cONE->Print("Hist_SumADC_HO.png"); cONE->Clear();}
2466  if (sub==4) {cHB->Print("Hist_SumADC_HF.png"); cHB->Clear();}
2467  }// end sub
2468 
2469 
2470  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2471  if (sub==1) cHB->Divide(2,1);
2472  if (sub==2) cHE->Divide(3,1);
2473  if (sub==3) cONE->Divide(1,1);
2474  if (sub==4) cHB->Divide(2,1);
2475  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2476  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2477  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2478  if (sub==1) cHB->cd(k);
2479  if (sub==2) cHE->cd(k);
2480  if (sub==3) cONE->cd(k-3);
2481  if (sub==4) cHB->cd(k);
2482  gPad->SetGridy();
2483  gPad->SetGridx();
2484  gPad->SetLogy();
2485  hist_SumADC0[sub][k]->SetXTitle("ADC sum \b");
2486  hist_SumADC0[sub][k]->SetYTitle("Number of channels-events \b");
2487  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2488  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2489  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2490  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2491  hist_SumADC0[sub][k]->SetTitle(str);
2492  hist_SumADC0[sub][k]->Draw("");
2493  // hist_SumADC0[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2494  // hist_SumADC0[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2495  if (sub==1) {cHB->Modified(); cHB->Update();}
2496  if (sub==2) {cHE->Modified(); cHE->Update();}
2497  if (sub==3) {cONE->Modified();cONE->Update();}
2498  if (sub==4) {cHB->Modified(); cHB->Update();}
2499  }//end depth
2500  if (sub==1) {cHB->Print("Hist_SumADC_HB0.png"); cHB->Clear();}
2501  if (sub==2) {cHE->Print("Hist_SumADC_HE0.png"); cHE->Clear();}
2502  if (sub==3) {cONE->Print("Hist_SumADC_HO0.png"); cONE->Clear();}
2503  if (sub==4) {cHB->Print("Hist_SumADC_HF0.png"); cHB->Clear();}
2504  }// end sub
2505 
2506  for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
2507  if (sub==1) cHB->Divide(2,1);
2508  if (sub==2) cHE->Divide(3,1);
2509  if (sub==3) cONE->Divide(1,1);
2510  if (sub==4) cHB->Divide(2,1);
2511  int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
2512  int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
2513  for (int k=k_min[sub];k<=k_max[sub];k++) { //Depths
2514  if (sub==1) cHB->cd(k);
2515  if (sub==2) cHE->cd(k);
2516  if (sub==3) cONE->cd(k-3);
2517  if (sub==4) cHB->cd(k);
2518  gPad->SetGridy();
2519  gPad->SetGridx();
2520  gPad->SetLogy();
2521  hist_SumADC1[sub][k]->SetXTitle("ADC sum \b");
2522  hist_SumADC1[sub][k]->SetYTitle("Number of channels-events \b");
2523  if (sub==1) sprintf(str,"HB, Depth%d \b", k);
2524  if (sub==2) sprintf(str,"HE, Depth%d \b", k);
2525  if (sub==3) sprintf(str,"HO, Depth%d \b", k);
2526  if (sub==4) sprintf(str,"HF, Depth%d \b", k);
2527  hist_SumADC1[sub][k]->SetTitle(str);
2528  hist_SumADC1[sub][k]->Draw("");
2529  // hist_SumADC1[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
2530  // hist_SumADC1[sub][k]->GetZaxis()->SetRangeUser(0.0001, 1.);
2531  if (sub==1) {cHB->Modified(); cHB->Update();}
2532  if (sub==2) {cHE->Modified(); cHE->Update();}
2533  if (sub==3) {cONE->Modified();cONE->Update();}
2534  if (sub==4) {cHB->Modified(); cHB->Update();}
2535  }//end depth
2536  if (sub==1) {cHB->Print("Hist_SumADC_HB1.png"); cHB->Clear();}
2537  if (sub==2) {cHE->Print("Hist_SumADC_HE1.png"); cHE->Clear();}
2538  if (sub==3) {cONE->Print("Hist_SumADC_HO1.png"); cONE->Clear();}
2539  if (sub==4) {cHB->Print("Hist_SumADC_HF1.png"); cHB->Clear();}
2540  }// end sub
2541 
2542 */
2543 
2549 
2550  const int nsub = 4;
2551  const int ndepth = 7;
2552  const int neta = 82;
2553  const int nphi = 72;
2554  int njeta = neta;
2555  int njphi = nphi;
2556  int njdepth = ndepth;
2557  double alexhe[ndepth][njeta][njphi];
2558  double variance[ndepth][njeta][njphi];
2559 
2560  const int jposbeg = 57;
2561  const int jposend = 71;
2562 
2563  const int jnegbeg = 12;
2564  const int jnegend = 26;
2565 
2566  cout << "Iteration Method for Calibration Group nsub= " << nsub << " ndepth = " << ndepth << " neta = " << neta
2567  << " nphi = " << nphi << endl;
2568  cout << "Iteration Method for Calibration Group njdepth = " << njdepth << " njeta = " << njeta
2569  << " njphi = " << njphi << endl;
2570  cout << "Iteration Method for Calibration Group jposbeg = " << jposbeg << " jposend = " << jposend
2571  << " jnegbeg = " << jnegbeg << " jnegend = " << jnegend << endl;
2572 
2573  /*
2574  depth=5 all
2575  i=1-82 in initial histo
2576  j=i-1 in massives
2577 
2578  j= 13 23 (11) 12 25 (!!!)
2579  j-41 in histo
2580  -28 -18 (11) -29 -16
2581 
2582  j= 59 69 (11) 57 70 (!!!)
2583  j-41 in histo
2584  18 28 (11) 16 29
2585  */
2586 
2587  // RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR:
2588 
2589  TH2F *maprphinorm1HE1 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE1");
2590  TH2F *maprphinorm0HE1 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE1");
2591  TH2F *maprphinormHE1 = (TH2F *)maprphinorm1HE1->Clone("maprphinormHE1");
2592  maprphinormHE1->Divide(maprphinorm1HE1, maprphinorm0HE1, 1, 1, "B");
2593  TH2F *maprphinorm1HE2 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE2");
2594  TH2F *maprphinorm0HE2 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE2");
2595  TH2F *maprphinormHE2 = (TH2F *)maprphinorm1HE2->Clone("maprphinormHE2");
2596  maprphinormHE2->Divide(maprphinorm1HE2, maprphinorm0HE2, 1, 1, "B");
2597  TH2F *maprphinorm1HE3 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE3");
2598  TH2F *maprphinorm0HE3 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE3");
2599  TH2F *maprphinormHE3 = (TH2F *)maprphinorm1HE3->Clone("maprphinormHE3");
2600  maprphinormHE3->Divide(maprphinorm1HE3, maprphinorm0HE3, 1, 1, "B");
2601  TH2F *maprphinorm1HE4 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE4");
2602  TH2F *maprphinorm0HE4 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE4");
2603  TH2F *maprphinormHE4 = (TH2F *)maprphinorm1HE4->Clone("maprphinormHE4");
2604  maprphinormHE4->Divide(maprphinorm1HE4, maprphinorm0HE4, 1, 1, "B");
2605  TH2F *maprphinorm1HE5 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE5");
2606  TH2F *maprphinorm0HE5 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE5");
2607  TH2F *maprphinormHE5 = (TH2F *)maprphinorm1HE5->Clone("maprphinormHE5");
2608  maprphinormHE5->Divide(maprphinorm1HE5, maprphinorm0HE5, 1, 1, "B");
2609  TH2F *maprphinorm1HE6 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE6");
2610  TH2F *maprphinorm0HE6 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE6");
2611  TH2F *maprphinormHE6 = (TH2F *)maprphinorm1HE6->Clone("maprphinormHE6");
2612  maprphinormHE6->Divide(maprphinorm1HE6, maprphinorm0HE6, 1, 1, "B");
2613  TH2F *maprphinorm1HE7 = (TH2F *)dir->FindObjectAny("h_maprphinorm_HE7");
2614  TH2F *maprphinorm0HE7 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE7");
2615  TH2F *maprphinormHE7 = (TH2F *)maprphinorm1HE7->Clone("maprphinormHE7");
2616  maprphinormHE7->Divide(maprphinorm1HE7, maprphinorm0HE7, 1, 1, "B");
2617  //=========================== put R into massive alexhe
2618  for (int jeta = 0; jeta < njeta; jeta++) {
2619  for (int jphi = 0; jphi < njphi; jphi++) {
2620  alexhe[0][jeta][jphi] = maprphinormHE1->GetBinContent(jeta + 1, jphi + 1);
2621  alexhe[1][jeta][jphi] = maprphinormHE2->GetBinContent(jeta + 1, jphi + 1);
2622  alexhe[2][jeta][jphi] = maprphinormHE3->GetBinContent(jeta + 1, jphi + 1);
2623  alexhe[3][jeta][jphi] = maprphinormHE4->GetBinContent(jeta + 1, jphi + 1);
2624  alexhe[4][jeta][jphi] = maprphinormHE5->GetBinContent(jeta + 1, jphi + 1);
2625  alexhe[5][jeta][jphi] = maprphinormHE6->GetBinContent(jeta + 1, jphi + 1);
2626  alexhe[6][jeta][jphi] = maprphinormHE7->GetBinContent(jeta + 1, jphi + 1);
2627  }
2628  }
2629 
2630  //------------------------ 2D-eta/phi-plot: R, averaged over depthes
2631  //======================================================================
2632  //======================================================================
2633  cout << " R2D-eta/phi-plot: R, averaged over depthes *****" << endl;
2634  c1x0->Clear();
2636  c1x0->Divide(1, 1);
2637  c1x0->cd(1);
2638  TH2F *Gefz42D = new TH2F("Gefz42D", "", neta, -41., 41., nphi, 0., 72.);
2639  TH2F *Gefz42D0 = new TH2F("Gefz42D0", "", neta, -41., 41., nphi, 0., 72.);
2640  TH2F *Gefz42DF = (TH2F *)Gefz42D0->Clone("Gefz42DF");
2641  for (int i = 0; i < ndepth; i++) {
2642  for (int jeta = 0; jeta < neta; jeta++) {
2643  for (int jphi = 0; jphi < nphi; jphi++) {
2644  double ccc1 = alexhe[i][jeta][jphi];
2645  int k2plot = jeta - 41;
2646  int kkk = k2plot; //if(k2plot >0 ) kkk=k2plot+1; //-41 +41 !=0
2647  if (ccc1 != 0.) {
2648  Gefz42D->Fill(kkk, jphi, ccc1);
2649  Gefz42D0->Fill(kkk, jphi, 1.);
2650  }
2651  }
2652  }
2653  }
2654  Gefz42DF->Divide(Gefz42D, Gefz42D0, 1, 1, "B"); // average A
2655  gPad->SetGridy();
2656  gPad->SetGridx(); // gPad->SetLogz();
2657  Gefz42DF->SetMarkerStyle(20);
2658  Gefz42DF->SetMarkerSize(0.4);
2659  Gefz42DF->GetZaxis()->SetLabelSize(0.08);
2660  Gefz42DF->SetXTitle("<R>_depth #eta \b");
2661  Gefz42DF->SetYTitle(" #phi \b");
2662  Gefz42DF->SetZTitle("<R>_depth \b");
2663  Gefz42DF->SetMarkerColor(2);
2664  Gefz42DF->SetLineColor(0); // Gefz42DF->SetMaximum(1.000); // Gefz42DF->SetMinimum(1.0);
2665  Gefz42DF->Draw("COLZ");
2666 
2668  c1x0->Update();
2669  c1x0->Print("Rhist2IterationMethodHE.png");
2670  c1x0->Clear();
2671  // clean-up
2672  if (Gefz42D)
2673  delete Gefz42D;
2674  if (Gefz42D0)
2675  delete Gefz42D0;
2676  if (Gefz42DF)
2677  delete Gefz42DF;
2678 
2679  //====================================================================== 1D plot: R vs phi , averaged over depthes & eta
2680  //======================================================================
2681  cout << " 1D plot: R vs phi , averaged over depthes & eta *****" << endl;
2682  c1x1->Clear();
2684  c1x1->Divide(1, 1);
2685  c1x1->cd(1);
2686  TH1F *Gefz41D = new TH1F("Gefz41D", "", nphi, 0., 72.);
2687  TH1F *Gefz41D0 = new TH1F("Gefz41D0", "", nphi, 0., 72.);
2688  TH1F *Gefz41DF = (TH1F *)Gefz41D0->Clone("Gefz41DF");
2689 
2690  for (int jeta = 0; jeta < neta; jeta++) {
2691  // positivedirection:
2692  if (jeta - 41 > 0) {
2693  for (int jphi = 0; jphi < nphi; jphi++) {
2694  for (int i = 0; i < ndepth; i++) {
2695  double ccc1 = alexhe[i][jeta][jphi];
2696  if (ccc1 != 0.) {
2697  Gefz41D->Fill(jphi, ccc1);
2698  Gefz41D0->Fill(jphi, 1.);
2699  }
2700  }
2701  }
2702  }
2703  }
2704  // Gefz41D->Sumw2();Gefz41D0->Sumw2();
2705 
2706  Gefz41DF->Divide(Gefz41D, Gefz41D0, 1, 1, "B"); // R averaged over depthes & eta
2707  Gefz41D0->Sumw2();
2708  // for (int jphi=1;jphi<73;jphi++) {Gefz41DF->SetBinError(jphi,0.01);}
2709  gPad->SetGridy();
2710  gPad->SetGridx(); // gPad->SetLogz();
2711  Gefz41DF->SetMarkerStyle(20);
2712  Gefz41DF->SetMarkerSize(1.4);
2713  Gefz41DF->GetZaxis()->SetLabelSize(0.08);
2714  Gefz41DF->SetXTitle("#phi \b");
2715  Gefz41DF->SetYTitle(" <R> \b");
2716  Gefz41DF->SetZTitle("<R>_PHI - AllDepthes \b");
2717  Gefz41DF->SetMarkerColor(4);
2718  Gefz41DF->SetLineColor(4);
2719  Gefz41DF->SetMinimum(0.8); // Gefz41DF->SetMaximum(1.000);
2720  Gefz41DF->Draw("Error");
2721 
2723  c1x1->Update();
2724  c1x1->Print("Rhist1IterationMethodHE.png");
2725  c1x1->Clear();
2726  // clean-up
2727  if (Gefz41D)
2728  delete Gefz41D;
2729  if (Gefz41D0)
2730  delete Gefz41D0;
2731  if (Gefz41DF)
2732  delete Gefz41DF;
2733 
2734  //========================================================================================== 4
2735  //======================================================================
2736  //======================================================================1D plot: R vs phi , different eta, depth=1
2737  cout << " 1D plot: R vs phi , different eta, depth=1 *****" << endl;
2738  c3x5->Clear();
2740  c3x5->Divide(3, 5);
2741  c3x5->cd(1);
2742  int kcountHEpositivedirection1 = 1;
2743  TH1F *h2CeffHEpositivedirection1 = new TH1F("h2CeffHEpositivedirection1", "", nphi, 0., 72.);
2744 
2745  for (int jeta = 0; jeta < njeta; jeta++) {
2746  // positivedirection:
2747  if (jeta - 41 > 0) {
2748  // for (int i=0;i<ndepth;i++) {
2749  // depth=1
2750  for (int i = 0; i < 1; i++) {
2751  TH1F *HEpositivedirection1 = (TH1F *)h2CeffHEpositivedirection1->Clone("twod1");
2752 
2753  float ccctest = 0; // to avoid empty massive elements
2754  for (int jphi = 0; jphi < nphi; jphi++) {
2755  double ccc1 = alexhe[i][jeta][jphi];
2756  if (ccc1 != 0.) {
2757  HEpositivedirection1->Fill(jphi, ccc1);
2758  ccctest = 1.; //HEpositivedirection1->SetBinError(i,0.01);
2759  }
2760  } // for jphi
2761  if (ccctest > 0.) {
2762  cout << "444 kcountHEpositivedirection1 = " << kcountHEpositivedirection1
2763  << " jeta-41= " << jeta - 41 << endl;
2764  c3x5->cd(kcountHEpositivedirection1);
2765  HEpositivedirection1->SetMarkerStyle(20);
2766  HEpositivedirection1->SetMarkerSize(0.4);
2767  HEpositivedirection1->GetYaxis()->SetLabelSize(0.04);
2768  HEpositivedirection1->SetXTitle("HEpositivedirection1 \b");
2769  HEpositivedirection1->SetMarkerColor(2);
2770  HEpositivedirection1->SetLineColor(0);
2771  gPad->SetGridy();
2772  gPad->SetGridx();
2773  // gPad->SetLogy();
2774  if (kcountHEpositivedirection1 == 1)
2775  HEpositivedirection1->SetXTitle("R for HE+ jeta = 18; depth = 1 \b");
2776  if (kcountHEpositivedirection1 == 2)
2777  HEpositivedirection1->SetXTitle("R for HE+ jeta = 19; depth = 1 \b");
2778  if (kcountHEpositivedirection1 == 3)
2779  HEpositivedirection1->SetXTitle("R for HE+ jeta = 20; depth = 1 \b");
2780  if (kcountHEpositivedirection1 == 4)
2781  HEpositivedirection1->SetXTitle("R for HE+ jeta = 21; depth = 1 \b");
2782  if (kcountHEpositivedirection1 == 5)
2783  HEpositivedirection1->SetXTitle("R for HE+ jeta = 22; depth = 1 \b");
2784  if (kcountHEpositivedirection1 == 6)
2785  HEpositivedirection1->SetXTitle("R for HE+ jeta = 23; depth = 1 \b");
2786  if (kcountHEpositivedirection1 == 7)
2787  HEpositivedirection1->SetXTitle("R for HE+ jeta = 24; depth = 1 \b");
2788  if (kcountHEpositivedirection1 == 8)
2789  HEpositivedirection1->SetXTitle("R for HE+ jeta = 25; depth = 1 \b");
2790  if (kcountHEpositivedirection1 == 9)
2791  HEpositivedirection1->SetXTitle("R for HE+ jeta = 26; depth = 1 \b");
2792  if (kcountHEpositivedirection1 == 10)
2793  HEpositivedirection1->SetXTitle("R for HE+ jeta = 27; depth = 1 \b");
2794  if (kcountHEpositivedirection1 == 11)
2795  HEpositivedirection1->SetXTitle("R for HE+ jeta = 28; depth = 1 \b");
2796  if (kcountHEpositivedirection1 == 12)
2797  HEpositivedirection1->SetXTitle("R for HE+ jeta = 29; depth = 1 \b");
2798  HEpositivedirection1->Draw("Error");
2799  kcountHEpositivedirection1++;
2800  if (kcountHEpositivedirection1 > 15)
2801  break; // 4x6 = 24
2802  } //ccctest>0
2803 
2804  } // for i
2805  } //if(jeta-41 > 0)
2806  } //for jeta
2808  c3x5->Update();
2809  c3x5->Print("Rhist1IterationMethodDepth1HE.png");
2810  c3x5->Clear();
2811  // clean-up
2812  if (h2CeffHEpositivedirection1)
2813  delete h2CeffHEpositivedirection1;
2814 
2815  //========================================================================================== 5
2816  //======================================================================
2817  //======================================================================1D plot: R vs phi , different eta, depth=2
2818  cout << " 1D plot: R vs phi , different eta, depth=2 *****" << endl;
2819  c3x5->Clear();
2821  c3x5->Divide(3, 5);
2822  c3x5->cd(1);
2823  int kcountHEpositivedirection2 = 1;
2824  TH1F *h2CeffHEpositivedirection2 = new TH1F("h2CeffHEpositivedirection2", "", nphi, 0., 72.);
2825 
2826  for (int jeta = 0; jeta < njeta; jeta++) {
2827  // positivedirection:
2828  if (jeta - 41 > 0) {
2829  // for (int i=0;i<ndepth;i++) {
2830  // depth=2
2831  for (int i = 1; i < 2; i++) {
2832  TH1F *HEpositivedirection2 = (TH1F *)h2CeffHEpositivedirection2->Clone("twod1");
2833 
2834  float ccctest = 0; // to avoid empty massive elements
2835  for (int jphi = 0; jphi < nphi; jphi++) {
2836  double ccc1 = alexhe[i][jeta][jphi];
2837  if (ccc1 != 0.) {
2838  HEpositivedirection2->Fill(jphi, ccc1);
2839  ccctest = 1.; //HEpositivedirection2->SetBinError(i,0.01);
2840  }
2841  } // for jphi
2842  if (ccctest > 0.) {
2843  cout << "555 kcountHEpositivedirection2 = " << kcountHEpositivedirection2
2844  << " jeta-41= " << jeta - 41 << endl;
2845  c3x5->cd(kcountHEpositivedirection2);
2846  HEpositivedirection2->SetMarkerStyle(20);
2847  HEpositivedirection2->SetMarkerSize(0.4);
2848  HEpositivedirection2->GetYaxis()->SetLabelSize(0.04);
2849  HEpositivedirection2->SetXTitle("HEpositivedirection2 \b");
2850  HEpositivedirection2->SetMarkerColor(2);
2851  HEpositivedirection2->SetLineColor(0);
2852  gPad->SetGridy();
2853  gPad->SetGridx();
2854  // gPad->SetLogy();
2855  if (kcountHEpositivedirection2 == 1)
2856  HEpositivedirection2->SetXTitle("R for HE+ jeta = 17; depth = 2 \b");
2857  if (kcountHEpositivedirection2 == 2)
2858  HEpositivedirection2->SetXTitle("R for HE+ jeta = 18; depth = 2 \b");
2859  if (kcountHEpositivedirection2 == 3)
2860  HEpositivedirection2->SetXTitle("R for HE+ jeta = 19; depth = 2 \b");
2861  if (kcountHEpositivedirection2 == 4)
2862  HEpositivedirection2->SetXTitle("R for HE+ jeta = 20; depth = 2 \b");
2863  if (kcountHEpositivedirection2 == 5)
2864  HEpositivedirection2->SetXTitle("R for HE+ jeta = 21; depth = 2 \b");
2865  if (kcountHEpositivedirection2 == 6)
2866  HEpositivedirection2->SetXTitle("R for HE+ jeta = 22; depth = 2 \b");
2867  if (kcountHEpositivedirection2 == 7)
2868  HEpositivedirection2->SetXTitle("R for HE+ jeta = 23; depth = 2 \b");
2869  if (kcountHEpositivedirection2 == 8)
2870  HEpositivedirection2->SetXTitle("R for HE+ jeta = 24; depth = 2 \b");
2871  if (kcountHEpositivedirection2 == 9)
2872  HEpositivedirection2->SetXTitle("R for HE+ jeta = 25; depth = 2 \b");
2873  if (kcountHEpositivedirection2 == 10)
2874  HEpositivedirection2->SetXTitle("R for HE+ jeta = 26; depth = 2 \b");
2875  if (kcountHEpositivedirection2 == 11)
2876  HEpositivedirection2->SetXTitle("R for HE+ jeta = 27; depth = 2 \b");
2877  if (kcountHEpositivedirection2 == 12)
2878  HEpositivedirection2->SetXTitle("R for HE+ jeta = 28; depth = 2 \b");
2879  if (kcountHEpositivedirection2 == 13)
2880  HEpositivedirection2->SetXTitle("R for HE+ jeta = 29; depth = 2 \b");
2881  HEpositivedirection2->Draw("Error");
2882  kcountHEpositivedirection2++;
2883  if (kcountHEpositivedirection2 > 15)
2884  break; // 4x6 = 24
2885  } //ccctest>0
2886 
2887  } // for i
2888  } //if(jeta-41 > 0)
2889  } //for jeta
2891  c3x5->Update();
2892  c3x5->Print("Rhist1IterationMethodDepth2HE.png");
2893  c3x5->Clear();
2894  // clean-up
2895  if (h2CeffHEpositivedirection2)
2896  delete h2CeffHEpositivedirection2;
2897  //========================================================================================== 6
2898  //======================================================================
2899  //======================================================================1D plot: R vs phi , different eta, depth=3
2900  cout << " 1D plot: R vs phi , different eta, depth=3 *****" << endl;
2901  c3x5->Clear();
2903  c3x5->Divide(3, 5);
2904  c3x5->cd(1);
2905  int kcountHEpositivedirection3 = 1;
2906  TH1F *h2CeffHEpositivedirection3 = new TH1F("h2CeffHEpositivedirection3", "", nphi, 0., 72.);
2907 
2908  for (int jeta = 0; jeta < njeta; jeta++) {
2909  // positivedirection:
2910  if (jeta - 41 > 0) {
2911  // for (int i=0;i<ndepth;i++) {
2912  // depth=3
2913  for (int i = 2; i < 3; i++) {
2914  TH1F *HEpositivedirection3 = (TH1F *)h2CeffHEpositivedirection3->Clone("twod1");
2915 
2916  float ccctest = 0; // to avoid empty massive elements
2917  for (int jphi = 0; jphi < nphi; jphi++) {
2918  double ccc1 = alexhe[i][jeta][jphi];
2919  if (ccc1 != 0.) {
2920  HEpositivedirection3->Fill(jphi, ccc1);
2921  ccctest = 1.; //HEpositivedirection3->SetBinError(i,0.01);
2922  }
2923  } // for jphi
2924  if (ccctest > 0.) {
2925  cout << "666 kcountHEpositivedirection3 = " << kcountHEpositivedirection3
2926  << " jeta-41= " << jeta - 41 << endl;
2927  c3x5->cd(kcountHEpositivedirection3);
2928  HEpositivedirection3->SetMarkerStyle(20);
2929  HEpositivedirection3->SetMarkerSize(0.4);
2930  HEpositivedirection3->GetYaxis()->SetLabelSize(0.04);
2931  HEpositivedirection3->SetXTitle("HEpositivedirection3 \b");
2932  HEpositivedirection3->SetMarkerColor(2);
2933  HEpositivedirection3->SetLineColor(0);
2934  gPad->SetGridy();
2935  gPad->SetGridx();
2936  // gPad->SetLogy();
2937  if (kcountHEpositivedirection3 == 1)
2938  HEpositivedirection3->SetXTitle("R for HE+ jeta = 17; depth = 3 \b");
2939  if (kcountHEpositivedirection3 == 2)
2940  HEpositivedirection3->SetXTitle("R for HE+ jeta = 18; depth = 3 \b");
2941  if (kcountHEpositivedirection3 == 3)
2942  HEpositivedirection3->SetXTitle("R for HE+ jeta = 19; depth = 3 \b");
2943  if (kcountHEpositivedirection3 == 4)
2944  HEpositivedirection3->SetXTitle("R for HE+ jeta = 20; depth = 3 \b");
2945  if (kcountHEpositivedirection3 == 5)
2946  HEpositivedirection3->SetXTitle("R for HE+ jeta = 21; depth = 3 \b");
2947  if (kcountHEpositivedirection3 == 6)
2948  HEpositivedirection3->SetXTitle("R for HE+ jeta = 22; depth = 3 \b");
2949  if (kcountHEpositivedirection3 == 7)
2950  HEpositivedirection3->SetXTitle("R for HE+ jeta = 23; depth = 3 \b");
2951  if (kcountHEpositivedirection3 == 8)
2952  HEpositivedirection3->SetXTitle("R for HE+ jeta = 24; depth = 3 \b");
2953  if (kcountHEpositivedirection3 == 9)
2954  HEpositivedirection3->SetXTitle("R for HE+ jeta = 25; depth = 3 \b");
2955  if (kcountHEpositivedirection3 == 10)
2956  HEpositivedirection3->SetXTitle("R for HE+ jeta = 26; depth = 3 \b");
2957  if (kcountHEpositivedirection3 == 11)
2958  HEpositivedirection3->SetXTitle("R for HE+ jeta = 27; depth = 3 \b");
2959  if (kcountHEpositivedirection3 == 12)
2960  HEpositivedirection3->SetXTitle("R for HE+ jeta = 28; depth = 3 \b");
2961  if (kcountHEpositivedirection3 == 13)
2962  HEpositivedirection3->SetXTitle("R for HE+ jeta = 29; depth = 3 \b");
2963  HEpositivedirection3->Draw("Error");
2964  kcountHEpositivedirection3++;
2965  if (kcountHEpositivedirection3 > 15)
2966  break; // 4x6 = 24
2967  } //ccctest>0
2968 
2969  } // for i
2970  } //if(jeta-41 > 0)
2971  } //for jeta
2973  c3x5->Update();
2974  c3x5->Print("Rhist1IterationMethodDepth3HE.png");
2975  c3x5->Clear();
2976  // clean-up
2977  if (h2CeffHEpositivedirection3)
2978  delete h2CeffHEpositivedirection3;
2979  //========================================================================================== 7
2980  //======================================================================
2981  //======================================================================1D plot: R vs phi , different eta, depth=4
2982  cout << " 1D plot: R vs phi , different eta, depth=4 *****" << endl;
2983  c3x5->Clear();
2985  c3x5->Divide(3, 5);
2986  c3x5->cd(1);
2987  int kcountHEpositivedirection4 = 1;
2988  TH1F *h2CeffHEpositivedirection4 = new TH1F("h2CeffHEpositivedirection4", "", nphi, 0., 72.);
2989 
2990  for (int jeta = 0; jeta < njeta; jeta++) {
2991  // positivedirection:
2992  if (jeta - 41 > 0) {
2993  // for (int i=0;i<ndepth;i++) {
2994  // depth=4
2995  for (int i = 3; i < 4; i++) {
2996  TH1F *HEpositivedirection4 = (TH1F *)h2CeffHEpositivedirection4->Clone("twod1");
2997 
2998  float ccctest = 0; // to avoid empty massive elements
2999  for (int jphi = 0; jphi < nphi; jphi++) {
3000  double ccc1 = alexhe[i][jeta][jphi];
3001  if (ccc1 != 0.) {
3002  HEpositivedirection4->Fill(jphi, ccc1);
3003  ccctest = 1.; //HEpositivedirection4->SetBinError(i,0.01);
3004  }
3005  } // for jphi
3006  if (ccctest > 0.) {
3007  cout << "777 kcountHEpositivedirection4 = " << kcountHEpositivedirection4
3008  << " jeta-41= " << jeta - 41 << endl;
3009  c3x5->cd(kcountHEpositivedirection4);
3010  HEpositivedirection4->SetMarkerStyle(20);
3011  HEpositivedirection4->SetMarkerSize(0.4);
3012  HEpositivedirection4->GetYaxis()->SetLabelSize(0.04);
3013  HEpositivedirection4->SetXTitle("HEpositivedirection4 \b");
3014  HEpositivedirection4->SetMarkerColor(2);
3015  HEpositivedirection4->SetLineColor(0);
3016  gPad->SetGridy();
3017  gPad->SetGridx();
3018  // gPad->SetLogy();
3019  if (kcountHEpositivedirection4 == 1)
3020  HEpositivedirection4->SetXTitle("R for HE+ jeta = 16; depth = 4 \b");
3021  if (kcountHEpositivedirection4 == 2)
3022  HEpositivedirection4->SetXTitle("R for HE+ jeta = 18; depth = 4 \b");
3023  if (kcountHEpositivedirection4 == 3)
3024  HEpositivedirection4->SetXTitle("R for HE+ jeta = 19; depth = 4 \b");
3025  if (kcountHEpositivedirection4 == 4)
3026  HEpositivedirection4->SetXTitle("R for HE+ jeta = 20; depth = 4 \b");
3027  if (kcountHEpositivedirection4 == 5)
3028  HEpositivedirection4->SetXTitle("R for HE+ jeta = 21; depth = 4 \b");
3029  if (kcountHEpositivedirection4 == 6)
3030  HEpositivedirection4->SetXTitle("R for HE+ jeta = 22; depth = 4 \b");
3031  if (kcountHEpositivedirection4 == 7)
3032  HEpositivedirection4->SetXTitle("R for HE+ jeta = 23; depth = 4 \b");
3033  if (kcountHEpositivedirection4 == 8)
3034  HEpositivedirection4->SetXTitle("R for HE+ jeta = 24; depth = 4 \b");
3035  if (kcountHEpositivedirection4 == 9)
3036  HEpositivedirection4->SetXTitle("R for HE+ jeta = 25; depth = 4 \b");
3037  if (kcountHEpositivedirection4 == 10)
3038  HEpositivedirection4->SetXTitle("R for HE+ jeta = 26; depth = 4 \b");
3039  if (kcountHEpositivedirection4 == 11)
3040  HEpositivedirection4->SetXTitle("R for HE+ jeta = 27; depth = 4 \b");
3041  if (kcountHEpositivedirection4 == 12)
3042  HEpositivedirection4->SetXTitle("R for HE+ jeta = 28; depth = 4 \b");
3043  HEpositivedirection4->Draw("Error");
3044  kcountHEpositivedirection4++;
3045  if (kcountHEpositivedirection4 > 15)
3046  break; // 4x6 = 24
3047  } //ccctest>0
3048 
3049  } // for i
3050  } //if(jeta-41 > 0)
3051  } //for jeta
3053  c3x5->Update();
3054  c3x5->Print("Rhist1IterationMethodDepth4HE.png");
3055  c3x5->Clear();
3056  // clean-up
3057  if (h2CeffHEpositivedirection4)
3058  delete h2CeffHEpositivedirection4;
3059  //========================================================================================== 8
3060  //======================================================================
3061  //======================================================================1D plot: R vs phi , different eta, depth=5
3062  cout << " 1D plot: R vs phi , different eta, depth=5 *****" << endl;
3063  c3x5->Clear();
3065  c3x5->Divide(3, 5);
3066  c3x5->cd(1);
3067  int kcountHEpositivedirection5 = 1;
3068  TH1F *h2CeffHEpositivedirection5 = new TH1F("h2CeffHEpositivedirection5", "", nphi, 0., 72.);
3069 
3070  for (int jeta = 0; jeta < njeta; jeta++) {
3071  // positivedirection:
3072  if (jeta - 41 > 0) {
3073  // for (int i=0;i<ndepth;i++) {
3074  // depth=5
3075  for (int i = 4; i < 5; i++) {
3076  TH1F *HEpositivedirection5 = (TH1F *)h2CeffHEpositivedirection5->Clone("twod1");
3077 
3078  float ccctest = 0; // to avoid empty massive elements
3079  for (int jphi = 0; jphi < nphi; jphi++) {
3080  // cout<<"888 initial kcountHEpositivedirection5 = "<<kcountHEpositivedirection5 <<" jeta-41= "<< jeta-41 <<" jphi= "<< jphi <<" alexhe[i][jeta][jphi]= "<< alexhe[i][jeta][jphi] <<" depth= "<< i <<endl;
3081 
3082  double ccc1 = alexhe[i][jeta][jphi];
3083  if (ccc1 != 0.) {
3084  HEpositivedirection5->Fill(jphi, ccc1);
3085  ccctest = 1.; //HEpositivedirection5->SetBinError(i,0.01);
3086  }
3087  } // for jphi
3088  if (ccctest > 0.) {
3089  cout << "888 kcountHEpositivedirection5 = " << kcountHEpositivedirection5
3090  << " jeta-41= " << jeta - 41 << endl;
3091  c3x5->cd(kcountHEpositivedirection5);
3092  HEpositivedirection5->SetMarkerStyle(20);
3093  HEpositivedirection5->SetMarkerSize(0.4);
3094  HEpositivedirection5->GetYaxis()->SetLabelSize(0.04);
3095  HEpositivedirection5->SetXTitle("HEpositivedirection5 \b");
3096  HEpositivedirection5->SetMarkerColor(2);
3097  HEpositivedirection5->SetLineColor(0);
3098  gPad->SetGridy();
3099  gPad->SetGridx();
3100  // gPad->SetLogy();
3101  if (kcountHEpositivedirection5 == 1)
3102  HEpositivedirection5->SetXTitle("R for HE+ jeta = 18; depth = 5 \b");
3103  if (kcountHEpositivedirection5 == 2)
3104  HEpositivedirection5->SetXTitle("R for HE+ jeta = 19; depth = 5 \b");
3105  if (kcountHEpositivedirection5 == 3)
3106  HEpositivedirection5->SetXTitle("R for HE+ jeta = 20; depth = 5 \b");
3107  if (kcountHEpositivedirection5 == 4)
3108  HEpositivedirection5->SetXTitle("R for HE+ jeta = 21; depth = 5 \b");
3109  if (kcountHEpositivedirection5 == 5)
3110  HEpositivedirection5->SetXTitle("R for HE+ jeta = 22; depth = 5 \b");
3111  if (kcountHEpositivedirection5 == 6)
3112  HEpositivedirection5->SetXTitle("R for HE+ jeta = 23; depth = 5 \b");
3113  if (kcountHEpositivedirection5 == 7)
3114  HEpositivedirection5->SetXTitle("R for HE+ jeta = 24; depth = 5 \b");
3115  if (kcountHEpositivedirection5 == 8)
3116  HEpositivedirection5->SetXTitle("R for HE+ jeta = 25; depth = 5 \b");
3117  if (kcountHEpositivedirection5 == 9)
3118  HEpositivedirection5->SetXTitle("R for HE+ jeta = 26; depth = 5 \b");
3119  if (kcountHEpositivedirection5 == 10)
3120  HEpositivedirection5->SetXTitle("R for HE+ jeta = 27; depth = 5 \b");
3121  if (kcountHEpositivedirection5 == 11)
3122  HEpositivedirection5->SetXTitle("R for HE+ jeta = 28; depth = 5 \b");
3123  HEpositivedirection5->Draw("Error");
3124  kcountHEpositivedirection5++;
3125  if (kcountHEpositivedirection5 > 15)
3126  break; // 4x6 = 24
3127  } //ccctest>0
3128 
3129  } // for i
3130  } //if(jeta-41 > 0)
3131  } //for jeta
3133  c3x5->Update();
3134  c3x5->Print("Rhist1IterationMethodDepth5HE.png");
3135  c3x5->Clear();
3136  // clean-up
3137  if (h2CeffHEpositivedirection5)
3138  delete h2CeffHEpositivedirection5;
3139  //========================================================================================== 9
3140  //======================================================================
3141  //======================================================================1D plot: R vs phi , different eta, depth=6
3142  cout << " 1D plot: R vs phi , different eta, depth=6 *****" << endl;
3143  c3x5->Clear();
3145  c3x5->Divide(3, 5);
3146  c3x5->cd(1);
3147  int kcountHEpositivedirection6 = 1;
3148  TH1F *h2CeffHEpositivedirection6 = new TH1F("h2CeffHEpositivedirection6", "", nphi, 0., 72.);
3149 
3150  for (int jeta = 0; jeta < njeta; jeta++) {
3151  // positivedirection:
3152  if (jeta - 41 > 0) {
3153  // for (int i=0;i<ndepth;i++) {
3154  // depth=6
3155  for (int i = 5; i < 6; i++) {
3156  TH1F *HEpositivedirection6 = (TH1F *)h2CeffHEpositivedirection6->Clone("twod1");
3157 
3158  float ccctest = 0; // to avoid empty massive elements
3159  for (int jphi = 0; jphi < nphi; jphi++) {
3160  double ccc1 = alexhe[i][jeta][jphi];
3161  if (ccc1 != 0.) {
3162  HEpositivedirection6->Fill(jphi, ccc1);
3163  ccctest = 1.; //HEpositivedirection6->SetBinError(i,0.01);
3164  }
3165  } // for jphi
3166  if (ccctest > 0.) {
3167  cout << "999 kcountHEpositivedirection6 = " << kcountHEpositivedirection6
3168  << " jeta-41= " << jeta - 41 << endl;
3169  c3x5->cd(kcountHEpositivedirection6);
3170  HEpositivedirection6->SetMarkerStyle(20);
3171  HEpositivedirection6->SetMarkerSize(0.4);
3172  HEpositivedirection6->GetYaxis()->SetLabelSize(0.04);
3173  HEpositivedirection6->SetXTitle("HEpositivedirection6 \b");
3174  HEpositivedirection6->SetMarkerColor(2);
3175  HEpositivedirection6->SetLineColor(0);
3176  gPad->SetGridy();
3177  gPad->SetGridx();
3178  // gPad->SetLogy();
3179  if (kcountHEpositivedirection6 == 1)
3180  HEpositivedirection6->SetXTitle("R for HE+ jeta = 19; depth = 6 \b");
3181  if (kcountHEpositivedirection6 == 2)
3182  HEpositivedirection6->SetXTitle("R for HE+ jeta = 20; depth = 6 \b");
3183  if (kcountHEpositivedirection6 == 3)
3184  HEpositivedirection6->SetXTitle("R for HE+ jeta = 21; depth = 6 \b");
3185  if (kcountHEpositivedirection6 == 4)
3186  HEpositivedirection6->SetXTitle("R for HE+ jeta = 22; depth = 6 \b");
3187  if (kcountHEpositivedirection6 == 5)
3188  HEpositivedirection6->SetXTitle("R for HE+ jeta = 23; depth = 6 \b");
3189  if (kcountHEpositivedirection6 == 6)
3190  HEpositivedirection6->SetXTitle("R for HE+ jeta = 24; depth = 6 \b");
3191  if (kcountHEpositivedirection6 == 7)
3192  HEpositivedirection6->SetXTitle("R for HE+ jeta = 25; depth = 6 \b");
3193  if (kcountHEpositivedirection6 == 8)
3194  HEpositivedirection6->SetXTitle("R for HE+ jeta = 26; depth = 6 \b");
3195  if (kcountHEpositivedirection6 == 9)
3196  HEpositivedirection6->SetXTitle("R for HE+ jeta = 27; depth = 6 \b");
3197  if (kcountHEpositivedirection6 == 10)
3198  HEpositivedirection6->SetXTitle("R for HE+ jeta = 28; depth = 6 \b");
3199  HEpositivedirection6->Draw("Error");
3200  kcountHEpositivedirection6++;
3201  if (kcountHEpositivedirection6 > 15)
3202  break; // 4x6 = 24
3203  } //ccctest>0
3204 
3205  } // for i
3206  } //if(jeta-41 > 0)
3207  } //for jeta
3209  c3x5->Update();
3210  c3x5->Print("Rhist1IterationMethodDepth6HE.png");
3211  c3x5->Clear();
3212  // clean-up
3213  if (h2CeffHEpositivedirection6)
3214  delete h2CeffHEpositivedirection6;
3215  //========================================================================================== 10
3216  //======================================================================
3217  //======================================================================1D plot: R vs phi , different eta, depth=7
3218  cout << " 1D plot: R vs phi , different eta, depth=7 *****" << endl;
3219  c3x5->Clear();
3221  c3x5->Divide(3, 5);
3222  c3x5->cd(1);
3223  int kcountHEpositivedirection7 = 1;
3224  TH1F *h2CeffHEpositivedirection7 = new TH1F("h2CeffHEpositivedirection7", "", nphi, 0., 72.);
3225 
3226  for (int jeta = 0; jeta < njeta; jeta++) {
3227  // positivedirection:
3228  if (jeta - 41 > 0) {
3229  // for (int i=0;i<ndepth;i++) {
3230  // depth=7
3231  for (int i = 6; i < 7; i++) {
3232  TH1F *HEpositivedirection7 = (TH1F *)h2CeffHEpositivedirection7->Clone("twod1");
3233 
3234  float ccctest = 0; // to avoid empty massive elements
3235  for (int jphi = 0; jphi < nphi; jphi++) {
3236  double ccc1 = alexhe[i][jeta][jphi];
3237  if (ccc1 != 0.) {
3238  HEpositivedirection7->Fill(jphi, ccc1);
3239  ccctest = 1.; //HEpositivedirection7->SetBinError(i,0.01);
3240  }
3241  } // for jphi
3242  if (ccctest > 0.) {
3243  cout << "1010 kcountHEpositivedirection7 = " << kcountHEpositivedirection7
3244  << " jeta-41= " << jeta - 41 << endl;
3245  c3x5->cd(kcountHEpositivedirection7);
3246  HEpositivedirection7->SetMarkerStyle(20);
3247  HEpositivedirection7->SetMarkerSize(0.4);
3248  HEpositivedirection7->GetYaxis()->SetLabelSize(0.04);
3249  HEpositivedirection7->SetXTitle("HEpositivedirection7 \b");
3250  HEpositivedirection7->SetMarkerColor(2);
3251  HEpositivedirection7->SetLineColor(0);
3252  gPad->SetGridy();
3253  gPad->SetGridx();
3254  // gPad->SetLogy();
3255  if (kcountHEpositivedirection7 == 1)
3256  HEpositivedirection7->SetXTitle("R for HE+ jeta = 26; depth = 7 \b");
3257  if (kcountHEpositivedirection7 == 2)
3258  HEpositivedirection7->SetXTitle("R for HE+ jeta = 27; depth = 7 \b");
3259  if (kcountHEpositivedirection7 == 3)
3260  HEpositivedirection7->SetXTitle("R for HE+ jeta = 28; depth = 7 \b");
3261  HEpositivedirection7->Draw("Error");
3262  kcountHEpositivedirection7++;
3263  if (kcountHEpositivedirection7 > 15)
3264  break; // 4x6 = 24
3265  } //ccctest>0
3266 
3267  } // for i
3268  } //if(jeta-41 > 0)
3269  } //for jeta
3271  c3x5->Update();
3272  c3x5->Print("Rhist1IterationMethodDepth7HE.png");
3273  c3x5->Clear();
3274  // clean-up
3275  if (h2CeffHEpositivedirection7)
3276  delete h2CeffHEpositivedirection7;
3277 
3278  // DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD:
3279 
3280  cout << " Start Vaiance: preparation *****" << endl;
3281  TH2F *mapdphinorm1HE1 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE1");
3282  TH2F *mapdphinorm0HE1 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE1");
3283  TH2F *mapdphinormHE1 = (TH2F *)mapdphinorm1HE1->Clone("mapdphinormHE1");
3284  mapdphinormHE1->Divide(mapdphinorm1HE1, mapdphinorm0HE1, 1, 1, "B");
3285  TH2F *mapdphinorm1HE2 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE2");
3286  TH2F *mapdphinorm0HE2 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE2");
3287  TH2F *mapdphinormHE2 = (TH2F *)mapdphinorm1HE2->Clone("mapdphinormHE2");
3288  mapdphinormHE2->Divide(mapdphinorm1HE2, mapdphinorm0HE2, 1, 1, "B");
3289  TH2F *mapdphinorm1HE3 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE3");
3290  TH2F *mapdphinorm0HE3 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE3");
3291  TH2F *mapdphinormHE3 = (TH2F *)mapdphinorm1HE3->Clone("mapdphinormHE3");
3292  mapdphinormHE3->Divide(mapdphinorm1HE3, mapdphinorm0HE3, 1, 1, "B");
3293  TH2F *mapdphinorm1HE4 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE4");
3294  TH2F *mapdphinorm0HE4 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE4");
3295  TH2F *mapdphinormHE4 = (TH2F *)mapdphinorm1HE4->Clone("mapdphinormHE4");
3296  mapdphinormHE4->Divide(mapdphinorm1HE4, mapdphinorm0HE4, 1, 1, "B");
3297  TH2F *mapdphinorm1HE5 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE5");
3298  TH2F *mapdphinorm0HE5 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE5");
3299  TH2F *mapdphinormHE5 = (TH2F *)mapdphinorm1HE5->Clone("mapdphinormHE5");
3300  mapdphinormHE5->Divide(mapdphinorm1HE5, mapdphinorm0HE5, 1, 1, "B");
3301  TH2F *mapdphinorm1HE6 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE6");
3302  TH2F *mapdphinorm0HE6 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE6");
3303  TH2F *mapdphinormHE6 = (TH2F *)mapdphinorm1HE6->Clone("mapdphinormHE6");
3304  mapdphinormHE6->Divide(mapdphinorm1HE6, mapdphinorm0HE6, 1, 1, "B");
3305  TH2F *mapdphinorm1HE7 = (TH2F *)dir->FindObjectAny("h_maprphinorm2_HE7");
3306  TH2F *mapdphinorm0HE7 = (TH2F *)dir->FindObjectAny("h_maprphinorm0_HE7");
3307  TH2F *mapdphinormHE7 = (TH2F *)mapdphinorm1HE7->Clone("mapdphinormHE7");
3308  mapdphinormHE7->Divide(mapdphinorm1HE7, mapdphinorm0HE7, 1, 1, "B");
3309  cout << " Vaiance: preparation DONE *****" << endl;
3310  //====================================================================== put Vaiance=Dispersia = Sig**2=<R**2> - (<R>)**2
3311  // = sum(R*R)/N - (sum(R)/N)**2
3312  // = mapdphinormHE1,2,3..7 - alexhe*alexhe
3313  for (int jeta = 0; jeta < njeta; jeta++) {
3314  for (int jphi = 0; jphi < njphi; jphi++) {
3315  variance[0][jeta][jphi] =
3316  fabs(mapdphinormHE1->GetBinContent(jeta + 1, jphi + 1) - alexhe[0][jeta][jphi] * alexhe[0][jeta][jphi]);
3317  if (variance[0][jeta][jphi] < 0.00003)
3318  variance[0][jeta][jphi] = 0.000067;
3319  variance[1][jeta][jphi] =
3320  fabs(mapdphinormHE2->GetBinContent(jeta + 1, jphi + 1) - alexhe[1][jeta][jphi] * alexhe[1][jeta][jphi]);
3321  if (variance[1][jeta][jphi] < 0.00003)
3322  variance[1][jeta][jphi] = 0.000067;
3323  variance[2][jeta][jphi] =
3324  fabs(mapdphinormHE3->GetBinContent(jeta + 1, jphi + 1) - alexhe[2][jeta][jphi] * alexhe[2][jeta][jphi]);
3325  if (variance[2][jeta][jphi] < 0.00003)
3326  variance[2][jeta][jphi] = 0.000067;
3327  variance[3][jeta][jphi] =
3328  fabs(mapdphinormHE4->GetBinContent(jeta + 1, jphi + 1) - alexhe[3][jeta][jphi] * alexhe[3][jeta][jphi]);
3329  if (variance[3][jeta][jphi] < 0.00003)
3330  variance[3][jeta][jphi] = 0.000067;
3331  variance[4][jeta][jphi] =
3332  fabs(mapdphinormHE5->GetBinContent(jeta + 1, jphi + 1) - alexhe[4][jeta][jphi] * alexhe[4][jeta][jphi]);
3333  if (variance[4][jeta][jphi] < 0.00003)
3334  variance[4][jeta][jphi] = 0.000067;
3335  variance[5][jeta][jphi] =
3336  fabs(mapdphinormHE6->GetBinContent(jeta + 1, jphi + 1) - alexhe[5][jeta][jphi] * alexhe[5][jeta][jphi]);
3337  if (variance[5][jeta][jphi] < 0.00003)
3338  variance[5][jeta][jphi] = 0.000067;
3339  variance[6][jeta][jphi] =
3340  fabs(mapdphinormHE7->GetBinContent(jeta + 1, jphi + 1) - alexhe[6][jeta][jphi] * alexhe[6][jeta][jphi]);
3341  if (variance[6][jeta][jphi] < 0.00003)
3342  variance[6][jeta][jphi] = 0.000067;
3343  }
3344  }
3345  cout << " Vaiance: DONE*****" << endl;
3346 
3347  //------------------------ 2D-eta/phi-plot: D, averaged over depthes
3348  //======================================================================
3349  //======================================================================
3350  cout << " R2D-eta/phi-plot: D, averaged over depthes *****" << endl;
3351  c1x1->Clear();
3353  c1x0->Divide(1, 1);
3354  c1x0->cd(1);
3355  TH2F *Defz42D = new TH2F("Defz42D", "", neta, -41., 41., nphi, 0., 72.);
3356  TH2F *Defz42D0 = new TH2F("Defz42D0", "", neta, -41., 41., nphi, 0., 72.);
3357  TH2F *Defz42DF = (TH2F *)Defz42D0->Clone("Defz42DF");
3358  for (int i = 0; i < ndepth; i++) {
3359  for (int jeta = 0; jeta < neta; jeta++) {
3360  for (int jphi = 0; jphi < nphi; jphi++) {
3361  double ccc1 = variance[i][jeta][jphi];
3362  int k2plot = jeta - 41;
3363  int kkk = k2plot; //if(k2plot >0 kkk=k2plot+1; //-41 +41 !=0
3364  if (alexhe[i][jeta][jphi] > 0.) {
3365  Defz42D->Fill(kkk, jphi, ccc1);
3366  Defz42D0->Fill(kkk, jphi, 1.);
3367  }
3368  }
3369  }
3370  }
3371  Defz42DF->Divide(Defz42D, Defz42D0, 1, 1, "B"); // average A
3372  // Defz1->Sumw2();
3373  gPad->SetGridy();
3374  gPad->SetGridx(); // gPad->SetLogz();
3375  Defz42DF->SetMarkerStyle(20);
3376  Defz42DF->SetMarkerSize(0.4);
3377  Defz42DF->GetZaxis()->SetLabelSize(0.08);
3378  Defz42DF->SetXTitle("<D>_depth #eta \b");
3379  Defz42DF->SetYTitle(" #phi \b");
3380  Defz42DF->SetZTitle("<D>_depth \b");
3381  Defz42DF->SetMarkerColor(2);
3382  Defz42DF->SetLineColor(0); // Defz42DF->SetMaximum(1.000); // Defz42DF->SetMinimum(1.0);
3383  Defz42DF->Draw("COLZ");
3385  c1x0->Update();
3386  c1x0->Print("Dhist2IterationMethodHE.png");
3387  c1x0->Clear();
3388  // clean-up
3389  if (Defz42D)
3390  delete Defz42D;
3391  if (Defz42D0)
3392  delete Defz42D0;
3393  if (Defz42DF)
3394  delete Defz42DF;
3395 
3396  //====================================================================== 1D plot: D vs phi , averaged over depthes & eta
3397  //======================================================================
3398  cout << " 1D plot: D vs phi , averaged over depthes & eta *****" << endl;
3399  c1x1->Clear();
3401  c1x1->Divide(1, 1);
3402  c1x1->cd(1);
3403  TH1F *Defz41D = new TH1F("Defz41D", "", nphi, 0., 72.);
3404  TH1F *Defz41D0 = new TH1F("Defz41D0", "", nphi, 0., 72.);
3405  TH1F *Defz41DF = (TH1F *)Defz41D0->Clone("Defz41DF");
3406 
3407  for (int jeta = 0; jeta < neta; jeta++) {
3408  // positivedirectionD:
3409  for (int jphi = 0; jphi < nphi; jphi++) {
3410  if (jeta - 41 > 0) {
3411  for (int i = 0; i < ndepth; i++) {
3412  double ccc1 = variance[i][jeta][jphi];
3413  if (alexhe[i][jeta][jphi] > 0.) {
3414  Defz41D->Fill(jphi, ccc1);
3415  Defz41D0->Fill(jphi, 1.);
3416  }
3417  }
3418  }
3419  }
3420  }
3421  // Defz41D->Sumw2();Defz41D0->Sumw2();
3422 
3423  Defz41DF->Divide(Defz41D, Defz41D0, 1, 1, "B"); // R averaged over depthes & eta
3424  Defz41D0->Sumw2();
3425  // for (int jphi=1;jphi<73;jphi++) {Defz41DF->SetBinError(jphi,0.01);}
3426  gPad->SetGridy();
3427  gPad->SetGridx(); // gPad->SetLogz();
3428  Defz41DF->SetMarkerStyle(20);
3429  Defz41DF->SetMarkerSize(1.4);
3430  Defz41DF->GetZaxis()->SetLabelSize(0.08);
3431  Defz41DF->SetXTitle("#phi \b");
3432  Defz41DF->SetYTitle(" <D> \b");
3433  Defz41DF->SetZTitle("<D>_PHI - AllDepthes \b");
3434  Defz41DF->SetMarkerColor(4);
3435  Defz41DF->SetLineColor(4);
3436  Defz41DF->SetMinimum(0.8);
3437  Defz41DF->SetMinimum(-0.015);
3438  Defz41DF->Draw("Error");
3440  c1x1->Update();
3441  c1x1->Print("Dhist1IterationMethodHE.png");
3442  c1x1->Clear();
3443  // clean-up
3444  if (Defz41D)
3445  delete Defz41D;
3446  if (Defz41D0)
3447  delete Defz41D0;
3448  if (Defz41DF)
3449  delete Defz41DF;
3450 
3451  //========================================================================================== 14
3452  //======================================================================
3453  //======================================================================1D plot: D vs phi , different eta, depth=1
3454  cout << " 1D plot: D vs phi , different eta, depth=1 *****" << endl;
3455  c3x5->Clear();
3457  c3x5->Divide(3, 5);
3458  c3x5->cd(1);
3459 
3460  int kcountHEpositivedirectionD1 = 1;
3461  TH1F *h2CeffHEpositivedirectionD1 = new TH1F("h2CeffHEpositivedirectionD1", "", nphi, 0., 72.);
3462 
3463  for (int jeta = 0; jeta < njeta; jeta++) {
3464  // positivedirectionD:
3465  if (jeta - 41 > 0) {
3466  // for (int i=0;i<ndepth;i++) {
3467  // depth=1
3468  for (int i = 0; i < 1; i++) {
3469  TH1F *HEpositivedirectionD1 = (TH1F *)h2CeffHEpositivedirectionD1->Clone("twod1");
3470 
3471  float ccctest = 0; // to avoid empty massive elements
3472  for (int jphi = 0; jphi < nphi; jphi++) {
3473  double ccc1 = variance[i][jeta][jphi];
3474  if (alexhe[i][jeta][jphi] > 0.) {
3475  HEpositivedirectionD1->Fill(jphi, ccc1);
3476  ccctest = 1.; //HEpositivedirectionD1->SetBinError(i,0.01);
3477  }
3478  } // for jphi
3479  if (ccctest > 0.) {
3480  cout << "1414 kcountHEpositivedirectionD1 = " << kcountHEpositivedirectionD1
3481  << " jeta-41= " << jeta - 41 << endl;
3482  c3x5->cd(kcountHEpositivedirectionD1);
3483  HEpositivedirectionD1->SetMarkerStyle(20);
3484  HEpositivedirectionD1->SetMarkerSize(0.4);
3485  HEpositivedirectionD1->GetYaxis()->SetLabelSize(0.04);
3486  HEpositivedirectionD1->SetXTitle("HEpositivedirectionD1 \b");
3487  HEpositivedirectionD1->SetMarkerColor(2);
3488  HEpositivedirectionD1->SetLineColor(0);
3489  gPad->SetGridy();
3490  gPad->SetGridx();
3491  // gPad->SetLogy();
3492  if (kcountHEpositivedirectionD1 == 1)
3493  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 18; depth = 1 \b");
3494  if (kcountHEpositivedirectionD1 == 2)
3495  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 19; depth = 1 \b");
3496  if (kcountHEpositivedirectionD1 == 3)
3497  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 20; depth = 1 \b");
3498  if (kcountHEpositivedirectionD1 == 4)
3499  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 21; depth = 1 \b");
3500  if (kcountHEpositivedirectionD1 == 5)
3501  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 22; depth = 1 \b");
3502  if (kcountHEpositivedirectionD1 == 6)
3503  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 23; depth = 1 \b");
3504  if (kcountHEpositivedirectionD1 == 7)
3505  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 24; depth = 1 \b");
3506  if (kcountHEpositivedirectionD1 == 8)
3507  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 25; depth = 1 \b");
3508  if (kcountHEpositivedirectionD1 == 9)
3509  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 26; depth = 1 \b");
3510  if (kcountHEpositivedirectionD1 == 10)
3511  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 27; depth = 1 \b");
3512  if (kcountHEpositivedirectionD1 == 11)
3513  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 28; depth = 1 \b");
3514  if (kcountHEpositivedirectionD1 == 12)
3515  HEpositivedirectionD1->SetXTitle("D for HE+ jeta = 29; depth = 1 \b");
3516  HEpositivedirectionD1->Draw("Error");
3517  kcountHEpositivedirectionD1++;
3518  if (kcountHEpositivedirectionD1 > 15)
3519  break; // 4x6 = 24
3520  } //ccctest>0
3521 
3522  } // for i
3523  } //if(jeta-41 > 0)
3524  } //for jeta
3526  c3x5->Update();
3527  c3x5->Print("Dhist1IterationMethodDepth1HE.png");
3528  c3x5->Clear();
3529  // clean-up
3530  if (h2CeffHEpositivedirectionD1)
3531  delete h2CeffHEpositivedirectionD1;
3532 
3533  //========================================================================================== 15
3534  //======================================================================
3535  //======================================================================1D plot: D vs phi , different eta, depth=2
3536  cout << " 1D plot: D vs phi , different eta, depth=2 *****" << endl;
3537  c3x5->Clear();
3538  c3x5->Divide(3, 5);
3539  c3x5->cd(1);
3540  int kcountHEpositivedirectionD2 = 1;
3541  TH1F *h2CeffHEpositivedirectionD2 = new TH1F("h2CeffHEpositivedirectionD2", "", nphi, 0., 72.);
3542 
3543  for (int jeta = 0; jeta < njeta; jeta++) {
3544  // positivedirectionD:
3545  if (jeta - 41 > 0) {
3546  // for (int i=0;i<ndepth;i++) {
3547  // depth=2
3548  for (int i = 1; i < 2; i++) {
3549  TH1F *HEpositivedirectionD2 = (TH1F *)h2CeffHEpositivedirectionD2->Clone("twod1");
3550 
3551  float ccctest = 0; // to avoid empty massive elements
3552  for (int jphi = 0; jphi < nphi; jphi++) {
3553  double ccc1 = variance[i][jeta][jphi];
3554  if (alexhe[i][jeta][jphi] > 0.) {
3555  HEpositivedirectionD2->Fill(jphi, ccc1);
3556  ccctest = 1.; //HEpositivedirectionD2->SetBinError(i,0.01);
3557  }
3558  } // for jphi
3559  if (ccctest > 0.) {
3560  cout << "1515 kcountHEpositivedirectionD2 = " << kcountHEpositivedirectionD2
3561  << " jeta-41= " << jeta - 41 << endl;
3562  c3x5->cd(kcountHEpositivedirectionD2);
3563  HEpositivedirectionD2->SetMarkerStyle(20);
3564  HEpositivedirectionD2->SetMarkerSize(0.4);
3565  HEpositivedirectionD2->GetYaxis()->SetLabelSize(0.04);
3566  HEpositivedirectionD2->SetXTitle("HEpositivedirectionD2 \b");
3567  HEpositivedirectionD2->SetMarkerColor(2);
3568  HEpositivedirectionD2->SetLineColor(0);
3569  gPad->SetGridy();
3570  gPad->SetGridx();
3571  // gPad->SetLogy();
3572  if (kcountHEpositivedirectionD2 == 1)
3573  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 17; depth = 2 \b");
3574  if (kcountHEpositivedirectionD2 == 2)
3575  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 18; depth = 2 \b");
3576  if (kcountHEpositivedirectionD2 == 3)
3577  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 19; depth = 2 \b");
3578  if (kcountHEpositivedirectionD2 == 4)
3579  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 20; depth = 2 \b");
3580  if (kcountHEpositivedirectionD2 == 5)
3581  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 21; depth = 2 \b");
3582  if (kcountHEpositivedirectionD2 == 6)
3583  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 22; depth = 2 \b");
3584  if (kcountHEpositivedirectionD2 == 7)
3585  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 23; depth = 2 \b");
3586  if (kcountHEpositivedirectionD2 == 8)
3587  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 24; depth = 2 \b");
3588  if (kcountHEpositivedirectionD2 == 9)
3589  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 25; depth = 2 \b");
3590  if (kcountHEpositivedirectionD2 == 10)
3591  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 26; depth = 2 \b");
3592  if (kcountHEpositivedirectionD2 == 11)
3593  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 27; depth = 2 \b");
3594  if (kcountHEpositivedirectionD2 == 12)
3595  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 28; depth = 2 \b");
3596  if (kcountHEpositivedirectionD2 == 13)
3597  HEpositivedirectionD2->SetXTitle("D for HE+ jeta = 29; depth = 2 \b");
3598  HEpositivedirectionD2->Draw("Error");
3599  kcountHEpositivedirectionD2++;
3600  if (kcountHEpositivedirectionD2 > 15)
3601  break; // 4x6 = 24
3602  } //ccctest>0
3603 
3604  } // for i
3605  } //if(jeta-41 > 0)
3606  } //for jeta
3608  c3x5->Update();
3609  c3x5->Print("Dhist1IterationMethodDepth2HE.png");
3610  c3x5->Clear();
3611  // clean-up
3612  if (h2CeffHEpositivedirectionD2)
3613  delete h2CeffHEpositivedirectionD2;
3614 
3615  //========================================================================================== 16
3616  //======================================================================
3617  //======================================================================1D plot: D vs phi , different eta, depth=3
3618  cout << " 1D plot: D vs phi , different eta, depth=3 *****" << endl;
3619  c3x5->Clear();
3620  c3x5->Divide(3, 5);
3621  c3x5->cd(1);
3622  int kcountHEpositivedirectionD3 = 1;
3623  TH1F *h2CeffHEpositivedirectionD3 = new TH1F("h2CeffHEpositivedirectionD3", "", nphi, 0., 72.);
3624 
3625  for (int jeta = 0; jeta < njeta; jeta++) {
3626  // positivedirectionD:
3627  if (jeta - 41 > 0) {
3628  // for (int i=0;i<ndepth;i++) {
3629  // depth=3
3630  for (int i = 2; i < 3; i++) {
3631  TH1F *HEpositivedirectionD3 = (TH1F *)h2CeffHEpositivedirectionD3->Clone("twod1");
3632 
3633  float ccctest = 0; // to avoid empty massive elements
3634  for (int jphi = 0; jphi < nphi; jphi++) {
3635  double ccc1 = variance[i][jeta][jphi];
3636  if (alexhe[i][jeta][jphi] > 0.) {
3637  HEpositivedirectionD3->Fill(jphi, ccc1);
3638  ccctest = 1.; //HEpositivedirectionD3->SetBinError(i,0.01);
3639  }
3640  } // for jphi
3641  if (ccctest > 0.) {
3642  cout << "1616 kcountHEpositivedirectionD3 = " << kcountHEpositivedirectionD3
3643  << " jeta-41= " << jeta - 41 << endl;
3644  c3x5->cd(kcountHEpositivedirectionD3);
3645  HEpositivedirectionD3->SetMarkerStyle(20);
3646  HEpositivedirectionD3->SetMarkerSize(0.4);
3647  HEpositivedirectionD3->GetYaxis()->SetLabelSize(0.04);
3648  HEpositivedirectionD3->SetXTitle("HEpositivedirectionD3 \b");
3649  HEpositivedirectionD3->SetMarkerColor(2);
3650  HEpositivedirectionD3->SetLineColor(0);
3651  gPad->SetGridy();
3652  gPad->SetGridx();
3653  // gPad->SetLogy();
3654  if (kcountHEpositivedirectionD3 == 1)
3655  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 17; depth = 3 \b");
3656  if (kcountHEpositivedirectionD3 == 2)
3657  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 18; depth = 3 \b");
3658  if (kcountHEpositivedirectionD3 == 3)
3659  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 19; depth = 3 \b");
3660  if (kcountHEpositivedirectionD3 == 4)
3661  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 20; depth = 3 \b");
3662  if (kcountHEpositivedirectionD3 == 5)
3663  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 21; depth = 3 \b");
3664  if (kcountHEpositivedirectionD3 == 6)
3665  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 22; depth = 3 \b");
3666  if (kcountHEpositivedirectionD3 == 7)
3667  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 23; depth = 3 \b");
3668  if (kcountHEpositivedirectionD3 == 8)
3669  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 24; depth = 3 \b");
3670  if (kcountHEpositivedirectionD3 == 9)
3671  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 25; depth = 3 \b");
3672  if (kcountHEpositivedirectionD3 == 10)
3673  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 26; depth = 3 \b");
3674  if (kcountHEpositivedirectionD3 == 11)
3675  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 27; depth = 3 \b");
3676  if (kcountHEpositivedirectionD3 == 12)
3677  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 28; depth = 3 \b");
3678  if (kcountHEpositivedirectionD3 == 13)
3679  HEpositivedirectionD3->SetXTitle("D for HE+ jeta = 29; depth = 3 \b");
3680  HEpositivedirectionD3->Draw("Error");
3681  kcountHEpositivedirectionD3++;
3682  if (kcountHEpositivedirectionD3 > 15)
3683  break; // 4x6 = 24
3684  } //ccctest>0
3685 
3686  } // for i
3687  } //if(jeta-41 > 0)
3688  } //for jeta
3690  c3x5->Update();
3691  c3x5->Print("Dhist1IterationMethodDepth3HE.png");
3692  c3x5->Clear();
3693  // clean-up
3694  if (h2CeffHEpositivedirectionD3)
3695  delete h2CeffHEpositivedirectionD3;
3696 
3697  //========================================================================================== 17
3698  //======================================================================
3699  //======================================================================1D plot: D vs phi , different eta, depth=4
3700  cout << " 1D plot: D vs phi , different eta, depth=4 *****" << endl;
3701  c3x5->Clear();
3702  c3x5->Divide(3, 5);
3703  c3x5->cd(1);
3704  int kcountHEpositivedirectionD4 = 1;
3705  TH1F *h2CeffHEpositivedirectionD4 = new TH1F("h2CeffHEpositivedirectionD4", "", nphi, 0., 72.);
3706 
3707  for (int jeta = 0; jeta < njeta; jeta++) {
3708  // positivedirectionD:
3709  if (jeta - 41 > 0) {
3710  // for (int i=0;i<ndepth;i++) {
3711  // depth=4
3712  for (int i = 3; i < 4; i++) {
3713  TH1F *HEpositivedirectionD4 = (TH1F *)h2CeffHEpositivedirectionD4->Clone("twod1");
3714 
3715  float ccctest = 0; // to avoid empty massive elements
3716  for (int jphi = 0; jphi < nphi; jphi++) {
3717  double ccc1 = variance[i][jeta][jphi];
3718  if (alexhe[i][jeta][jphi] > 0.) {
3719  HEpositivedirectionD4->Fill(jphi, ccc1);
3720  ccctest = 1.; //HEpositivedirectionD4->SetBinError(i,0.01);
3721  }
3722  } // for jphi
3723  if (ccctest > 0.) {
3724  cout << "1717 kcountHEpositivedirectionD4 = " << kcountHEpositivedirectionD4
3725  << " jeta-41= " << jeta - 41 << endl;
3726  c3x5->cd(kcountHEpositivedirectionD4);
3727  HEpositivedirectionD4->SetMarkerStyle(20);
3728  HEpositivedirectionD4->SetMarkerSize(0.4);
3729  HEpositivedirectionD4->GetYaxis()->SetLabelSize(0.04);
3730  HEpositivedirectionD4->SetXTitle("HEpositivedirectionD4 \b");
3731  HEpositivedirectionD4->SetMarkerColor(2);
3732  HEpositivedirectionD4->SetLineColor(0);
3733  gPad->SetGridy();
3734  gPad->SetGridx();
3735  // gPad->SetLogy();
3736  if (kcountHEpositivedirectionD4 == 1)
3737  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 16; depth = 4 \b");
3738  if (kcountHEpositivedirectionD4 == 2)
3739  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 18; depth = 4 \b");
3740  if (kcountHEpositivedirectionD4 == 3)
3741  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 19; depth = 4 \b");
3742  if (kcountHEpositivedirectionD4 == 4)
3743  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 20; depth = 4 \b");
3744  if (kcountHEpositivedirectionD4 == 5)
3745  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 21; depth = 4 \b");
3746  if (kcountHEpositivedirectionD4 == 6)
3747  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 22; depth = 4 \b");
3748  if (kcountHEpositivedirectionD4 == 7)
3749  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 23; depth = 4 \b");
3750  if (kcountHEpositivedirectionD4 == 8)
3751  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 24; depth = 4 \b");
3752  if (kcountHEpositivedirectionD4 == 9)
3753  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 25; depth = 4 \b");
3754  if (kcountHEpositivedirectionD4 == 10)
3755  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 26; depth = 4 \b");
3756  if (kcountHEpositivedirectionD4 == 11)
3757  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 27; depth = 4 \b");
3758  if (kcountHEpositivedirectionD4 == 12)
3759  HEpositivedirectionD4->SetXTitle("D for HE+ jeta = 28; depth = 4 \b");
3760  HEpositivedirectionD4->Draw("Error");
3761  kcountHEpositivedirectionD4++;
3762  if (kcountHEpositivedirectionD4 > 15)
3763  break; // 4x6 = 24
3764  } //ccctest>0
3765 
3766  } // for i
3767  } //if(jeta-41 > 0)
3768  } //for jeta
3770  c3x5->Update();
3771  c3x5->Print("Dhist1IterationMethodDepth4HE.png");
3772  c3x5->Clear();
3773  // clean-up
3774  if (h2CeffHEpositivedirectionD4)
3775  delete h2CeffHEpositivedirectionD4;
3776 
3777  //========================================================================================== 18
3778  //======================================================================
3779  //======================================================================1D plot: D vs phi , different eta, depth=5
3780  cout << " 1D plot: D vs phi , different eta, depth=5 *****" << endl;
3781  c3x5->Clear();
3782  c3x5->Divide(3, 5);
3783  c3x5->cd(1);
3784  int kcountHEpositivedirectionD5 = 1;
3785  TH1F *h2CeffHEpositivedirectionD5 = new TH1F("h2CeffHEpositivedirectionD5", "", nphi, 0., 72.);
3786 
3787  for (int jeta = 0; jeta < njeta; jeta++) {
3788  // positivedirectionD:
3789  if (jeta - 41 > 0) {
3790  // for (int i=0;i<ndepth;i++) {
3791  // depth=5
3792  for (int i = 4; i < 5; i++) {
3793  TH1F *HEpositivedirectionD5 = (TH1F *)h2CeffHEpositivedirectionD5->Clone("twod1");
3794 
3795  float ccctest = 0; // to avoid empty massive elements
3796  for (int jphi = 0; jphi < nphi; jphi++) {
3797  double ccc1 = variance[i][jeta][jphi];
3798  if (alexhe[i][jeta][jphi] > 0.) {
3799  HEpositivedirectionD5->Fill(jphi, ccc1);
3800  ccctest = 1.; //HEpositivedirectionD5->SetBinError(i,0.01);
3801  }
3802  } // for jphi
3803  if (ccctest > 0.) {
3804  cout << "1818 kcountHEpositivedirectionD5 = " << kcountHEpositivedirectionD5
3805  << " jeta-41= " << jeta - 41 << endl;
3806  c3x5->cd(kcountHEpositivedirectionD5);
3807  HEpositivedirectionD5->SetMarkerStyle(20);
3808  HEpositivedirectionD5->SetMarkerSize(0.4);
3809  HEpositivedirectionD5->GetYaxis()->SetLabelSize(0.04);
3810  HEpositivedirectionD5->SetXTitle("HEpositivedirectionD5 \b");
3811  HEpositivedirectionD5->SetMarkerColor(2);
3812  HEpositivedirectionD5->SetLineColor(0);
3813  gPad->SetGridy();
3814  gPad->SetGridx();
3815  // gPad->SetLogy();
3816  if (kcountHEpositivedirectionD5 == 1)
3817  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 18; depth = 5 \b");
3818  if (kcountHEpositivedirectionD5 == 2)
3819  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 19; depth = 5 \b");
3820  if (kcountHEpositivedirectionD5 == 3)
3821  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 20; depth = 5 \b");
3822  if (kcountHEpositivedirectionD5 == 4)
3823  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 21; depth = 5 \b");
3824  if (kcountHEpositivedirectionD5 == 5)
3825  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 22; depth = 5 \b");
3826  if (kcountHEpositivedirectionD5 == 6)
3827  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 23; depth = 5 \b");
3828  if (kcountHEpositivedirectionD5 == 7)
3829  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 24; depth = 5 \b");
3830  if (kcountHEpositivedirectionD5 == 8)
3831  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 25; depth = 5 \b");
3832  if (kcountHEpositivedirectionD5 == 9)
3833  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 26; depth = 5 \b");
3834  if (kcountHEpositivedirectionD5 == 10)
3835  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 27; depth = 5 \b");
3836  if (kcountHEpositivedirectionD5 == 11)
3837  HEpositivedirectionD5->SetXTitle("D for HE+ jeta = 28; depth = 5 \b");
3838  HEpositivedirectionD5->Draw("Error");
3839  kcountHEpositivedirectionD5++;
3840  if (kcountHEpositivedirectionD5 > 15)
3841  break; // 4x6 = 24
3842  } //ccctest>0
3843 
3844  } // for i
3845  } //if(jeta-41 > 0)
3846  } //for jeta
3848  c3x5->Update();
3849  c3x5->Print("Dhist1IterationMethodDepth5HE.png");
3850  c3x5->Clear();
3851  // clean-up
3852  if (h2CeffHEpositivedirectionD5)
3853  delete h2CeffHEpositivedirectionD5;
3854 
3855  //========================================================================================== 19
3856  //======================================================================
3857  //======================================================================1D plot: D vs phi , different eta, depth=6
3858  cout << " 1D plot: D vs phi , different eta, depth=6 *****" << endl;
3859  c3x5->Clear();
3860  c3x5->Divide(3, 5);
3861  c3x5->cd(1);
3862  int kcountHEpositivedirectionD6 = 1;
3863  TH1F *h2CeffHEpositivedirectionD6 = new TH1F("h2CeffHEpositivedirectionD6", "", nphi, 0., 72.);
3864 
3865  for (int jeta = 0; jeta < njeta; jeta++) {
3866  // positivedirectionD:
3867  if (jeta - 41 > 0) {
3868  // for (int i=0;i<ndepth;i++) {
3869  // depth=6
3870  for (int i = 5; i < 6; i++) {
3871  TH1F *HEpositivedirectionD6 = (TH1F *)h2CeffHEpositivedirectionD6->Clone("twod1");
3872 
3873  float ccctest = 0; // to avoid empty massive elements
3874  for (int jphi = 0; jphi < nphi; jphi++) {
3875  double ccc1 = variance[i][jeta][jphi];
3876  if (alexhe[i][jeta][jphi] > 0.) {
3877  HEpositivedirectionD6->Fill(jphi, ccc1);
3878  ccctest = 1.; //HEpositivedirectionD6->SetBinError(i,0.01);
3879  }
3880  } // for jphi
3881  if (ccctest > 0.) {
3882  cout << "1919 kcountHEpositivedirectionD6 = " << kcountHEpositivedirectionD6
3883  << " jeta-41= " << jeta - 41 << endl;
3884  c3x5->cd(kcountHEpositivedirectionD6);
3885  HEpositivedirectionD6->SetMarkerStyle(20);
3886  HEpositivedirectionD6->SetMarkerSize(0.4);
3887  HEpositivedirectionD6->GetYaxis()->SetLabelSize(0.04);
3888  HEpositivedirectionD6->SetXTitle("HEpositivedirectionD6 \b");
3889  HEpositivedirectionD6->SetMarkerColor(2);
3890  HEpositivedirectionD6->SetLineColor(0);
3891  gPad->SetGridy();
3892  gPad->SetGridx();
3893  // gPad->SetLogy();
3894  if (kcountHEpositivedirectionD6 == 1)
3895  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 19; depth = 6 \b");
3896  if (kcountHEpositivedirectionD6 == 2)
3897  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 20; depth = 6 \b");
3898  if (kcountHEpositivedirectionD6 == 3)
3899  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 21; depth = 6 \b");
3900  if (kcountHEpositivedirectionD6 == 4)
3901  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 22; depth = 6 \b");
3902  if (kcountHEpositivedirectionD6 == 5)
3903  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 23; depth = 6 \b");
3904  if (kcountHEpositivedirectionD6 == 6)
3905  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 24; depth = 6 \b");
3906  if (kcountHEpositivedirectionD6 == 7)
3907  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 25; depth = 6 \b");
3908  if (kcountHEpositivedirectionD6 == 8)
3909  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 26; depth = 6 \b");
3910  if (kcountHEpositivedirectionD6 == 9)
3911  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 27; depth = 6 \b");
3912  if (kcountHEpositivedirectionD6 == 10)
3913  HEpositivedirectionD6->SetXTitle("D for HE+ jeta = 28; depth = 6 \b");
3914  HEpositivedirectionD6->Draw("Error");
3915  kcountHEpositivedirectionD6++;
3916  if (kcountHEpositivedirectionD6 > 15)
3917  break; // 4x6 = 24
3918  } //ccctest>0
3919 
3920  } // for i
3921  } //if(jeta-41 > 0)
3922  } //for jeta
3924  c3x5->Update();
3925  c3x5->Print("Dhist1IterationMethodDepth6HE.png");
3926  c3x5->Clear();
3927  // clean-up
3928  if (h2CeffHEpositivedirectionD6)
3929  delete h2CeffHEpositivedirectionD6;
3930 
3931  //========================================================================================== 20
3932  //======================================================================
3933  //======================================================================1D plot: D vs phi , different eta, depth=7
3934  cout << " 1D plot: D vs phi , different eta, depth=7 *****" << endl;
3935  c3x5->Clear();
3936  c3x5->Divide(3, 5);
3937  c3x5->cd(1);
3938  int kcountHEpositivedirectionD7 = 1;
3939  TH1F *h2CeffHEpositivedirectionD7 = new TH1F("h2CeffHEpositivedirectionD7", "", nphi, 0., 72.);
3940 
3941  for (int jeta = 0; jeta < njeta; jeta++) {
3942  // positivedirectionD:
3943  if (jeta - 41 > 0) {
3944  // for (int i=0;i<ndepth;i++) {
3945  // depth=7
3946  for (int i = 6; i < 7; i++) {
3947  TH1F *HEpositivedirectionD7 = (TH1F *)h2CeffHEpositivedirectionD7->Clone("twod1");
3948 
3949  float ccctest = 0; // to avoid empty massive elements
3950  for (int jphi = 0; jphi < nphi; jphi++) {
3951  double ccc1 = variance[i][jeta][jphi];
3952  if (alexhe[i][jeta][jphi] > 0.) {
3953  HEpositivedirectionD7->Fill(jphi, ccc1);
3954  ccctest = 1.; //HEpositivedirectionD7->SetBinError(i,0.01);
3955  }
3956  } // for jphi
3957  if (ccctest != 0.) {
3958  cout << "2020 kcountHEpositivedirectionD7 = " << kcountHEpositivedirectionD7
3959  << " jeta-41= " << jeta - 41 << endl;
3960  c3x5->cd(kcountHEpositivedirectionD7);
3961  HEpositivedirectionD7->SetMarkerStyle(20);
3962  HEpositivedirectionD7->SetMarkerSize(0.4);
3963  HEpositivedirectionD7->GetYaxis()->SetLabelSize(0.04);
3964  HEpositivedirectionD7->SetXTitle("HEpositivedirectionD7 \b");
3965  HEpositivedirectionD7->SetMarkerColor(2);
3966  HEpositivedirectionD7->SetLineColor(0);
3967  gPad->SetGridy();
3968  gPad->SetGridx();
3969  // gPad->SetLogy();
3970  if (kcountHEpositivedirectionD7 == 1)
3971  HEpositivedirectionD7->SetXTitle("D for HE+ jeta = 26; depth = 7 \b");
3972  if (kcountHEpositivedirectionD7 == 2)
3973  HEpositivedirectionD7->SetXTitle("D for HE+ jeta = 27; depth = 7 \b");
3974  if (kcountHEpositivedirectionD7 == 3)
3975  HEpositivedirectionD7->SetXTitle("D for HE+ jeta = 28; depth = 7 \b");
3976  HEpositivedirectionD7->Draw("Error");
3977  kcountHEpositivedirectionD7++;
3978  if (kcountHEpositivedirectionD7 > 15)
3979  break; // 4x6 = 24
3980  } //ccctest>0
3981 
3982  } // for i
3983  } //if(jeta-41 > 0)
3984  } //for jeta
3986  c3x5->Update();
3987  c3x5->Print("Dhist1IterationMethodDepth7HE.png");
3988  c3x5->Clear();
3989  // clean-up
3990  if (h2CeffHEpositivedirectionD7)
3991  delete h2CeffHEpositivedirectionD7;
3992 
3993  //=====================================================================
3994  //======================================================================
3995  //======================================================================
3996  //======================================================================
3997  //======================================================================
3998  //======================================================================
3999 
4000  std::cout << " We are here to print 2017 MAPs " << std::endl;
4001  //======================================================================
4002 
4003  //======================================================================
4005 
4006  TH2F *Map_ALL = new TH2F("Map_All", "Map_all", 82, -41, 40, 72, 0, 71);
4007  int nx = Map_ALL->GetXaxis()->GetNbins();
4008  int ny = Map_ALL->GetYaxis()->GetNbins();
4009  int NBad = 0;
4010  int NWarn = 0;
4011  int NCalib = 0;
4012  int NPed = 0;
4013  // int Eta[3][10000]={0};
4014  int Eta[4][10000] = {0};
4015  int Phi[4][10000] = {0};
4016  int Sub[4][10000] = {0};
4017  int Depth[4][10000] = {0};
4018  string Comment[4][10000] = {""};
4019  string Text[33] = {"", "Cm", "Am", "Wm", "Rm", "TNm", "TXm", "", "", "", "", "Cc", "Ac", "Wc", "Rc", "TNc", "TXc",
4020  "", "", "", "", "GS", "", "", "", "", "", "", "", "", "", "Pm", "pWm"};
4021  int flag_W = 0;
4022  int flag_B = 0;
4023  int flag_P = 0;
4024 
4025  for (int i = 1; i <= nx; i++) { //Eta
4026  for (int j = 1; j <= ny; j++) { // Phi
4027  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HO, 4-HF
4028  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
4029  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
4030  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
4031  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
4032  if (Map_SUB[sub][k]->GetBinContent(i, j) != 0) {
4033  Map_SUB[sub][k]->SetBinContent(i, j, 0.5);
4034  Map_ALL->SetBinContent(i, j, 0.5);
4035  }
4036  }
4037  }
4038  }
4039  }
4040 
4041  for (int i = 1; i <= nx; i++) { //Eta
4042  for (int j = 1; j <= ny; j++) { // Phi
4043  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
4044  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
4045  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
4046  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
4047  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
4048  flag_W = 0;
4049  flag_B = 0;
4050  flag_P = 0;
4051  for (int test = 1; test <= 6; test++) { //Test: 1-Wm, 2-Rm, etc
4052  //Bad
4053  if (Map_Ampl[test][sub][k]->GetBinContent(i, j) >
4054  0.1) { //Rate 0.1 for displaying on whole detector map and subdetector map
4055  Map_ALL->SetBinContent(i, j, 1.);
4056  Map_SUB[sub][k]->SetBinContent(i, j, 1.);
4057  if (flag_B == 0) {
4058  NBad += 1;
4059  Eta[2][NBad] = i - 41;
4060  Phi[2][NBad] = j - 1;
4061  Sub[2][NBad] = sub;
4062  Depth[2][NBad] = k;
4063  Comment[2][NBad] = Text[test];
4064  } else
4065  Comment[2][NBad] += ", " + Text[test];
4066  flag_B = 1;
4067  // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
4068  }
4069  //Warning
4070  /*
4071  if ((Map_Ampl[test][sub][k]->GetBinContent(i,j) != 0.)&&(Map_Ampl[test][sub][k]->GetBinContent(i,j) < 0.001) ) {
4072  if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.) Map_SUB[sub][k]->SetBinContent(i,j,0.75);
4073  if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.75);
4074  if (flag_W == 0) {
4075  NWarn +=1;
4076  Eta[1][NWarn]=i-41;
4077  Phi[1][NWarn]=j-1;
4078  Sub[1][NWarn]=sub;
4079  Depth[1][NWarn]=k;
4080  Comment[1][NWarn]=Text[test];
4081  }
4082  else Comment[1][NWarn]+=", "+Text[test];
4083  flag_W = 1;
4084 // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
4085  }
4086 */
4087 
4088  } //end test
4089 
4090  //Calib
4091  /*
4092  for (int test=11;test<=16;test++) { //Test: 1-2.E, 2-2.F, etc
4093  if (Map_Ampl[test][sub][k]->GetBinContent(i,j) != 0.) {
4094 // if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.0) Map_SUB[sub][k]->SetBinContent(i,j,0.3);
4095 // if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.3);
4096  if (flag_W == 0) {
4097  NWarn +=1;
4098  Eta[1][NWarn]=i-41;
4099  Phi[1][NWarn]=j-1;
4100  Sub[1][NWarn]=sub;
4101  Depth[1][NWarn]=k;
4102  Comment[1][NWarn]=Text[test];
4103  }
4104  else Comment[1][NWarn]+=", "+Text[test];
4105  flag_W = 1;
4106 // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
4107  }
4108  } //end test
4109 */
4110  //Gain stabil
4111  for (int test = 21; test <= 21; test++) {
4112  if (abs(Map_Ampl[test][sub][k]->GetBinContent(i, j)) > porog[sub]) {
4113  if (Map_SUB[sub][k]->GetBinContent(i, j) != 1.0)
4114  Map_SUB[sub][k]->SetBinContent(i, j, 0.75);
4115  if (Map_ALL->GetBinContent(i, j) != 1.) {
4116  Map_ALL->SetBinContent(i, j, 0.75);
4117  if (flag_W == 0) {
4118  NWarn += 1;
4119  Eta[1][NWarn] = i - 41;
4120  Phi[1][NWarn] = j - 1;
4121  Sub[1][NWarn] = sub;
4122  Depth[1][NWarn] = k;
4123  Comment[1][NWarn] = Text[test];
4124  } else
4125  Comment[1][NWarn] += ", " + Text[test];
4126  flag_W = 1;
4127 
4128  cout << "Map_Ampl[" << test << "][" << sub << "][" << k << "]->GetBinContent(" << i << "," << j
4129  << ")= " << Map_Ampl[test][sub][k]->GetBinContent(i, j) << endl;
4130  }
4131  }
4132  } //end test
4133 
4134  //Pedestals
4135  for (int test = 31; test <= 32; test++) {
4136  if (Map_Ampl[test][sub][k]->GetBinContent(i, j) > 0.1) {
4137  // if (Map_SUB[sub][k]->GetBinContent(i,j)!=1.0) Map_SUB[sub][k]->SetBinContent(i,j,0.75);
4138  // if (Map_ALL->GetBinContent(i,j)!=1.) Map_ALL->SetBinContent(i,j,0.75);
4139  if (flag_P == 0) {
4140  NPed += 1;
4141  Eta[3][NPed] = i - 41;
4142  Phi[3][NPed] = j - 1;
4143  Sub[3][NPed] = sub;
4144  Depth[3][NPed] = k;
4145  Comment[3][NPed] = Text[test];
4146  } else
4147  Comment[3][NPed] += ", " + Text[test];
4148  flag_P = 1;
4149 
4150  // cout<<"Map_Ampl["<<test<<"]["<<sub<<"]["<<k<<"]->GetBinContent("<<i<<","<<j<<")= "<<Map_Ampl[test][sub][k]->GetBinContent(i,j)<<endl;
4151  }
4152  } //end test
4153 
4154  } //end Depth
4155  } //end Sub
4156  } //end Phi
4157  } //end Eta
4158  // subdet maps
4159  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
4160 
4161  std::cout << " 2017 MAPS_SUB " << sub << std::endl;
4162  // if (sub==1) cHB->Divide(2,1);
4163  if (sub == 1)
4164  cHB->Divide(2, 2);
4165  // if (sub==2) cHE->Divide(3,1);
4166  if (sub == 2)
4167  cHE->Divide(3, 3);
4168  if (sub == 3)
4169  cONE->Divide(1, 1);
4170  // if (sub==4) cHB->Divide(2,1);
4171  if (sub == 4)
4172  cHF->Divide(2, 2);
4173  // int k_min[5]={0,1,1,4,1}; // minimum depth for each subdet
4174  // int k_max[5]={0,2,3,4,2}; // maximum depth for each subdet
4175  // int k_max[5]={0,2,7,4,4}; // maximum depth for each subdet
4176  for (int k = k_min[sub]; k <= k_max[sub]; k++) { //Depth
4177  if (sub == 1)
4178  cHB->cd(k);
4179  if (sub == 2)
4180  cHE->cd(k);
4181  if (sub == 3)
4182  cONE->cd(k - 3);
4183  if (sub == 4)
4184  cHF->cd(k);
4185  gPad->SetGridy();
4186  gPad->SetGridx();
4187  // gPad->SetLogz();
4188  // gStyle->SetTitleOffset(0.5, "Y");
4189  if (sub == 1)
4190  sprintf(str, "HB, Depth%d \b", k);
4191  if (sub == 2)
4192  sprintf(str, "HE, Depth%d \b", k);
4193  if (sub == 3)
4194  sprintf(str, "HO, Depth%d \b", k);
4195  if (sub == 4)
4196  sprintf(str, "HF, Depth%d \b", k);
4197  Map_SUB[sub][k]->SetTitle(str);
4198  Map_SUB[sub][k]->SetXTitle("#eta \b");
4199  Map_SUB[sub][k]->SetYTitle("#phi \b");
4200  Map_SUB[sub][k]->Draw("COL");
4201  Map_SUB[sub][k]->GetYaxis()->SetRangeUser(0, 72.);
4202  Map_SUB[sub][k]->GetZaxis()->SetRangeUser(0., 1.);
4203  if (sub == 1) {
4204  cHB->Modified();
4205  cHB->Update();
4206  }
4207  if (sub == 2) {
4208  cHE->Modified();
4209  cHE->Update();
4210  }
4211  if (sub == 3) {
4212  cONE->Modified();
4213  cONE->Update();
4214  }
4215  if (sub == 4) {
4216  cHF->Modified();
4217  cHF->Update();
4218  }
4219  } //end depth
4220  if (sub == 1) {
4221  cHB->Print("MAPHB.png");
4222  cHB->Clear();
4223  }
4224  if (sub == 2) {
4225  cHE->Print("MAPHE.png");
4226  cHE->Clear();
4227  }
4228  if (sub == 3) {
4229  cONE->Print("MAPHO.png");
4230  cONE->Clear();
4231  }
4232  if (sub == 4) {
4233  cHF->Print("MAPHF.png");
4234  cHF->Clear();
4235  }
4236  }
4237 
4239  // TCanvas *cmain1 = new TCanvas("cmain1","MAP",200,10,1400,1800);
4240  TCanvas *cmain1 = new TCanvas("cmain1", "MAP", 250, 10, 1450, 1410);
4241  cmain1->Divide(2, 2);
4242 
4243  cmain1->cd(1);
4244  TH1F *JDBEYESJ0 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHBperEvent");
4245  JDBEYESJ0->SetStats(0);
4246  JDBEYESJ0->SetMarkerStyle(20);
4247  JDBEYESJ0->SetMarkerSize(0.8);
4248  JDBEYESJ0->GetYaxis()->SetLabelSize(0.04);
4249  JDBEYESJ0->SetXTitle("iEvent \b");
4250  JDBEYESJ0->SetYTitle("totalAmplitude perEvent \b");
4251  JDBEYESJ0->SetTitle("HB \b");
4252  JDBEYESJ0->SetMarkerColor(2);
4253  JDBEYESJ0->SetLineColor(1);
4254  JDBEYESJ0->SetMinimum(0.8);
4255  JDBEYESJ0->Draw("HIST same P0");
4256 
4257  cmain1->cd(2);
4258  TH1F *JDBEYESJ1 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHEperEvent");
4259  JDBEYESJ1->SetStats(0);
4260  JDBEYESJ1->SetMarkerStyle(20);
4261  JDBEYESJ1->SetMarkerSize(0.8);
4262  JDBEYESJ1->GetYaxis()->SetLabelSize(0.04);
4263  JDBEYESJ1->SetXTitle("iEvent \b");
4264  JDBEYESJ1->SetYTitle("totalAmplitude perEvent \b");
4265  JDBEYESJ1->SetTitle("HE \b");
4266  JDBEYESJ1->SetMarkerColor(2);
4267  JDBEYESJ1->SetLineColor(1);
4268  JDBEYESJ1->SetMinimum(0.8);
4269  JDBEYESJ1->Draw("HIST same P0");
4270 
4271  cmain1->cd(3);
4272  TH1F *JDBEYESJ2 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHFperEvent");
4273  JDBEYESJ2->SetStats(0);
4274  JDBEYESJ2->SetMarkerStyle(20);
4275  JDBEYESJ2->SetMarkerSize(0.8);
4276  JDBEYESJ2->GetYaxis()->SetLabelSize(0.04);
4277  JDBEYESJ2->SetXTitle("iEvent \b");
4278  JDBEYESJ2->SetYTitle("totalAmplitude perEvent \b");
4279  JDBEYESJ2->SetTitle("HF \b");
4280  JDBEYESJ2->SetMarkerColor(2);
4281  JDBEYESJ2->SetLineColor(1);
4282  JDBEYESJ2->SetMinimum(0.8);
4283  JDBEYESJ2->Draw("HIST same P0");
4284 
4285  cmain1->cd(4);
4286  TH1F *JDBEYESJ3 = (TH1F *)dir->FindObjectAny("h_totalAmplitudeHOperEvent");
4287  JDBEYESJ3->SetStats(0);
4288  JDBEYESJ3->SetMarkerStyle(20);
4289  JDBEYESJ3->SetMarkerSize(0.8);
4290  JDBEYESJ3->GetYaxis()->SetLabelSize(0.04);
4291  JDBEYESJ3->SetXTitle("iEvent \b");
4292  JDBEYESJ3->SetYTitle("totalAmplitude perEvent \b");
4293  JDBEYESJ3->SetTitle("HO \b");
4294  JDBEYESJ3->SetMarkerColor(2);
4295  JDBEYESJ3->SetLineColor(1);
4296  JDBEYESJ3->SetMinimum(0.8);
4297  JDBEYESJ3->Draw("HIST same P0");
4298 
4299  cmain1->Modified();
4300  cmain1->Update();
4301  cmain1->Print("EVENTDEPENDENCE.png");
4302 
4303  std::cout << " EVENTDEPENDENCE " << std::endl;
4304 
4306  // ALL SubDet
4307  gStyle->SetOptTitle(0);
4308  TCanvas *cmain = new TCanvas("cmain", "MAP", 1000, 1000);
4309  //cmain->cd(1);
4310  gPad->SetGridy();
4311  gPad->SetGridx();
4312  // gPad->SetLogz();
4313  Map_ALL->SetTitleOffset(1.3, "Y");
4314  Map_ALL->SetXTitle("#eta \b");
4315  Map_ALL->SetYTitle("#phi \b");
4316  Map_ALL->Draw("COL");
4317  Map_ALL->GetYaxis()->SetRangeUser(0, 72.);
4318  Map_ALL->GetZaxis()->SetRangeUser(0, 1.);
4319  cmain->Modified();
4320  cmain->Update();
4321  cmain->Print("MAP.png");
4322 
4323  std::cout << "******** MAP_ALL done" << std::endl;
4324  std::cout << "********" << std::endl;
4325 
4326  std::cout << "********" << std::endl;
4327  std::cout << "************ Start creating each test kind for each subdet html pages:" << std::endl;
4328 
4329  //======================================================================
4330 
4331  //======================================================================
4332  // Creating each test kind for each subdet html pages:
4333  std::string raw_class, raw_class1, raw_class2, raw_class3;
4334  int ind = 0;
4335 
4336  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
4337  ofstream htmlFileT, htmlFileC, htmlFileD, htmlFileP, htmlFileS, htmlFileM;
4338  if (sub == 1) {
4339  htmlFileT.open("HB_Tile.html");
4340  htmlFileC.open("HB_Calib.html");
4341  htmlFileD.open("HB_Drift.html");
4342  htmlFileP.open("HB_Pedestals.html");
4343  htmlFileS.open("HB_Shapes.html");
4344  }
4345  if (sub == 2) {
4346  htmlFileT.open("HE_Tile.html");
4347  htmlFileC.open("HE_Calib.html");
4348  htmlFileD.open("HE_Drift.html");
4349  htmlFileP.open("HE_Pedestals.html");
4350  htmlFileS.open("HE_Shapes.html");
4351  htmlFileM.open("HE_IterationMethod.html");
4352  }
4353  if (sub == 3) {
4354  htmlFileT.open("HO_Tile.html");
4355  htmlFileC.open("HO_Calib.html");
4356  htmlFileD.open("HO_Drift.html");
4357  htmlFileP.open("HO_Pedestals.html");
4358  htmlFileS.open("HO_Shapes.html");
4359  }
4360  if (sub == 4) {
4361  htmlFileT.open("HF_Tile.html");
4362  htmlFileC.open("HF_Calib.html");
4363  htmlFileD.open("HF_Drift.html");
4364  htmlFileP.open("HF_Pedestals.html");
4365  htmlFileS.open("HF_Shapes.html");
4366  }
4367 
4368  // Megatile channels
4369  htmlFileT << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
4370  htmlFileT << "<head>" << std::endl;
4371  htmlFileT << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
4372  htmlFileT << "<title> Remote Monitoring Tool </title>" << std::endl;
4373  htmlFileT << "<style type=\"text/css\">" << std::endl;
4374  htmlFileT << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
4375  << std::endl;
4376  htmlFileT << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
4377  htmlFileT << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
4378  "text-align: center;}"
4379  << std::endl;
4380  htmlFileT << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
4381  htmlFileT << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
4382  htmlFileT << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
4383  htmlFileT << "</style>" << std::endl;
4384  htmlFileT << "<body>" << std::endl;
4385 
4386  if (sub == 1)
4387  htmlFileT << "<h1> Criteria for megatile channels for HB, RUN = " << runnumber << " </h1>" << std::endl;
4388  if (sub == 2)
4389  htmlFileT << "<h1> Criteria for megatile channels for HE, RUN = " << runnumber << " </h1>" << std::endl;
4390  if (sub == 3)
4391  htmlFileT << "<h1> Criteria for megatile channels for HO, RUN = " << runnumber << " </h1>" << std::endl;
4392  if (sub == 4)
4393  htmlFileT << "<h1> Criteria for megatile channels for HF, RUN = " << runnumber << " </h1>" << std::endl;
4394  htmlFileT << "<br>" << std::endl;
4395 
4396  // Test Entries
4397 
4398  htmlFileT << "<h2> 0. Entries for each channel.</h3>" << std::endl;
4399  htmlFileT << "<h3> 0.A. Entries in each channel for each depth.</h3>" << std::endl;
4400  htmlFileT << "<h4> Channel legend: color is rate of entries </h4>" << std::endl;
4401  if (sub == 1)
4402  htmlFileT << " <img src=\"MapRateEntryHB.png\" />" << std::endl;
4403  if (sub == 2)
4404  htmlFileT << " <img src=\"MapRateEntryHE.png\" />" << std::endl;
4405  if (sub == 3)
4406  htmlFileT << " <img src=\"MapRateEntryHO.png\" />" << std::endl;
4407  if (sub == 4)
4408  htmlFileT << " <img src=\"MapRateEntryHF.png\" />" << std::endl;
4409  htmlFileT << "<br>" << std::endl;
4410 
4411  // Test Cm
4412  htmlFileT << "<h2> 1. Cm criterion: CapID errors for each channel.</h3>" << std::endl;
4413  htmlFileT << "<h3> 1.A. Rate of CapId failures in each channel for each depth.</h3>" << std::endl;
4414  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4415  if (sub == 1)
4416  htmlFileT << " <img src=\"MapRateCapIDHB.png\" />" << std::endl;
4417  if (sub == 2)
4418  htmlFileT << " <img src=\"MapRateCapIDHE.png\" />" << std::endl;
4419  if (sub == 3)
4420  htmlFileT << " <img src=\"MapRateCapIDHO.png\" />" << std::endl;
4421  if (sub == 4)
4422  htmlFileT << " <img src=\"MapRateCapIDHF.png\" />" << std::endl;
4423  htmlFileT << "<br>" << std::endl;
4424 
4425  // Am
4426  htmlFileT << "<h2> 2. Am criterion: ADC amplitude collected over all TSs(Full Amplitude) for each channel. </h3>"
4427  << std::endl;
4428  htmlFileT << "<h3> 2.A. Full ADC amplitude distribution over all events, channels and depths.</h3>" << std::endl;
4429  htmlFileT << "<h4> Legend: Bins less " << MIN_M[2][sub] << " correpond to bad ADC amplitude </h4>" << std::endl;
4430  if (sub == 1)
4431  htmlFileT << " <img src=\"HistAmplHB.png\" />" << std::endl;
4432  if (sub == 2)
4433  htmlFileT << " <img src=\"HistAmplHE.png\" />" << std::endl;
4434  if (sub == 3)
4435  htmlFileT << " <img src=\"HistAmplHO.png\" />" << std::endl;
4436  if (sub == 4)
4437  htmlFileT << " <img src=\"HistAmplHF.png\" />" << std::endl;
4438  htmlFileT << "<br>" << std::endl;
4439  htmlFileT << "<h3> 2.B. Rate of bad ADC amplitude (<" << MIN_M[2][sub] << ") in each channel for each depth. </h3>"
4440  << std::endl;
4441  htmlFileT << "<h4> Channel legend: white - good, other colours - bad. </h4>" << std::endl;
4442  if (sub == 1)
4443  htmlFileT << " <img src=\"MapRateAmplHB.png\" />" << std::endl;
4444  if (sub == 2)
4445  htmlFileT << " <img src=\"MapRateAmplHE.png\" />" << std::endl;
4446  if (sub == 3)
4447  htmlFileT << " <img src=\"MapRateAmplHO.png\" />" << std::endl;
4448  if (sub == 4)
4449  htmlFileT << " <img src=\"MapRateAmplHF.png\" />" << std::endl;
4450  htmlFileT << "<br>" << std::endl;
4451 
4452  // Test Wm
4453  htmlFileT << "<h2> 3. Wm criterion: RMS (width) of ADC amplutude for each channel.</h3>" << std::endl;
4454  htmlFileT << "<h3> 3.A. RMS distribution over all events, channel and depth.</h3>" << std::endl;
4455  htmlFileT << "<h4> Legend: Bins less " << MIN_M[3][sub] << " and more " << MAX_M[3][sub]
4456  << " correpond to bad RMS </h4>" << std::endl;
4457  if (sub == 1)
4458  htmlFileT << " <img src=\"HistRMSHB.png\" />" << std::endl;
4459  if (sub == 2)
4460  htmlFileT << " <img src=\"HistRMSHE.png\" />" << std::endl;
4461  if (sub == 3)
4462  htmlFileT << " <img src=\"HistRMSHO.png\" />" << std::endl;
4463  if (sub == 4)
4464  htmlFileT << " <img src=\"HistRMSHF.png\" />" << std::endl;
4465  htmlFileT << "<br>" << std::endl;
4466  htmlFileT << "<h3> 3.B. Rate of bad RMS (<" << MIN_M[3][sub] << ",>" << MAX_M[3][sub]
4467  << ") in each channel for each depth.</h3>" << std::endl;
4468  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4469  if (sub == 1)
4470  htmlFileT << " <img src=\"MapRateRMSHB.png\" />" << std::endl;
4471  if (sub == 2)
4472  htmlFileT << " <img src=\"MapRateRMSHE.png\" />" << std::endl;
4473  if (sub == 3)
4474  htmlFileT << " <img src=\"MapRateRMSHO.png\" />" << std::endl;
4475  if (sub == 4)
4476  htmlFileT << " <img src=\"MapRateRMSHF.png\" />" << std::endl;
4477  htmlFileT << "<br>" << std::endl;
4478 
4479  // Rm
4480  htmlFileT << "<h2> 4. Rm criterion: Ratio ADC value sum over four near maximum (-2, -1, max, +1) TS to ADC value "
4481  "sum over all TS for each channel. </h3>"
4482  << std::endl;
4483  htmlFileT << "<h3> 4.A. Ratio distribution over all events, channels and depths.</h3>" << std::endl;
4484  htmlFileT << "<h4> Legend: Bins less " << MIN_M[4][sub] << " and more " << MAX_M[4][sub]
4485  << " correpond to bad ratio </h4>" << std::endl;
4486  if (sub == 1)
4487  htmlFileT << " <img src=\"Hist43TStoAllTSHB.png\" />" << std::endl;
4488  if (sub == 2)
4489  htmlFileT << " <img src=\"Hist43TStoAllTSHE.png\" />" << std::endl;
4490  if (sub == 3)
4491  htmlFileT << " <img src=\"Hist43TStoAllTSHO.png\" />" << std::endl;
4492  if (sub == 4)
4493  htmlFileT << " <img src=\"Hist43TStoAllTSHF.png\" />" << std::endl;
4494  htmlFileT << "<br>" << std::endl;
4495  htmlFileT << "<h3> 4.B. Rate of bad ratio (<" << MIN_M[4][sub] << ", >" << MAX_M[4][sub]
4496  << ") in each channel for each depth.</h3>" << std::endl;
4497  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4498  if (sub == 1)
4499  htmlFileT << " <img src=\"MapRate43TStoAllTSHB.png\" />" << std::endl;
4500  if (sub == 2)
4501  htmlFileT << " <img src=\"MapRate43TStoAllTSHE.png\" />" << std::endl;
4502  if (sub == 3)
4503  htmlFileT << " <img src=\"MapRate43TStoAllTSHO.png\" />" << std::endl;
4504  if (sub == 4)
4505  htmlFileT << " <img src=\"MapRate43TStoAllTSHF.png\" />" << std::endl;
4506  htmlFileT << "<br>" << std::endl;
4507 
4508  // TNm
4509  htmlFileT << "<h2> 5. TNm criterion: Mean TS position for each channel.</h3>" << std::endl;
4510  htmlFileT << "<h3> 5.A. TN position distribution over all events, channels and depths.</h3>" << std::endl;
4511  htmlFileT << "<h4> Legend: Bins less " << MIN_M[5][sub] << " and more " << MAX_M[5][sub]
4512  << " correpond to bad mean position </h4>" << std::endl;
4513  if (sub == 1)
4514  htmlFileT << " <img src=\"HistMeanPosHB.png\" />" << std::endl;
4515  if (sub == 2)
4516  htmlFileT << " <img src=\"HistMeanPosHE.png\" />" << std::endl;
4517  if (sub == 3)
4518  htmlFileT << " <img src=\"HistMeanPosHO.png\" />" << std::endl;
4519  if (sub == 4)
4520  htmlFileT << " <img src=\"HistMeanPosHF.png\" />" << std::endl;
4521  htmlFileT << "<br>" << std::endl;
4522  htmlFileT << "<h3> 5.B. Rate of bad TN position (<" << MIN_M[5][sub] << ", >" << MAX_M[5][sub]
4523  << ") in each channel for each depth. </h3>" << std::endl;
4524  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4525  if (sub == 1)
4526  htmlFileT << " <img src=\"MapRateMeanPosHB.png\" />" << std::endl;
4527  if (sub == 2)
4528  htmlFileT << " <img src=\"MapRateMeanPosHE.png\" />" << std::endl;
4529  if (sub == 3)
4530  htmlFileT << " <img src=\"MapRateMeanPosHO.png\" />" << std::endl;
4531  if (sub == 4)
4532  htmlFileT << " <img src=\"MapRateMeanPosHF.png\" />" << std::endl;
4533  htmlFileT << "<br>" << std::endl;
4534 
4535  // TXm
4536  htmlFileT << "<h2> 6.TXm criterion: Maximum TS position for each channel.</h3>" << std::endl;
4537  htmlFileT << "<h3> 6.A. TX position distribution over all events, channel and depth.</h3>" << std::endl;
4538  htmlFileT << "<h4> Legend: Bins less " << MIN_M[6][sub] << " and more " << MAX_M[6][sub]
4539  << " correpond to bad position </h4>" << std::endl;
4540  if (sub == 1)
4541  htmlFileT << " <img src=\"HistMaxPosHB.png\" />" << std::endl;
4542  if (sub == 2)
4543  htmlFileT << " <img src=\"HistMaxPosHE.png\" />" << std::endl;
4544  if (sub == 3)
4545  htmlFileT << " <img src=\"HistMaxPosHO.png\" />" << std::endl;
4546  if (sub == 4)
4547  htmlFileT << " <img src=\"HistMaxPosHF.png\" />" << std::endl;
4548  htmlFileT << "<br>" << std::endl;
4549  htmlFileT << "<h3> 6.B. Rate of bad TX position (<" << MIN_M[6][sub] << ", >" << MAX_M[6][sub]
4550  << ") in each channel for each depth. </h3>" << std::endl;
4551  htmlFileT << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4552  if (sub == 1)
4553  htmlFileT << " <img src=\"MapRateMaxPosHB.png\" />" << std::endl;
4554  if (sub == 2)
4555  htmlFileT << " <img src=\"MapRateMaxPosHE.png\" />" << std::endl;
4556  if (sub == 3)
4557  htmlFileT << " <img src=\"MapRateMaxPosHO.png\" />" << std::endl;
4558  if (sub == 4)
4559  htmlFileT << " <img src=\"MapRateMaxPosHF.png\" />" << std::endl;
4560  htmlFileT << "<br>" << std::endl;
4561 
4562  htmlFileT << "</body> " << std::endl;
4563  htmlFileT << "</html> " << std::endl;
4564  htmlFileT.close();
4565 
4566  //Calibration channels
4567  htmlFileC << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
4568  htmlFileC << "<head>" << std::endl;
4569  htmlFileC << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
4570  htmlFileC << "<title> Raw Data Analyser </title>" << std::endl;
4571  htmlFileC << "<style type=\"text/css\">" << std::endl;
4572  htmlFileC << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
4573  << std::endl;
4574  htmlFileC << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
4575  htmlFileC << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
4576  "text-align: center;}"
4577  << std::endl;
4578  htmlFileC << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
4579  htmlFileC << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
4580  htmlFileC << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
4581  htmlFileC << "</style>" << std::endl;
4582  htmlFileC << "<body>" << std::endl;
4583 
4584  if (sub == 1)
4585  htmlFileC << "<h1> Criteria for calibration channels for HB, RUN = " << runnumber << " </h1>" << std::endl;
4586  if (sub == 2)
4587  htmlFileC << "<h1> Criteria for calibration channels for HE, RUN = " << runnumber << " </h1>" << std::endl;
4588  if (sub == 3)
4589  htmlFileC << "<h1> Criteria for calibration channels for HO, RUN = " << runnumber << " </h1>" << std::endl;
4590  if (sub == 4)
4591  htmlFileC << "<h1> Criteria for calibration channels for HF, RUN = " << runnumber << " </h1>" << std::endl;
4592  htmlFileC << "<br>" << std::endl;
4593 
4594  // Test Entries
4595 
4596  htmlFileC << "<h2> 0. Entries for each channel.</h3>" << std::endl;
4597  htmlFileC << "<h3> 0.A. Entries in each channel for each depth.</h3>" << std::endl;
4598  htmlFileC << "<h4> Channel legend: color is rate of entries </h4>" << std::endl;
4599  if (sub == 1)
4600  htmlFileC << " <img src=\"MapRateCalibEntryHB.png\" />" << std::endl;
4601  if (sub == 2)
4602  htmlFileC << " <img src=\"MapRateCalibEntryHE.png\" />" << std::endl;
4603  if (sub == 3)
4604  htmlFileC << " <img src=\"MapRateCalibEntryHO.png\" />" << std::endl;
4605  if (sub == 4)
4606  htmlFileC << " <img src=\"MapRateCalibEntryHF.png\" />" << std::endl;
4607  htmlFileC << "<br>" << std::endl;
4608 
4609  // Test Cc
4610  htmlFileC << "<h2> 1. Cc criterion: CapID errors for each channel.</h3>" << std::endl;
4611  htmlFileC << "<h3> 1.A. Rate of CapId failures in each channel for each depth.</h3>" << std::endl;
4612  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4613  if (sub == 1)
4614  htmlFileC << " <img src=\"MapRateCapCalibHB.png\" />" << std::endl;
4615  if (sub == 2)
4616  htmlFileC << " <img src=\"MapRateCapCalibHE.png\" />" << std::endl;
4617  if (sub == 3)
4618  htmlFileC << " <img src=\"MapRateCapCalibHO.png\" />" << std::endl;
4619  if (sub == 4)
4620  htmlFileC << " <img src=\"MapRateCapCalibHF.png\" />" << std::endl;
4621  htmlFileC << "<br>" << std::endl;
4622 
4623  // Ac
4624  htmlFileC << "<h2> 2. Ac criterion: ADC amplitude collected over all TSs(Full Amplitude) for each channel. </h3>"
4625  << std::endl;
4626  htmlFileC << "<h3> 2.A. Full ADC amplitude distribution over all events, channels and depths.</h3>" << std::endl;
4627  htmlFileC << "<h4> Legend: Bins less " << MIN_C[2][sub] << " correpond to bad ADC amplitude </h4>" << std::endl;
4628  if (sub == 1)
4629  htmlFileC << " <img src=\"HistAmplCalibHB.png\" />" << std::endl;
4630  if (sub == 2)
4631  htmlFileC << " <img src=\"HistAmplCalibHE.png\" />" << std::endl;
4632  if (sub == 3)
4633  htmlFileC << " <img src=\"HistAmplCalibHO.png\" />" << std::endl;
4634  if (sub == 4)
4635  htmlFileC << " <img src=\"HistAmplCalibHF.png\" />" << std::endl;
4636  htmlFileC << "<br>" << std::endl;
4637  htmlFileC << "<h3> 2.B. Rate of bad ADC amplitude (<" << MIN_C[2][sub] << ") in each channel for each depth. </h3>"
4638  << std::endl;
4639  htmlFileC << "<h4> Channel legend: white - good, other colours - bad. </h4>" << std::endl;
4640  if (sub == 1)
4641  htmlFileC << " <img src=\"MapRateAmplCalibHB.png\" />" << std::endl;
4642  if (sub == 2)
4643  htmlFileC << " <img src=\"MapRateAmplCalibHE.png\" />" << std::endl;
4644  if (sub == 3)
4645  htmlFileC << " <img src=\"MapRateAmplCalibHO.png\" />" << std::endl;
4646  if (sub == 4)
4647  htmlFileC << " <img src=\"MapRateAmplCalibHF.png\" />" << std::endl;
4648  htmlFileC << "<br>" << std::endl;
4649 
4650  // Test Wc
4651  htmlFileC << "<h2> 3. Wc criterion: RMS (width) of ADC amplutude for each channel.</h3>" << std::endl;
4652  htmlFileC << "<h3> 3.A. W distribution over all events, channel and depth.</h3>" << std::endl;
4653  htmlFileC << "<h4> Legend: Bins less " << MIN_C[3][sub] << " and more " << MAX_C[3][sub]
4654  << " correpond to bad RMS </h4>" << std::endl;
4655  if (sub == 1)
4656  htmlFileC << " <img src=\"HistRMSCalibHB.png\" />" << std::endl;
4657  if (sub == 2)
4658  htmlFileC << " <img src=\"HistRMSCalibHE.png\" />" << std::endl;
4659  if (sub == 3)
4660  htmlFileC << " <img src=\"HistRMSCalibHO.png\" />" << std::endl;
4661  if (sub == 4)
4662  htmlFileC << " <img src=\"HistRMSCalibHF.png\" />" << std::endl;
4663  htmlFileC << "<br>" << std::endl;
4664  htmlFileC << "<h3> 3.B. Rate of bad W (<" << MIN_C[3][sub] << ",>" << MAX_C[3][sub]
4665  << ") in each channel for each depth.</h3>" << std::endl;
4666  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4667  if (sub == 1)
4668  htmlFileC << " <img src=\"MapRateRMSCalibHB.png\" />" << std::endl;
4669  if (sub == 2)
4670  htmlFileC << " <img src=\"MapRateRMSCalibHE.png\" />" << std::endl;
4671  if (sub == 3)
4672  htmlFileC << " <img src=\"MapRateRMSCalibHO.png\" />" << std::endl;
4673  if (sub == 4)
4674  htmlFileC << " <img src=\"MapRateRMSCalibHF.png\" />" << std::endl;
4675  htmlFileC << "<br>" << std::endl;
4676 
4677  // Rc
4678  htmlFileC << "<h2> 4. Rc criterion: Ratio ADC value sum over five near maximum (-2, -1, max, +1, +2) TS to ADC "
4679  "value sum over all TS for each channel. </h3>"
4680  << std::endl;
4681  htmlFileC << "<h3> 4.A. Ratio distribution over all events, channels and depths.</h3>" << std::endl;
4682  htmlFileC << "<h4> Legend: Bins less " << MIN_C[4][sub] << " and more " << MAX_C[4][sub]
4683  << " correpond to bad ratio </h4>" << std::endl;
4684  if (sub == 1)
4685  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHB.png\" />" << std::endl;
4686  if (sub == 2)
4687  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHE.png\" />" << std::endl;
4688  if (sub == 3)
4689  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHO.png\" />" << std::endl;
4690  if (sub == 4)
4691  htmlFileC << " <img src=\"Hist43TStoAllTSCalibHF.png\" />" << std::endl;
4692  htmlFileC << "<br>" << std::endl;
4693  htmlFileC << "<h3> 4.B. Rate of bad Ratio (<" << MIN_C[4][sub] << ", >" << MAX_C[4][sub]
4694  << ") in each channel for each depth.</h3>" << std::endl;
4695  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4696  if (sub == 1)
4697  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHB.png\" />" << std::endl;
4698  if (sub == 2)
4699  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHE.png\" />" << std::endl;
4700  if (sub == 3)
4701  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHO.png\" />" << std::endl;
4702  if (sub == 4)
4703  htmlFileC << " <img src=\"MapRate43TStoAllTSCalibHF.png\" />" << std::endl;
4704  htmlFileC << "<br>" << std::endl;
4705 
4706  // TNc
4707  htmlFileC << "<h2> 5. TNc criterion: Mean TS position for each channel.</h3>" << std::endl;
4708  htmlFileC << "<h3> 5.A. TN position distribution over all events, channels and depths.</h3>" << std::endl;
4709  htmlFileC << "<h4> Legend: Bins less " << MIN_C[5][sub] << " and more " << MAX_C[5][sub]
4710  << " correpond to bad position </h4>" << std::endl;
4711  if (sub == 1)
4712  htmlFileC << " <img src=\"HistMeanPosCalibHB.png\" />" << std::endl;
4713  if (sub == 2)
4714  htmlFileC << " <img src=\"HistMeanPosCalibHE.png\" />" << std::endl;
4715  if (sub == 3)
4716  htmlFileC << " <img src=\"HistMeanPosCalibHO.png\" />" << std::endl;
4717  if (sub == 4)
4718  htmlFileC << " <img src=\"HistMeanPosCalibHF.png\" />" << std::endl;
4719  htmlFileC << "<br>" << std::endl;
4720  htmlFileC << "<h3> 5.B. Rate of bad TN position (<" << MIN_C[5][sub] << ", >" << MAX_C[5][sub]
4721  << ") in each channel for each depth. </h3>" << std::endl;
4722  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4723  if (sub == 1)
4724  htmlFileC << " <img src=\"MapRateMeanPosCalibHB.png\" />" << std::endl;
4725  if (sub == 2)
4726  htmlFileC << " <img src=\"MapRateMeanPosCalibHE.png\" />" << std::endl;
4727  if (sub == 3)
4728  htmlFileC << " <img src=\"MapRateMeanPosCalibHO.png\" />" << std::endl;
4729  if (sub == 4)
4730  htmlFileC << " <img src=\"MapRateMeanPosCalibHF.png\" />" << std::endl;
4731  htmlFileC << "<br>" << std::endl;
4732 
4733  // TXm
4734  htmlFileC << "<h2> 6.TXc criterion: Maximum TS position for each channel.</h3>" << std::endl;
4735  htmlFileC << "<h3> 6.A. TX position distribution over all events, channel and depth.</h3>" << std::endl;
4736  htmlFileC << "<h4> Legend: Bins less " << MIN_C[6][sub] << " and more " << MAX_C[6][sub]
4737  << " correpond to bad position </h4>" << std::endl;
4738  if (sub == 1)
4739  htmlFileC << " <img src=\"HistMaxPosCalibHB.png\" />" << std::endl;
4740  if (sub == 2)
4741  htmlFileC << " <img src=\"HistMaxPosCalibHE.png\" />" << std::endl;
4742  if (sub == 3)
4743  htmlFileC << " <img src=\"HistMaxPosCalibHO.png\" />" << std::endl;
4744  if (sub == 4)
4745  htmlFileC << " <img src=\"HistMaxPosCalibHF.png\" />" << std::endl;
4746  htmlFileC << "<br>" << std::endl;
4747  htmlFileC << "<h3> 6.B. Rate of bad TX position (<" << MIN_C[6][sub] << ", >" << MAX_C[6][sub]
4748  << ") in each channel for each depth. </h3>" << std::endl;
4749  htmlFileC << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4750  if (sub == 1)
4751  htmlFileC << " <img src=\"MapRateMaxPosCalibHB.png\" />" << std::endl;
4752  if (sub == 2)
4753  htmlFileC << " <img src=\"MapRateMaxPosCalibHE.png\" />" << std::endl;
4754  if (sub == 3)
4755  htmlFileC << " <img src=\"MapRateMaxPosCalibHO.png\" />" << std::endl;
4756  if (sub == 4)
4757  htmlFileC << " <img src=\"MapRateMaxPosCalibHF.png\" />" << std::endl;
4758  htmlFileC << "<br>" << std::endl;
4759 
4760  htmlFileC << "</body> " << std::endl;
4761  htmlFileC << "</html> " << std::endl;
4762  htmlFileC.close();
4763 
4764  //Response drift
4765  htmlFileD << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
4766  htmlFileD << "<head>" << std::endl;
4767  htmlFileD << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
4768  htmlFileD << "<title> Remore Monitoring Tool </title>" << std::endl;
4769  htmlFileD << "<style type=\"text/css\">" << std::endl;
4770  htmlFileD << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
4771  << std::endl;
4772  htmlFileD << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
4773  htmlFileD << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
4774  "text-align: center;}"
4775  << std::endl;
4776  htmlFileD << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
4777  htmlFileD << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
4778  htmlFileD << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
4779  htmlFileD << "</style>" << std::endl;
4780  htmlFileD << "<body>" << std::endl;
4781 
4782  if (sub == 1)
4783  htmlFileD << "<h1> Response drift for HB: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
4784  << " </h1>" << std::endl;
4785  if (sub == 2)
4786  htmlFileD << "<h1> Response drift for HE: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
4787  << " </h1>" << std::endl;
4788  if (sub == 3)
4789  htmlFileD << "<h1> Response drift for HO: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
4790  << " </h1>" << std::endl;
4791  if (sub == 4)
4792  htmlFileD << "<h1> Response drift for HF: Current RUN = " << runnumber << ", Reference RUN = " << refrunnumber
4793  << " </h1>" << std::endl;
4794  htmlFileD << "<br>" << std::endl;
4795 
4796  // test GS
4797  htmlFileD << "<h2> 1. Gain Stability (GS) </h3>" << std::endl;
4798  htmlFileD << "<h3> 1.A. Averaged channel response, collected over all TS, for Current run in each channel for each "
4799  "depth.</h3>"
4800  << std::endl;
4801  htmlFileD << "<h4> Channel legend: colour means cooresponding value of mean response. </h4>" << std::endl;
4802  if (sub == 1)
4803  htmlFileD << " <img src=\"MapRateAmpl1HB.png\" />" << std::endl;
4804  if (sub == 2)
4805  htmlFileD << " <img src=\"MapRateAmpl1HE.png\" />" << std::endl;
4806  if (sub == 3)
4807  htmlFileD << " <img src=\"MapRateAmpl1HO.png\" />" << std::endl;
4808  if (sub == 4)
4809  htmlFileD << " <img src=\"MapRateAmpl1HF.png\" />" << std::endl;
4810  htmlFileD << "<br>" << std::endl;
4811  htmlFileD << "<h3> 1.B. Averaged channel response, collected over all TS, for Reference run in each channel for "
4812  "each depth.</h3>"
4813  << std::endl;
4814  htmlFileD << "<h4> Channel legend: colour means cooresponding value of mean response. </h4>" << std::endl;
4815  if (sub == 1)
4816  htmlFileD << " <img src=\"MapRateAmpl2HB.png\" />" << std::endl;
4817  if (sub == 2)
4818  htmlFileD << " <img src=\"MapRateAmpl2HE.png\" />" << std::endl;
4819  if (sub == 3)
4820  htmlFileD << " <img src=\"MapRateAmpl2HO.png\" />" << std::endl;
4821  if (sub == 4)
4822  htmlFileD << " <img src=\"MapRateAmpl2HF.png\" />" << std::endl;
4823  htmlFileD << "<br>" << std::endl;
4824  htmlFileD << "<h3> 1.C. Relative difference between Current and Reference run distribution over all events, "
4825  "channels for each depth.</h3>"
4826  << std::endl;
4827  htmlFileD << "<h4> Legend: Bins less -" << porog[sub] << "% and more +" << porog[sub]
4828  << "% correpond to bad relative difference position </h4>" << std::endl;
4829  if (sub == 1)
4830  htmlFileD << " <img src=\"HistAmplDriftDepthHB.png\" />" << std::endl;
4831  if (sub == 2)
4832  htmlFileD << " <img src=\"HistAmplDriftDepthHE.png\" />" << std::endl;
4833  if (sub == 3)
4834  htmlFileD << " <img src=\"HistAmplDriftDepthHO.png\" />" << std::endl;
4835  if (sub == 4)
4836  htmlFileD << " <img src=\"HistAmplDriftDepthHF.png\" />" << std::endl;
4837  htmlFileD << "<br>" << std::endl;
4838  htmlFileD << "<h3> 1.D. Rate of bad relative difference (<-" << porog[sub] << ", >+" << porog[sub]
4839  << ") in each channel for each depth.</h3>" << std::endl;
4840  htmlFileD << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4841  if (sub == 1)
4842  htmlFileD << " <img src=\"MapRateAmplDriftHB.png\" />" << std::endl;
4843  if (sub == 2)
4844  htmlFileD << " <img src=\"MapRateAmplDriftHE.png\" />" << std::endl;
4845  if (sub == 3)
4846  htmlFileD << " <img src=\"MapRateAmplDriftHO.png\" />" << std::endl;
4847  if (sub == 4)
4848  htmlFileD << " <img src=\"MapRateAmplDriftHF.png\" />" << std::endl;
4849  htmlFileD << "<br>" << std::endl;
4850 
4851  htmlFileD << "</body> " << std::endl;
4852  htmlFileD << "</html> " << std::endl;
4853  htmlFileD.close();
4854 
4855  // Pedestals
4856  htmlFileP << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
4857  htmlFileP << "<head>" << std::endl;
4858  htmlFileP << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
4859  htmlFileP << "<title> Remote Monitoring Tool </title>" << std::endl;
4860  htmlFileP << "<style type=\"text/css\">" << std::endl;
4861  htmlFileP << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
4862  << std::endl;
4863  htmlFileP << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
4864  htmlFileP << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
4865  "text-align: center;}"
4866  << std::endl;
4867  htmlFileP << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
4868  htmlFileP << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
4869  htmlFileP << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
4870  htmlFileP << "</style>" << std::endl;
4871  htmlFileP << "<body>" << std::endl;
4872 
4873  if (sub == 1)
4874  htmlFileP << "<h1> Pedestals for HB, RUN = " << runnumber << " </h1>" << std::endl;
4875  if (sub == 2)
4876  htmlFileP << "<h1> Pedestals for HE, RUN = " << runnumber << " </h1>" << std::endl;
4877  if (sub == 3)
4878  htmlFileP << "<h1> Pedestals for HO, RUN = " << runnumber << " </h1>" << std::endl;
4879  if (sub == 4)
4880  htmlFileP << "<h1> Pedestals for HF, RUN = " << runnumber << " </h1>" << std::endl;
4881  htmlFileP << "<br>" << std::endl;
4882 
4883  // Pedestal:
4884  htmlFileP << "<h2> 1.Pm criterion: Pedestals for each CapID .</h3>" << std::endl;
4885  htmlFileP << "<h3> 1.A. Pedestal distribution over all events, channels for each CapID and all depths.</h3>"
4886  << std::endl;
4887  htmlFileP << "<h4> Legend: Bins less " << Pedest[0][sub] << " correpond to bad Pedestals </h4>" << std::endl;
4888  if (sub == 1)
4889  htmlFileP << " <img src=\"HistPedestalsHB.png\" />" << std::endl;
4890  if (sub == 2)
4891  htmlFileP << " <img src=\"HistPedestalsHE.png\" />" << std::endl;
4892  if (sub == 3)
4893  htmlFileP << " <img src=\"HistPedestalsHO.png\" />" << std::endl;
4894  if (sub == 4)
4895  htmlFileP << " <img src=\"HistPedestalsHF.png\" />" << std::endl;
4896  htmlFileP << "<br>" << std::endl;
4897  htmlFileP << "<h3> 1.B. Rate of channels at very low Pedestals at least in one CapID for each depth.</h3>"
4898  << std::endl;
4899  htmlFileP << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4900  if (sub == 1)
4901  htmlFileP << " <img src=\"MapRatePedHB.png\" />" << std::endl;
4902  if (sub == 2)
4903  htmlFileP << " <img src=\"MapRatePedHE.png\" />" << std::endl;
4904  if (sub == 3)
4905  htmlFileP << " <img src=\"MapRatePedHO.png\" />" << std::endl;
4906  if (sub == 4)
4907  htmlFileP << " <img src=\"MapRatePedHF.png\" />" << std::endl;
4908 
4909  // PedestalWidth:
4910  htmlFileP << "<h2> 2.pWm criterion: Pedestal Widths for each CapID .</h3>" << std::endl;
4911  htmlFileP << "<h3> 2.A. Pedestal Widths distribution over all events, channels for each CapID and all depths.</h3>"
4912  << std::endl;
4913  htmlFileP << "<h4> Legend: Bins less " << Pedest[1][sub] << " correpond to bad Pedestal Widths </h4>" << std::endl;
4914  if (sub == 1)
4915  htmlFileP << " <img src=\"HistPedestalWidthsHB.png\" />" << std::endl;
4916  if (sub == 2)
4917  htmlFileP << " <img src=\"HistPedestalWidthsHE.png\" />" << std::endl;
4918  if (sub == 3)
4919  htmlFileP << " <img src=\"HistPedestalWidthsHO.png\" />" << std::endl;
4920  if (sub == 4)
4921  htmlFileP << " <img src=\"HistPedestalWidthsHF.png\" />" << std::endl;
4922  htmlFileP << "<br>" << std::endl;
4923  htmlFileP << "<h3> 2.B. Rate of channels at very low Pedestal Widths at least in one CapID for each depth.</h3>"
4924  << std::endl;
4925  htmlFileP << "<h4> Channel legend: white - good, other colour - bad. </h4>" << std::endl;
4926  if (sub == 1)
4927  htmlFileP << " <img src=\"MapRatePedWidthsHB.png\" />" << std::endl;
4928  if (sub == 2)
4929  htmlFileP << " <img src=\"MapRatePedWidthsHE.png\" />" << std::endl;
4930  if (sub == 3)
4931  htmlFileP << " <img src=\"MapRatePedWidthsHO.png\" />" << std::endl;
4932  if (sub == 4)
4933  htmlFileP << " <img src=\"MapRatePedWidthsHF.png\" />" << std::endl;
4934 
4935  // Correlations of Pedestal(Width) and fullAmplitude:
4936  htmlFileP << "<h2> 3.Pedestal and pedestalWidths vs Amplitude .</h3>" << std::endl;
4937  htmlFileP << "<h3> 3.A. Correlation of Pedestal(pedestalWidths) and Amplitude over all channels and events .</h3>"
4938  << std::endl;
4939  htmlFileP << "<h4> Legend: colour - entries </h4>" << std::endl;
4940  if (sub == 1)
4941  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHB.png\" />" << std::endl;
4942  if (sub == 2)
4943  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHE.png\" />" << std::endl;
4944  if (sub == 3)
4945  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHO.png\" />" << std::endl;
4946  if (sub == 4)
4947  htmlFileP << "<img src=\"CorrelationsMapPedestalVsfullAmplitudeHF.png\" />" << std::endl;
4948  htmlFileP << "<br>" << std::endl;
4949  htmlFileP.close();
4950 
4951  // TSs Shapes:
4952 
4953  htmlFileS << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
4954  htmlFileS << "<head>" << std::endl;
4955  htmlFileS << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
4956  htmlFileS << "<title> Remote Monitoring Tool </title>" << std::endl;
4957  htmlFileS << "<style type=\"text/css\">" << std::endl;
4958  htmlFileS << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
4959  << std::endl;
4960  htmlFileS << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
4961  htmlFileS << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
4962  "text-align: center;}"
4963  << std::endl;
4964  htmlFileS << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
4965  htmlFileS << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
4966  htmlFileS << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
4967  htmlFileS << "</style>" << std::endl;
4968  htmlFileS << "<body>" << std::endl;
4969 
4970  if (sub == 1)
4971  htmlFileS << "<h1> ADC Shape for HB, RUN = " << runnumber << " </h1>" << std::endl;
4972  if (sub == 2)
4973  htmlFileS << "<h1> ADC Shape for HE, RUN = " << runnumber << " </h1>" << std::endl;
4974  if (sub == 3)
4975  htmlFileS << "<h1> ADC Shape for HO, RUN = " << runnumber << " </h1>" << std::endl;
4976  if (sub == 4)
4977  htmlFileS << "<h1> ADC Shape for HF, RUN = " << runnumber << " </h1>" << std::endl;
4978  htmlFileS << "<br>" << std::endl;
4979 
4980  htmlFileS << "<h2> 1.Mean ADC Shape.</h3>" << std::endl;
4981  htmlFileS << "<h3> 1.A. ADC shape averaged over all good channels, depth and events.</h3>" << std::endl;
4982  // htmlFileS << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
4983  if (sub == 1)
4984  htmlFileS << " <img src=\"HistGoodTSshapesHB.png\" />" << std::endl;
4985  if (sub == 2)
4986  htmlFileS << " <img src=\"HistGoodTSshapesHE.png\" />" << std::endl;
4987  if (sub == 3)
4988  htmlFileS << " <img src=\"HistGoodTSshapesHO.png\" />" << std::endl;
4989  if (sub == 4)
4990  htmlFileS << " <img src=\"HistGoodTSshapesHF.png\" />" << std::endl;
4991  htmlFileS << "<br>" << std::endl;
4992  htmlFileS << "<h3> 1.B. ADC shape averaged over all bad channels, depth and events. Bad channels are selected by 5 "
4993  "criteria: CapId, A, W, P, Pw </h3>"
4994  << std::endl;
4995  // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
4996  if (sub == 1)
4997  htmlFileS << " <img src=\"HistBadTSshapesHB.png\" />" << std::endl;
4998  if (sub == 2)
4999  htmlFileS << " <img src=\"HistBadTSshapesHE.png\" />" << std::endl;
5000  if (sub == 3)
5001  htmlFileS << " <img src=\"HistBadTSshapesHO.png\" />" << std::endl;
5002  if (sub == 4)
5003  htmlFileS << " <img src=\"HistBadTSshapesHF.png\" />" << std::endl;
5004  /*
5005  htmlFileS << "<h2> 2. ADC in Time Slice </h3>"<< std::endl;
5006  htmlFileS << "<h3> 2.A. ADC counts histogrammed over all channels, depth and events.</h3>"<< std::endl;
5007 // htmlFileS << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
5008  if (sub==1) htmlFileS << " <img src=\"Hist_ADC_HB_All.png\" />" << std::endl;
5009  if (sub==2) htmlFileS << " <img src=\"Hist_ADC_HE_All.png\" />" << std::endl;
5010  if (sub==3) htmlFileS << " <img src=\"Hist_ADC_HO_All.png\" />" << std::endl;
5011  if (sub==4) htmlFileS << " <img src=\"Hist_ADC_HF_All.png\" />" << std::endl;
5012  htmlFileS << "<br>"<< std::endl;
5013  htmlFileS << "<h3> 2.B. ADC counts histogrammed over all channels and events for each depth separately. </h3>"<< std::endl;
5014 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5015  if (sub==1) htmlFileS << " <img src=\"Hist_ADC_HB_DS.png\" />" << std::endl;
5016  if (sub==2) htmlFileS << " <img src=\"Hist_ADC_HE_DS.png\" />" << std::endl;
5017  if (sub==3) htmlFileS << " <img src=\"Hist_ADC_HO_DS.png\" />" << std::endl;
5018  if (sub==4) htmlFileS << " <img src=\"Hist_ADC_HF_DS.png\" />" << std::endl;
5019 
5020  htmlFileS << "<h2> 3. ADC Sum in Time Slice </h3>"<< std::endl;
5021  htmlFileS << "<h3> 3.A. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
5022 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5023  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB.png\" />" << std::endl;
5024  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE.png\" />" << std::endl;
5025  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO.png\" />" << std::endl;
5026  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF.png\" />" << std::endl;
5027 
5028  htmlFileS << "<h3> 3.B. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
5029 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5030  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB0.png\" />" << std::endl;
5031  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE0.png\" />" << std::endl;
5032  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO0.png\" />" << std::endl;
5033  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF0.png\" />" << std::endl;
5034 
5035  htmlFileS << "<h3> 3.C. ADC Sum over all channels histogrammed over all events for each depth separately. </h3>"<< std::endl;
5036 // htmlFileS << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5037  if (sub==1) htmlFileS << " <img src=\"Hist_SumADC_HB1.png\" />" << std::endl;
5038  if (sub==2) htmlFileS << " <img src=\"Hist_SumADC_HE1.png\" />" << std::endl;
5039  if (sub==3) htmlFileS << " <img src=\"Hist_SumADC_HO1.png\" />" << std::endl;
5040  if (sub==4) htmlFileS << " <img src=\"Hist_SumADC_HF1.png\" />" << std::endl;
5041 */
5042  htmlFileS.close();
5043 
5045 
5046  // Iteration Method for Calibration Group:
5047 
5048  htmlFileM << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
5049  htmlFileM << "<head>" << std::endl;
5050  htmlFileM << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
5051  htmlFileM << "<title> Remote Monitoring Tool </title>" << std::endl;
5052  htmlFileM << "<style type=\"text/css\">" << std::endl;
5053  htmlFileM << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
5054  << std::endl;
5055  htmlFileM << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
5056  htmlFileM << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
5057  "text-align: center;}"
5058  << std::endl;
5059  htmlFileM << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
5060  htmlFileM << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
5061  htmlFileM << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
5062  htmlFileM << "</style>" << std::endl;
5063  htmlFileM << "<body>" << std::endl;
5064 
5065  if (sub == 1)
5066  htmlFileM << "<h1> Iteration Method for Calibration Group, HB, RUN = " << runnumber << " </h1>" << std::endl;
5067  if (sub == 2)
5068  htmlFileM << "<h1> Iteration Method for Calibration Group, HE, RUN = " << runnumber << " </h1>" << std::endl;
5069  if (sub == 3)
5070  htmlFileM << "<h1> Iteration Method for Calibration Group, HO, RUN = " << runnumber << " </h1>" << std::endl;
5071  if (sub == 4)
5072  htmlFileM << "<h1> Iteration Method for Calibration Group, HF, RUN = " << runnumber << " </h1>" << std::endl;
5073  htmlFileM << "<br>" << std::endl;
5074 
5075  htmlFileM << "<h2> 1: Positive direction, R = R_depth_ieta_iphi = E_depth_ieta_iphi/E_depth_ieta </h3>"
5076  << std::endl;
5077 
5078  htmlFileM << "<h3> 1.A. eta/phi-plot: R, averaged over depthes </h3>" << std::endl;
5079  // htmlFileM << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
5080  if (sub == 1)
5081  htmlFileM << " <img src=\"Rhist2IterationMethodHB.png\" />" << std::endl;
5082  if (sub == 2)
5083  htmlFileM << " <img src=\"Rhist2IterationMethodHE.png\" />" << std::endl;
5084  if (sub == 3)
5085  htmlFileM << " <img src=\"Rhist2IterationMethodHO.png\" />" << std::endl;
5086  if (sub == 4)
5087  htmlFileM << " <img src=\"Rhist2IterationMethodHF.png\" />" << std::endl;
5088  htmlFileM << "<br>" << std::endl;
5089 
5090  htmlFileM << "<h3> 1B: R vs phi , averaged over depthes & eta </h3>" << std::endl;
5091  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5092  if (sub == 1)
5093  htmlFileM << " <img src=\"Rhist1IterationMethodHB.png\" />" << std::endl;
5094  if (sub == 2)
5095  htmlFileM << " <img src=\"Rhist1IterationMethodHE.png\" />" << std::endl;
5096  if (sub == 3)
5097  htmlFileM << " <img src=\"Rhist1IterationMethodHO.png\" />" << std::endl;
5098  if (sub == 4)
5099  htmlFileM << " <img src=\"Rhist1IterationMethodHF.png\" />" << std::endl;
5100  htmlFileM << "<br>" << std::endl;
5101 
5103 
5104  htmlFileM << "<h3> 1C: R vs phi , different eta, Depth1 </h3>" << std::endl;
5105  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5106  if (sub == 1)
5107  htmlFileM << " <img src=\"Rhist1IterationMethodDepth1HB.png\" />" << std::endl;
5108  if (sub == 2)
5109  htmlFileM << " <img src=\"Rhist1IterationMethodDepth1HE.png\" />" << std::endl;
5110  if (sub == 4)
5111  htmlFileM << " <img src=\"Rhist1IterationMethodDepth1HF.png\" />" << std::endl;
5112  htmlFileM << "<br>" << std::endl;
5113 
5114  htmlFileM << "<h3> 1D: R vs phi , different eta, Depth2 </h3>" << std::endl;
5115  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5116  if (sub == 1)
5117  htmlFileM << " <img src=\"Rhist1IterationMethodDepth2HB.png\" />" << std::endl;
5118  if (sub == 2)
5119  htmlFileM << " <img src=\"Rhist1IterationMethodDepth2HE.png\" />" << std::endl;
5120  if (sub == 4)
5121  htmlFileM << " <img src=\"Rhist1IterationMethodDepth2HF.png\" />" << std::endl;
5122  htmlFileM << "<br>" << std::endl;
5123 
5124  htmlFileM << "<h3> 1E: R vs phi , different eta, Depth3 </h3>" << std::endl;
5125  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5126  if (sub == 1)
5127  htmlFileM << " <img src=\"Rhist1IterationMethodDepth3HB.png\" />" << std::endl;
5128  if (sub == 2)
5129  htmlFileM << " <img src=\"Rhist1IterationMethodDepth3HE.png\" />" << std::endl;
5130  if (sub == 4)
5131  htmlFileM << " <img src=\"Rhist1IterationMethodDepth3HF.png\" />" << std::endl;
5132  htmlFileM << "<br>" << std::endl;
5133 
5134  htmlFileM << "<h3> 1F: R vs phi , different eta, Depth4 </h3>" << std::endl;
5135  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5136  if (sub == 1)
5137  htmlFileM << " <img src=\"Rhist1IterationMethodDepth4HB.png\" />" << std::endl;
5138  if (sub == 2)
5139  htmlFileM << " <img src=\"Rhist1IterationMethodDepth4HE.png\" />" << std::endl;
5140  if (sub == 3)
5141  htmlFileM << " <img src=\"Rhist1IterationMethodDepth4HO.png\" />" << std::endl;
5142  if (sub == 4)
5143  htmlFileM << " <img src=\"Rhist1IterationMethodDepth4HF.png\" />" << std::endl;
5144  htmlFileM << "<br>" << std::endl;
5145 
5146  htmlFileM << "<h3> 1G: R vs phi , different eta, Depth5 </h3>" << std::endl;
5147  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5148  if (sub == 2)
5149  htmlFileM << " <img src=\"Rhist1IterationMethodDepth5HE.png\" />" << std::endl;
5150  htmlFileM << "<br>" << std::endl;
5151 
5152  htmlFileM << "<h3> 1H: R vs phi , different eta, Depth6 </h3>" << std::endl;
5153  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5154  if (sub == 2)
5155  htmlFileM << " <img src=\"Rhist1IterationMethodDepth6HE.png\" />" << std::endl;
5156  htmlFileM << "<br>" << std::endl;
5157 
5158  htmlFileM << "<h3> 1I: R vs phi , different eta, Depth7 </h3>" << std::endl;
5159  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5160  if (sub == 2)
5161  htmlFileM << " <img src=\"Rhist1IterationMethodDepth7HE.png\" />" << std::endl;
5162  htmlFileM << "<br>" << std::endl;
5163 
5164  htmlFileM << "<h2> 2: Positive direction, D(variance) </h3>" << std::endl;
5165 
5166  htmlFileM << "<h3> 2A: eta/phi-plot: D(variance), averaged over depthes </h3>" << std::endl;
5167  // htmlFileM << "<h4> Legend: Bins less "<<Pedest[0][sub]<<" correpond to bad Pedestals </h4>"<< std::endl;
5168  if (sub == 1)
5169  htmlFileM << " <img src=\"Dhist2IterationMethodHB.png\" />" << std::endl;
5170  if (sub == 2)
5171  htmlFileM << " <img src=\"Dhist2IterationMethodHE.png\" />" << std::endl;
5172  if (sub == 3)
5173  htmlFileM << " <img src=\"Dhist2IterationMethodHO.png\" />" << std::endl;
5174  if (sub == 4)
5175  htmlFileM << " <img src=\"Dhist2IterationMethodHF.png\" />" << std::endl;
5176  htmlFileM << "<br>" << std::endl;
5177 
5178  htmlFileM << "<h3> 2B: D(variance) vs phi , averaged over depthes & eta </h3>" << std::endl;
5179  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5180  if (sub == 1)
5181  htmlFileM << " <img src=\"Dhist1IterationMethodHB.png\" />" << std::endl;
5182  if (sub == 2)
5183  htmlFileM << " <img src=\"Dhist1IterationMethodHE.png\" />" << std::endl;
5184  if (sub == 3)
5185  htmlFileM << " <img src=\"Dhist1IterationMethodHO.png\" />" << std::endl;
5186  if (sub == 4)
5187  htmlFileM << " <img src=\"Dhist1IterationMethodHF.png\" />" << std::endl;
5188  htmlFileM << "<br>" << std::endl;
5189 
5191 
5192  htmlFileM << "<h3> 2C: D(variance) vs phi , different eta, Depth1 </h3>" << std::endl;
5193  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5194  if (sub == 1)
5195  htmlFileM << " <img src=\"Dhist1IterationMethodDepth1HB.png\" />" << std::endl;
5196  if (sub == 2)
5197  htmlFileM << " <img src=\"Dhist1IterationMethodDepth1HE.png\" />" << std::endl;
5198  if (sub == 4)
5199  htmlFileM << " <img src=\"Dhist1IterationMethodDepth1HF.png\" />" << std::endl;
5200  htmlFileM << "<br>" << std::endl;
5201 
5202  htmlFileM << "<h3> 2.D. D(variance) vs phi , different eta, Depth2 </h3>" << std::endl;
5203  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5204  if (sub == 1)
5205  htmlFileM << " <img src=\"Dhist1IterationMethodDepth2HB.png\" />" << std::endl;
5206  if (sub == 2)
5207  htmlFileM << " <img src=\"Dhist1IterationMethodDepth2HE.png\" />" << std::endl;
5208  if (sub == 4)
5209  htmlFileM << " <img src=\"Dhist1IterationMethodDepth2HF.png\" />" << std::endl;
5210  htmlFileM << "<br>" << std::endl;
5211 
5212  htmlFileM << "<h3> 2E: D(variance) vs phi , different eta, Depth3 </h3>" << std::endl;
5213  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5214  if (sub == 1)
5215  htmlFileM << " <img src=\"Dhist1IterationMethodDepth3HB.png\" />" << std::endl;
5216  if (sub == 2)
5217  htmlFileM << " <img src=\"Dhist1IterationMethodDepth3HE.png\" />" << std::endl;
5218  if (sub == 4)
5219  htmlFileM << " <img src=\"Dhist1IterationMethodDepth3HF.png\" />" << std::endl;
5220  htmlFileM << "<br>" << std::endl;
5221 
5222  htmlFileM << "<h3> 2F: D(variance) vs phi , different eta, Depth4 </h3>" << std::endl;
5223  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5224  if (sub == 1)
5225  htmlFileM << " <img src=\"Dhist1IterationMethodDepth4HB.png\" />" << std::endl;
5226  if (sub == 2)
5227  htmlFileM << " <img src=\"Dhist1IterationMethodDepth4HE.png\" />" << std::endl;
5228  if (sub == 3)
5229  htmlFileM << " <img src=\"Dhist1IterationMethodDepth4HO.png\" />" << std::endl;
5230  if (sub == 4)
5231  htmlFileM << " <img src=\"Dhist1IterationMethodDepth4HF.png\" />" << std::endl;
5232  htmlFileM << "<br>" << std::endl;
5233 
5234  htmlFileM << "<h3> 2G: D(variance) vs phi , different eta, Depth5 </h3>" << std::endl;
5235  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5236  if (sub == 2)
5237  htmlFileM << " <img src=\"Dhist1IterationMethodDepth5HE.png\" />" << std::endl;
5238  htmlFileM << "<br>" << std::endl;
5239 
5240  htmlFileM << "<h3> 2H: D(variance) vs phi , different eta, Depth6 </h3>" << std::endl;
5241  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5242  if (sub == 2)
5243  htmlFileM << " <img src=\"Dhist1IterationMethodDepth6HE.png\" />" << std::endl;
5244  htmlFileM << "<br>" << std::endl;
5245 
5246  htmlFileM << "<h3> 2I: D(variance) vs phi , different eta, Depth7 </h3>" << std::endl;
5247  // htmlFileM << "<h4> Channel legend: white - good, other colour - bad. </h4>"<< std::endl;
5248  if (sub == 2)
5249  htmlFileM << " <img src=\"Dhist1IterationMethodDepth7HE.png\" />" << std::endl;
5250  htmlFileM << "<br>" << std::endl;
5251 
5252  htmlFileM.close();
5253 
5255  //
5256  //
5257  } // end sub //for (int sub=1;sub<=4;sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
5258 
5259  //======================================================================
5260 
5261  std::cout << "********" << std::endl;
5262  std::cout << "************ Start creating subdet html pages: - rather long time needed, waiting please"
5263  << std::endl;
5264  //======================================================================
5265  // Creating subdet html pages:
5266 
5267  for (int sub = 1; sub <= 4; sub++) { //Subdetector: 1-HB, 2-HE, 3-HF, 4-HO
5268  ofstream htmlFile;
5269  if (sub == 1)
5270  htmlFile.open("HB.html");
5271  if (sub == 2)
5272  htmlFile.open("HE.html");
5273  if (sub == 3)
5274  htmlFile.open("HO.html");
5275  if (sub == 4)
5276  htmlFile.open("HF.html");
5277 
5278  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
5279  htmlFile << "<head>" << std::endl;
5280  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
5281  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
5282  htmlFile << "<style type=\"text/css\">" << std::endl;
5283  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
5284  << std::endl;
5285  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
5286  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
5287  "text-align: center;}"
5288  << std::endl;
5289  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
5290  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
5291  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
5292  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #FF00FF; }" << std::endl;
5293  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #9ACD32; }" << std::endl;
5294  htmlFile << " td.s7 { font-family: arial, arial ce, helvetica; background-color: #32CD32; }" << std::endl;
5295  htmlFile << " td.s8 { font-family: arial, arial ce, helvetica; background-color: #00FFFF; }" << std::endl;
5296  htmlFile << " td.s9 { font-family: arial, arial ce, helvetica; background-color: #FFE4E1; }" << std::endl;
5297  htmlFile << " td.s10 { font-family: arial, arial ce, helvetica; background-color: #A0522D; }" << std::endl;
5298  htmlFile << " td.s11 { font-family: arial, arial ce, helvetica; background-color: #1E90FF; }" << std::endl;
5299  htmlFile << " td.s12 { font-family: arial, arial ce, helvetica; background-color: #00BFFF; }" << std::endl;
5300  htmlFile << " td.s13 { font-family: arial, arial ce, helvetica; background-color: #FFFF00; }" << std::endl;
5301  htmlFile << " td.s14 { font-family: arial, arial ce, helvetica; background-color: #B8860B; }" << std::endl;
5302  htmlFile << "</style>" << std::endl;
5303  htmlFile << "<body>" << std::endl;
5304  if (sub == 1)
5305  htmlFile << "<h1> HCAL BARREL, RUN = " << runnumber << " </h1>" << std::endl;
5306  if (sub == 2)
5307  htmlFile << "<h1> HCAL ENDCAP, RUN = " << runnumber << " </h1>" << std::endl;
5308  if (sub == 3)
5309  htmlFile << "<h1> HCAL OUTER, RUN = " << runnumber << " </h1>" << std::endl;
5310  if (sub == 4)
5311  htmlFile << "<h1> HCAL FORWARD, RUN = " << runnumber << " </h1>" << std::endl;
5312  htmlFile << "<br>" << std::endl;
5313  if (sub == 1)
5314  htmlFile << "<h2> 1. Analysis results for HB</h2>" << std::endl;
5315  if (sub == 2)
5316  htmlFile << "<h2> 1. Analysis results for HE</h2>" << std::endl;
5317  if (sub == 3)
5318  htmlFile << "<h2> 1. Analysis results for HO</h2>" << std::endl;
5319  if (sub == 4)
5320  htmlFile << "<h2> 1. Analysis results for HF</h2>" << std::endl;
5321  htmlFile << "<table width=\"600\">" << std::endl;
5322  htmlFile << "<tr>" << std::endl;
5323 
5324  if (sub == 1) {
5325  /*
5326  htmlFile << " <td><a href=\"HB_Tile.html\">Megatile Channels</a></td>"<< std::endl;
5327  htmlFile << " <td><a href=\"HB_Calib.html\">Calibration Channels</a></td>"<< std::endl;
5328  htmlFile << " <td><a href=\"HB_Drift.html\">Gain Stability</a></td>"<< std::endl;
5329  htmlFile << " <td><a href=\"HB_Pedestals.html\">Pedestals</a></td>"<< std::endl;
5330  htmlFile << " <td><a href=\"HB_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
5331 */
5332 
5333  htmlFile << " <td><a "
5334  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5335  "HcalRemoteMonitoring/RMT/LED_"
5336  << runnumber << "/HB_Tile.html\">Megatile Channels</a></td>" << std::endl;
5337  htmlFile << " <td><a "
5338  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5339  "HcalRemoteMonitoring/RMT/LED_"
5340  << runnumber << "/HB_Calib.html\">Calibration Channels</a></td>" << std::endl;
5341  htmlFile << " <td><a "
5342  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5343  "HcalRemoteMonitoring/RMT/LED_"
5344  << runnumber << "/HB_Drift.html\">Gain Stability</a></td>" << std::endl;
5345  htmlFile << " <td><a "
5346  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5347  "HcalRemoteMonitoring/RMT/LED_"
5348  << runnumber << "/HB_Pedestals.html\">Pedestals</a></td>" << std::endl;
5349  htmlFile << " <td><a "
5350  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5351  "HcalRemoteMonitoring/RMT/LED_"
5352  << runnumber << "/HB_Shapes.html\">ADC Shapes</a></td>" << std::endl;
5353  }
5354  if (sub == 2) {
5355  /*
5356  htmlFile << " <td><a href=\"HE_Tile.html\">Megatile Channels</a></td>"<< std::endl;
5357  htmlFile << " <td><a href=\"HE_Calib.html\">Calibration Channels</a></td>"<< std::endl;
5358  htmlFile << " <td><a href=\"HE_Drift.html\">Gain Stability</a></td>"<< std::endl;
5359  htmlFile << " <td><a href=\"HE_Pedestals.html\">Pedestals</a></td>"<< std::endl;
5360  htmlFile << " <td><a href=\"HE_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
5361  htmlFile << " <td><a href=\"HE_IterationMethod.html\">Iteration Method</a></td>"<< std::endl;
5362 */
5363 
5364  htmlFile << " <td><a "
5365  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5366  "HcalRemoteMonitoring/RMT/LED_"
5367  << runnumber << "/HE_Tile.html\">Megatile Channels</a></td>" << std::endl;
5368  htmlFile << " <td><a "
5369  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5370  "HcalRemoteMonitoring/RMT/LED_"
5371  << runnumber << "/HE_Calib.html\">Calibration Channels</a></td>" << std::endl;
5372  htmlFile << " <td><a "
5373  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5374  "HcalRemoteMonitoring/RMT/LED_"
5375  << runnumber << "/HE_Drift.html\">Gain Stability</a></td>" << std::endl;
5376  htmlFile << " <td><a "
5377  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5378  "HcalRemoteMonitoring/RMT/LED_"
5379  << runnumber << "/HE_Pedestals.html\">Pedestals</a></td>" << std::endl;
5380  htmlFile << " <td><a "
5381  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5382  "HcalRemoteMonitoring/RMT/LED_"
5383  << runnumber << "/HE_Shapes.html\">ADC Shapes</a></td>" << std::endl;
5384  htmlFile << " <td><a "
5385  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5386  "HcalRemoteMonitoring/RMT/LED_"
5387  << runnumber << "/HE_IterationMethod.html\">Iteration Method</a></td>" << std::endl;
5388  }
5389 
5390  if (sub == 3) {
5391  /*
5392  htmlFile << " <td><a href=\"HO_Tile.html\">Megatile Channels</a></td>"<< std::endl;
5393  htmlFile << " <td><a href=\"HO_Calib.html\">Calibration Channels</a></td>"<< std::endl;
5394  htmlFile << " <td><a href=\"HO_Drift.html\">Gain Stability</a></td>"<< std::endl;
5395  htmlFile << " <td><a href=\"HO_Pedestals.html\">Pedestals</a></td>"<< std::endl;
5396  htmlFile << " <td><a href=\"HO_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
5397  */
5398  htmlFile << " <td><a "
5399  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5400  "HcalRemoteMonitoring/RMT/LED_"
5401  << runnumber << "/HO_Tile.html\">Megatile Channels</a></td>" << std::endl;
5402  htmlFile << " <td><a "
5403  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5404  "HcalRemoteMonitoring/RMT/LED_"
5405  << runnumber << "/HO_Calib.html\">Calibration Channels</a></td>" << std::endl;
5406  htmlFile << " <td><a "
5407  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5408  "HcalRemoteMonitoring/RMT/LED_"
5409  << runnumber << "/HO_Drift.html\">Gain Stability</a></td>" << std::endl;
5410  htmlFile << " <td><a "
5411  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5412  "HcalRemoteMonitoring/RMT/LED_"
5413  << runnumber << "/HO_Pedestals.html\">Pedestals</a></td>" << std::endl;
5414  htmlFile << " <td><a "
5415  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5416  "HcalRemoteMonitoring/RMT/LED_"
5417  << runnumber << "/HO_Shapes.html\">ADC Shapes</a></td>" << std::endl;
5418  }
5419  if (sub == 4) {
5420  /*
5421  htmlFile << " <td><a href=\"HF_Tile.html\">Megatile Channels</a></td>"<< std::endl;
5422  htmlFile << " <td><a href=\"HF_Calib.html\">Calibration Channels</a></td>"<< std::endl;
5423  htmlFile << " <td><a href=\"HF_Drift.html\">Gain Stability</a></td>"<< std::endl;
5424  htmlFile << " <td><a href=\"HF_Pedestals.html\">Pedestals</a></td>"<< std::endl;
5425  htmlFile << " <td><a href=\"HF_Shapes.html\">ADC Shapes</a></td>"<< std::endl;
5426  */
5427  htmlFile << " <td><a "
5428  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5429  "HcalRemoteMonitoring/RMT/LED_"
5430  << runnumber << "/HF_Tile.html\">Megatile Channels</a></td>" << std::endl;
5431  htmlFile << " <td><a "
5432  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5433  "HcalRemoteMonitoring/RMT/LED_"
5434  << runnumber << "/HF_Calib.html\">Calibration Channels</a></td>" << std::endl;
5435  htmlFile << " <td><a "
5436  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5437  "HcalRemoteMonitoring/RMT/LED_"
5438  << runnumber << "/HF_Drift.html\">Gain Stability</a></td>" << std::endl;
5439  htmlFile << " <td><a "
5440  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5441  "HcalRemoteMonitoring/RMT/LED_"
5442  << runnumber << "/HF_Pedestals.html\">Pedestals</a></td>" << std::endl;
5443  htmlFile << " <td><a "
5444  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5445  "HcalRemoteMonitoring/RMT/LED_"
5446  << runnumber << "/HF_Shapes.html\">ADC Shapes</a></td>" << std::endl;
5447  }
5448 
5449  htmlFile << "</tr>" << std::endl;
5450  htmlFile << "</table>" << std::endl;
5451  htmlFile << "<br>" << std::endl;
5452  if (sub == 1)
5453  htmlFile << "<h2> 2.Status HB over all criteria </h2>" << std::endl;
5454  if (sub == 2)
5455  htmlFile << "<h2> 2.Status HE over all criteria </h2>" << std::endl;
5456  if (sub == 3)
5457  htmlFile << "<h2> 2.Status HO over all criteria </h2>" << std::endl;
5458  if (sub == 4)
5459  htmlFile << "<h2> 2.Status HF over all criteria </h2>" << std::endl;
5460  htmlFile << "<h3> 2.A.Channel map for each Depth </h3>" << std::endl;
5461  htmlFile << "<h4> Channel legend: green - good, red - bad (rate of failures at least 0.1), yellow - at least 2% "
5462  "gain drift, white - not applicable or out of range </h4>"
5463  << std::endl;
5464  if (sub == 1)
5465  htmlFile << " <img src=\"MAPHB.png\" />" << std::endl;
5466  if (sub == 2)
5467  htmlFile << " <img src=\"MAPHE.png\" />" << std::endl;
5468  if (sub == 3)
5469  htmlFile << " <img src=\"MAPHO.png\" />" << std::endl;
5470  if (sub == 4)
5471  htmlFile << " <img src=\"MAPHF.png\" />" << std::endl;
5472  htmlFile << "<br>" << std::endl;
5473 
5474  htmlFile << "<h3> 2.B.List of Bad channels (rate > 0.1) and its rates for each RMT criteria (for GS - %) </h3>"
5475  << std::endl;
5476 
5477  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
5478  htmlFile << " <td><a "
5479  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
5480  "HcalRemoteMonitoring/RMT/LED_"
5481  << runnumber << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
5482 
5483  htmlFile << "<table>" << std::endl;
5484  htmlFile << "<tr>";
5485  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
5486  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
5487  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
5488  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
5489  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
5490  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
5491  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
5492  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
5493  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
5494  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
5495  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
5496  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
5497  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
5498  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
5499  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
5500  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
5501  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
5502  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
5503  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
5504  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
5505  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
5506  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
5507  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
5508  htmlFile << "<td class=\"s9\" align=\"center\">GS (%)</td>" << std::endl;
5509  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
5510  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
5511  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
5512  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
5513  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
5514  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
5515  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
5516  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
5517 
5518  htmlFile << "</tr>" << std::endl;
5519 
5520  for (int i = 1; i <= NBad; i++) {
5521  if ((ind % 2) == 1) {
5522  raw_class = "<td class=\"s2\" align=\"center\">";
5523  raw_class1 = "<td class=\"s6\" align=\"center\">";
5524  raw_class2 = "<td class=\"s11\" align=\"center\">";
5525  raw_class3 = "<td class=\"s13\" align=\"center\">";
5526 
5527  } else {
5528  raw_class = "<td class=\"s3\" align=\"center\">";
5529  raw_class1 = "<td class=\"s7\" align=\"center\">";
5530  raw_class2 = "<td class=\"s12\" align=\"center\">";
5531  raw_class3 = "<td class=\"s14\" align=\"center\">";
5532  }
5533  const CellDB db;
5534  CellDB ce;
5535  if ((ce.size() >= 1) && (Sub[2][i] == sub)) {
5536  if (Sub[2][i] == 1) {
5537  ce = db.find("subdet", "HB").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
5538  if (ce.size() == 0) {
5539  // cout<<"Error: No such HB, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
5540  continue;
5541  } else if (ce.size() > 1) {
5542  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
5543  << ", Depth=" << Depth[2][i] << " in database" << endl;
5544  }
5545  }
5546  if (Sub[2][i] == 2) {
5547  ce = db.find("subdet", "HE").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
5548  if (ce.size() == 0) {
5549  // cout<<"Error: No such HE, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
5550  continue;
5551  } else if (ce.size() > 1) {
5552  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
5553  << ", Depth=" << Depth[2][i] << " in database" << endl;
5554  }
5555  }
5556  if (Sub[2][i] == 3) {
5557  ce = db.find("subdet", "HO").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
5558  if (ce.size() == 0) {
5559  // cout<<"Error: No such HO, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
5560  continue;
5561  } else if (ce.size() > 1) {
5562  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
5563  << ", Depth=" << Depth[2][i] << " in database" << endl;
5564  }
5565  }
5566  if (Sub[2][i] == 4) {
5567  ce = db.find("subdet", "HF").find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
5568  if (ce.size() == 0) {
5569  // cout<<"Error: No such HF, Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
5570  continue;
5571  } else if (ce.size() > 1) {
5572  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[2][i] << ", Phi=" << Phi[2][i]
5573  << ", Depth=" << Depth[2][i] << " in database" << endl;
5574  }
5575  }
5576  htmlFile << "<tr>" << std::endl;
5577  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
5578  htmlFile << raw_class << Eta[2][i] << "</td>" << std::endl;
5579  htmlFile << raw_class << Phi[2][i] << "</td>" << std::endl;
5580  htmlFile << raw_class << Depth[2][i] << "</td>" << std::endl;
5581  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
5582  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
5583  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
5584  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
5585  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
5586  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
5587  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
5588  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
5589  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
5590  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
5591  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
5592  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
5593  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
5594  htmlFile << raw_class1 << Map_Ampl[1][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5595  << "</td>" << std::endl;
5596  htmlFile << raw_class1 << Map_Ampl[2][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5597  << "</td>" << std::endl;
5598  htmlFile << raw_class1 << Map_Ampl[3][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5599  << "</td>" << std::endl;
5600  htmlFile << raw_class1 << Map_Ampl[4][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5601  << "</td>" << std::endl;
5602  htmlFile << raw_class1 << Map_Ampl[5][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5603  << "</td>" << std::endl;
5604  htmlFile << raw_class1 << Map_Ampl[6][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5605  << "</td>" << std::endl;
5606  htmlFile << raw_class3 << Map_Ampl[21][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5607  << "</td>" << std::endl;
5608  htmlFile << raw_class << Map_Ampl[31][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5609  << "</td>" << std::endl;
5610  htmlFile << raw_class << Map_Ampl[32][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5611  << "</td>" << std::endl;
5612  htmlFile << raw_class2 << Map_Ampl[11][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5613  << "</td>" << std::endl;
5614  htmlFile << raw_class2 << Map_Ampl[12][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5615  << "</td>" << std::endl;
5616  htmlFile << raw_class2 << Map_Ampl[13][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5617  << "</td>" << std::endl;
5618  htmlFile << raw_class2 << Map_Ampl[14][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5619  << "</td>" << std::endl;
5620  htmlFile << raw_class2 << Map_Ampl[15][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5621  << "</td>" << std::endl;
5622  htmlFile << raw_class2 << Map_Ampl[16][Sub[2][i]][Depth[2][i]]->GetBinContent(Eta[2][i] + 41, Phi[2][i] + 1)
5623  << "</td>" << std::endl;
5624  htmlFile << "</tr>" << std::endl;
5625 
5626  ind += 1;
5627  }
5628  }
5629  htmlFile << "</table>" << std::endl;
5630  htmlFile << "<br>" << std::endl;
5631 
5632  htmlFile << "<h3> 2.C.List of Gain unstable channels and its value in % (for other criterias - rate)</h3>"
5633  << std::endl;
5634  htmlFile << "<table>" << std::endl;
5635  htmlFile << "<tr>";
5636  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
5637  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
5638  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
5639  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
5640  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
5641  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
5642  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
5643  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
5644  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
5645  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
5646  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
5647  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
5648  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
5649  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
5650  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
5651  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
5652  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
5653  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
5654  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
5655  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
5656  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
5657  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
5658  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
5659  htmlFile << "<td class=\"s9\" align=\"center\">GS(%)</td>" << std::endl;
5660  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
5661  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
5662  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
5663  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
5664  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
5665  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
5666  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
5667  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
5668  htmlFile << "</tr>" << std::endl;
5669 
5670  for (int i = 1; i <= NWarn; i++) {
5671  if ((ind % 2) == 1) {
5672  raw_class = "<td class=\"s2\" align=\"center\">";
5673  raw_class1 = "<td class=\"s6\" align=\"center\">";
5674  raw_class2 = "<td class=\"s11\" align=\"center\">";
5675  raw_class3 = "<td class=\"s13\" align=\"center\">";
5676 
5677  } else {
5678  raw_class = "<td class=\"s3\" align=\"center\">";
5679  raw_class1 = "<td class=\"s7\" align=\"center\">";
5680  raw_class2 = "<td class=\"s12\" align=\"center\">";
5681  raw_class3 = "<td class=\"s14\" align=\"center\">";
5682  }
5683  const CellDB db;
5684  CellDB ce;
5685  if ((ce.size() >= 1) && (Sub[1][i] == sub)) {
5686  if (Sub[1][i] == 1) {
5687  ce = db.find("subdet", "HB").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
5688  if (ce.size() == 0) {
5689  // cout<<"Error: No such HB, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
5690  continue;
5691  } else if (ce.size() > 1) {
5692  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
5693  << ", Depth=" << Depth[1][i] << " in database" << endl;
5694  }
5695  }
5696  if (Sub[1][i] == 2) {
5697  ce = db.find("subdet", "HE").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
5698  if (ce.size() == 0) {
5699  // cout<<"Error: No such HE, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
5700  continue;
5701  } else if (ce.size() > 1) {
5702  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
5703  << ", Depth=" << Depth[1][i] << " in database" << endl;
5704  }
5705  }
5706  if (Sub[1][i] == 3) {
5707  ce = db.find("subdet", "HO").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
5708  if (ce.size() == 0) {
5709  // cout<<"Error: No such HO, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
5710  continue;
5711  } else if (ce.size() > 1) {
5712  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
5713  << ", Depth=" << Depth[1][i] << " in database" << endl;
5714  }
5715  }
5716  if (Sub[1][i] == 4) {
5717  ce = db.find("subdet", "HF").find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
5718  if (ce.size() == 0) {
5719  // cout<<"Error: No such HF, Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
5720  continue;
5721  } else if (ce.size() > 1) {
5722  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[1][i] << ", Phi=" << Phi[1][i]
5723  << ", Depth=" << Depth[1][i] << " in database" << endl;
5724  }
5725  }
5726  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
5727  htmlFile << raw_class << Eta[1][i] << "</td>" << std::endl;
5728  htmlFile << raw_class << Phi[1][i] << "</td>" << std::endl;
5729  htmlFile << raw_class << Depth[1][i] << "</td>" << std::endl;
5730  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
5731  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
5732  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
5733  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
5734  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
5735  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
5736  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
5737  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
5738  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
5739  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
5740  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
5741  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
5742  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
5743  htmlFile << raw_class1 << Map_Ampl[1][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5744  << "</td>" << std::endl;
5745  htmlFile << raw_class1 << Map_Ampl[2][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5746  << "</td>" << std::endl;
5747  htmlFile << raw_class1 << Map_Ampl[3][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5748  << "</td>" << std::endl;
5749  htmlFile << raw_class1 << Map_Ampl[4][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5750  << "</td>" << std::endl;
5751  htmlFile << raw_class1 << Map_Ampl[5][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5752  << "</td>" << std::endl;
5753  htmlFile << raw_class1 << Map_Ampl[6][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5754  << "</td>" << std::endl;
5755  htmlFile << raw_class3 << Map_Ampl[21][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5756  << "</td>" << std::endl;
5757  htmlFile << raw_class << Map_Ampl[31][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5758  << "</td>" << std::endl;
5759  htmlFile << raw_class << Map_Ampl[32][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5760  << "</td>" << std::endl;
5761  htmlFile << raw_class2 << Map_Ampl[11][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5762  << "</td>" << std::endl;
5763  htmlFile << raw_class2 << Map_Ampl[12][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5764  << "</td>" << std::endl;
5765  htmlFile << raw_class2 << Map_Ampl[13][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5766  << "</td>" << std::endl;
5767  htmlFile << raw_class2 << Map_Ampl[14][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5768  << "</td>" << std::endl;
5769  htmlFile << raw_class2 << Map_Ampl[15][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5770  << "</td>" << std::endl;
5771  htmlFile << raw_class2 << Map_Ampl[16][Sub[1][i]][Depth[1][i]]->GetBinContent(Eta[1][i] + 41, Phi[1][i] + 1)
5772  << "</td>" << std::endl;
5773  htmlFile << "</tr>" << std::endl;
5774  htmlFile << "</tr>" << std::endl;
5775  ind += 1;
5776  }
5777  }
5778  htmlFile << "</table>" << std::endl;
5779  htmlFile << "<br>" << std::endl;
5780 
5781  htmlFile << "<h3> 2.D.List of channels with Bad Pedestals (rate > 0.1) and its rates (for GS - %)</h3>"
5782  << std::endl;
5783  htmlFile << "<table>" << std::endl;
5784  htmlFile << "<tr>";
5785  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
5786  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
5787  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
5788  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
5789  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
5790  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
5791  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
5792  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
5793  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
5794  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
5795  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
5796  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
5797  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
5798  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
5799  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
5800  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
5801  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
5802  htmlFile << "<td class=\"s5\" align=\"center\">Cm</td>" << std::endl;
5803  htmlFile << "<td class=\"s5\" align=\"center\">Am</td>" << std::endl;
5804  htmlFile << "<td class=\"s5\" align=\"center\">Wm</td>" << std::endl;
5805  htmlFile << "<td class=\"s5\" align=\"center\">Rm</td>" << std::endl;
5806  htmlFile << "<td class=\"s5\" align=\"center\">TNm</td>" << std::endl;
5807  htmlFile << "<td class=\"s5\" align=\"center\">TXm</td>" << std::endl;
5808  htmlFile << "<td class=\"s9\" align=\"center\">GS(%)</td>" << std::endl;
5809  htmlFile << "<td class=\"s4\" align=\"center\">Pm</td>" << std::endl;
5810  htmlFile << "<td class=\"s4\" align=\"center\">pWm</td>" << std::endl;
5811  htmlFile << "<td class=\"s8\" align=\"center\">Cc</td>" << std::endl;
5812  htmlFile << "<td class=\"s8\" align=\"center\">Ac</td>" << std::endl;
5813  htmlFile << "<td class=\"s8\" align=\"center\">Wc</td>" << std::endl;
5814  htmlFile << "<td class=\"s8\" align=\"center\">Rc</td>" << std::endl;
5815  htmlFile << "<td class=\"s8\" align=\"center\">TNc</td>" << std::endl;
5816  htmlFile << "<td class=\"s8\" align=\"center\">TXc</td>" << std::endl;
5817  htmlFile << "</tr>" << std::endl;
5818 
5819  for (int i = 1; i <= NPed; i++) {
5820  if ((ind % 2) == 1) {
5821  raw_class = "<td class=\"s2\" align=\"center\">";
5822  raw_class1 = "<td class=\"s6\" align=\"center\">";
5823  raw_class2 = "<td class=\"s11\" align=\"center\">";
5824  raw_class3 = "<td class=\"s13\" align=\"center\">";
5825 
5826  } else {
5827  raw_class = "<td class=\"s3\" align=\"center\">";
5828  raw_class1 = "<td class=\"s7\" align=\"center\">";
5829  raw_class2 = "<td class=\"s12\" align=\"center\">";
5830  raw_class3 = "<td class=\"s14\" align=\"center\">";
5831  }
5832  const CellDB db;
5833  CellDB ce;
5834  if ((ce.size() >= 1) && (Sub[3][i] == sub)) {
5835  if (Sub[3][i] == 1) {
5836  ce = db.find("subdet", "HB").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
5837  if (ce.size() == 0) {
5838  // cout<<"Error: No such HB, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
5839  continue;
5840  } else if (ce.size() > 1) {
5841  cout << "Warning: More than one line correspond to such HB, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
5842  << ", Depth=" << Depth[3][i] << " in database" << endl;
5843  }
5844  }
5845  if (Sub[3][i] == 2) {
5846  ce = db.find("subdet", "HE").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
5847  if (ce.size() == 0) {
5848  // cout<<"Error: No such HE, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
5849  continue;
5850  } else if (ce.size() > 1) {
5851  cout << "Warning: More than one line correspond to such HE, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
5852  << ", Depth=" << Depth[3][i] << " in database" << endl;
5853  }
5854  }
5855  if (Sub[3][i] == 3) {
5856  ce = db.find("subdet", "HO").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
5857  if (ce.size() == 0) {
5858  // cout<<"Error: No such HO, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
5859  continue;
5860  } else if (ce.size() > 1) {
5861  cout << "Warning: More than one line correspond to such HO, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
5862  << ", Depth=" << Depth[3][i] << " in database" << endl;
5863  }
5864  }
5865  if (Sub[3][i] == 4) {
5866  ce = db.find("subdet", "HF").find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
5867  if (ce.size() == 0) {
5868  // cout<<"Error: No such HF, Eta="<< Eta[3][i] <<", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
5869  continue;
5870  } else if (ce.size() > 1) {
5871  cout << "Warning: More than one line correspond to such HF, Eta=" << Eta[3][i] << ", Phi=" << Phi[3][i]
5872  << ", Depth=" << Depth[3][i] << " in database" << endl;
5873  }
5874  }
5875  htmlFile << "<td class=\"s4\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
5876  htmlFile << raw_class << Eta[3][i] << "</td>" << std::endl;
5877  htmlFile << raw_class << Phi[3][i] << "</td>" << std::endl;
5878  htmlFile << raw_class << Depth[3][i] << "</td>" << std::endl;
5879  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
5880  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
5881  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
5882  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
5883  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
5884  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
5885  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
5886  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
5887  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
5888  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
5889  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
5890  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
5891  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
5892  htmlFile << raw_class1 << Map_Ampl[1][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5893  << "</td>" << std::endl;
5894  htmlFile << raw_class1 << Map_Ampl[2][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5895  << "</td>" << std::endl;
5896  htmlFile << raw_class1 << Map_Ampl[3][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5897  << "</td>" << std::endl;
5898  htmlFile << raw_class1 << Map_Ampl[4][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5899  << "</td>" << std::endl;
5900  htmlFile << raw_class1 << Map_Ampl[5][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5901  << "</td>" << std::endl;
5902  htmlFile << raw_class1 << Map_Ampl[6][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5903  << "</td>" << std::endl;
5904  htmlFile << raw_class3 << Map_Ampl[21][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5905  << "</td>" << std::endl;
5906  htmlFile << raw_class << Map_Ampl[31][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5907  << "</td>" << std::endl;
5908  htmlFile << raw_class << Map_Ampl[32][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5909  << "</td>" << std::endl;
5910  htmlFile << raw_class2 << Map_Ampl[11][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5911  << "</td>" << std::endl;
5912  htmlFile << raw_class2 << Map_Ampl[12][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5913  << "</td>" << std::endl;
5914  htmlFile << raw_class2 << Map_Ampl[13][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5915  << "</td>" << std::endl;
5916  htmlFile << raw_class2 << Map_Ampl[14][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5917  << "</td>" << std::endl;
5918  htmlFile << raw_class2 << Map_Ampl[15][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5919  << "</td>" << std::endl;
5920  htmlFile << raw_class2 << Map_Ampl[16][Sub[3][i]][Depth[3][i]]->GetBinContent(Eta[3][i] + 41, Phi[3][i] + 1)
5921  << "</td>" << std::endl;
5922  htmlFile << "</tr>" << std::endl;
5923  htmlFile << "</tr>" << std::endl;
5924  ind += 1;
5925  }
5926  }
5927  htmlFile << "</table>" << std::endl;
5928 
5929  htmlFile << "</body> " << std::endl;
5930  htmlFile << "</html> " << std::endl;
5931  htmlFile.close();
5932  }
5933 
5934  //======================================================================
5935 
5936  std::cout << "********" << std::endl;
5937  std::cout << "************ Start creating description HELP html file:" << std::endl;
5938  //======================================================================
5939  // Creating description html file:
5940  ofstream htmlFile;
5941  htmlFile.open("HELP.html");
5942  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
5943  htmlFile << "<head>" << std::endl;
5944  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
5945  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
5946  htmlFile << "<style type=\"text/css\">" << std::endl;
5947  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
5948  << std::endl;
5949  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
5950  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
5951  "text-align: center;}"
5952  << std::endl;
5953  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
5954  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
5955  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
5956  htmlFile << "</style>" << std::endl;
5957  htmlFile << "<body>" << std::endl;
5958  htmlFile << "<h1> Description of Remote Monitoring Tool criteria for bad channel selection</h1>" << std::endl;
5959  htmlFile << "<br>" << std::endl;
5960  htmlFile << "<h3> - C means CAPID Errors assuming we inspect CAPID non-rotation,error & validation bits, and for "
5961  "this criterion - no need to apply any cuts to select bcs.</h3> "
5962  << std::endl;
5963  htmlFile << "<br>" << std::endl;
5964  htmlFile << "<h3> - A means full amplitude, collected over all time slices </h3> " << std::endl;
5965  htmlFile << "<h3> - R means ratio criterion where we define as a bad, the channels, for which the signal portion in "
5966  "4 middle TSs(plus one, minus two around TS with maximal amplitude) is out of some range of reasonable "
5967  "values </h3> "
5968  << std::endl;
5969  htmlFile << "<br>" << std::endl;
5970  htmlFile << "<h3> - W means width of shape distribution. Width is defined as square root from dispersion. </h3> "
5971  << std::endl;
5972  htmlFile << "<br>" << std::endl;
5973  htmlFile << "<h3> - TN means mean time position of adc signal. </h3> " << std::endl;
5974  htmlFile << "<br>" << std::endl;
5975  htmlFile << "<h3> - TX means TS number of maximum signal </h3> " << std::endl;
5976  htmlFile << "<br>" << std::endl;
5977  htmlFile << "<h3> - m means megatile channels. For example Am means Amplitude criteria for megatile channels </h3> "
5978  << std::endl;
5979  htmlFile << "<br>" << std::endl;
5980  htmlFile
5981  << "<h3> - c means calibration channels. For example Ac means Amplitude criteria for calibration channels </h3> "
5982  << std::endl;
5983  htmlFile << "<br>" << std::endl;
5984  htmlFile << "<h3> - Pm means Pedestals. </h3> " << std::endl;
5985  htmlFile << "<br>" << std::endl;
5986  htmlFile << "<h3> - pWm means pedestal Width. </h3> " << std::endl;
5987  htmlFile << "<br>" << std::endl;
5988  htmlFile << "</body> " << std::endl;
5989  htmlFile << "</html> " << std::endl;
5990  htmlFile.close();
5991 
5992  //======================================================================
5993 
5994  std::cout << "********" << std::endl;
5995  std::cout << "************ Start creating MAP html file: - rather long time needed, waiting please" << std::endl;
5996  //======================================================================
5997  // Creating main html file:
5998  htmlFile.open("MAP.html");
5999  htmlFile << "</html><html xmlns=\"http://www.w3.org/1999/xhtml\">" << std::endl;
6000  htmlFile << "<head>" << std::endl;
6001  htmlFile << "<meta http-equiv=\"Content-Type\" content=\"text/html\"/>" << std::endl;
6002  htmlFile << "<title> Remote Monitoring Tool </title>" << std::endl;
6003  htmlFile << "<style type=\"text/css\">" << std::endl;
6004  htmlFile << " body,td{ background-color: #FFFFCC; font-family: arial, arial ce, helvetica; font-size: 12px; }"
6005  << std::endl;
6006  htmlFile << " td.s0 { font-family: arial, arial ce, helvetica; }" << std::endl;
6007  htmlFile << " td.s1 { font-family: arial, arial ce, helvetica; font-weight: bold; background-color: #FFC169; "
6008  "text-align: center;}"
6009  << std::endl;
6010  htmlFile << " td.s2 { font-family: arial, arial ce, helvetica; background-color: #eeeeee; }" << std::endl;
6011  htmlFile << " td.s3 { font-family: arial, arial ce, helvetica; background-color: #d0d0d0; }" << std::endl;
6012  htmlFile << " td.s4 { font-family: arial, arial ce, helvetica; background-color: #FFC169; }" << std::endl;
6013  htmlFile << " td.s5 { font-family: arial, arial ce, helvetica; background-color: #FF00FF; }" << std::endl;
6014  htmlFile << " td.s6 { font-family: arial, arial ce, helvetica; background-color: #9ACD32; }" << std::endl;
6015  htmlFile << " td.s7 { font-family: arial, arial ce, helvetica; background-color: #32CD32; }" << std::endl;
6016  htmlFile << "</style>" << std::endl;
6017  htmlFile << "<body>" << std::endl;
6018 
6019  htmlFile << "<h1> Remote Monitoring Tool, LED RUN = " << runnumber << ". </h1>" << std::endl;
6020  htmlFile << "<br>" << std::endl;
6021 
6022  htmlFile << "<h2> 1. Analysis results for subdetectors </h2>" << std::endl;
6023  htmlFile << "<table width=\"400\">" << std::endl;
6024  htmlFile << "<tr>" << std::endl;
6025 
6026  /*
6027  htmlFile << " <td><a href=\"HB.html\">HB</a></td>"<< std::endl;
6028  htmlFile << " <td><a href=\"HE.html\">HE</a></td>"<< std::endl;
6029  htmlFile << " <td><a href=\"HO.html\">HO</a></td>"<< std::endl;
6030  htmlFile << " <td><a href=\"HF.html\">HF</a></td>"<< std::endl;
6031 */
6032 
6033  htmlFile << " <td><a "
6034  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6035  "HcalRemoteMonitoring/RMT/LED_"
6036  << runnumber << "/HB.html\">HB</a></td>" << std::endl;
6037  htmlFile << " <td><a "
6038  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6039  "HcalRemoteMonitoring/RMT/LED_"
6040  << runnumber << "/HE.html\">HE</a></td>" << std::endl;
6041  htmlFile << " <td><a "
6042  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6043  "HcalRemoteMonitoring/RMT/LED_"
6044  << runnumber << "/HO.html\">HO</a></td>" << std::endl;
6045  htmlFile << " <td><a "
6046  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6047  "HcalRemoteMonitoring/RMT/LED_"
6048  << runnumber << "/HF.html\">HF</a></td>" << std::endl;
6049 
6050  htmlFile << "</tr>" << std::endl;
6051  htmlFile << "</table>" << std::endl;
6052  htmlFile << "<br>" << std::endl;
6053 
6054  htmlFile << "<h2> 2. Amplitude summed over all sub-detector channels vs first 1000 events of this Run </h2>"
6055  << std::endl;
6056  htmlFile << "<h3> 2.A. Total subdetector Amplitude vs iEvent </h3>" << std::endl;
6057  htmlFile << " <img src=\"EVENTDEPENDENCE.png\" />" << std::endl;
6058  htmlFile << "<br>" << std::endl;
6059  htmlFile << "<br>" << std::endl;
6060  htmlFile << "<br>" << std::endl;
6061 
6062  htmlFile << "<h2> 3. HCAL status over all criteria and subdetectors </h2>" << std::endl;
6063  htmlFile << "<h3> 3.A. Channels in detector space </h3>" << std::endl;
6064  htmlFile << "<h4> Legend for channel status: green - good, red - bad, yellow - at least 2% gain drift, white - not "
6065  "applicable or out of range </h4>"
6066  << std::endl;
6067  htmlFile << " <img src=\"MAP.png\" />" << std::endl;
6068  htmlFile << "<br>" << std::endl;
6069  htmlFile << "<br>" << std::endl;
6070 
6071  htmlFile << "<h3> 3.B. List of Bad channels </h3>" << std::endl;
6072 
6073  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
6074  htmlFile << " <td><a "
6075  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6076  "HcalRemoteMonitoring/RMT/LED_"
6077  << runnumber << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
6078  htmlFile << "<table>" << std::endl;
6079  htmlFile << "<tr>";
6080  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
6081  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
6082  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
6083  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
6084  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
6085  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
6086  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
6087  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
6088  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
6089  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
6090  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
6091  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
6092  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
6093  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
6094  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
6095  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
6096  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
6097  htmlFile << "<td class=\"s5\" align=\"center\">RMT-criteria</td>" << std::endl;
6098  htmlFile << "</tr>" << std::endl;
6099 
6100  ind = 0;
6101 
6102  for (int i = 1; i <= NBad; i++) {
6103  if ((ind % 2) == 1) {
6104  raw_class = "<td class=\"s2\" align=\"center\">";
6105  raw_class1 = "<td class=\"s6\" align=\"center\">";
6106  } else {
6107  raw_class = "<td class=\"s3\" align=\"center\">";
6108  raw_class1 = "<td class=\"s7\" align=\"center\">";
6109  }
6110  const CellDB db;
6111  const CellDB ce = db.find("Eta", Eta[2][i]).find("Phi", Phi[2][i]).find("Depth", Depth[2][i]);
6112  if (ce.size() == 0) {
6113  // cout<<"Error: No such Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;
6114  continue;
6115  }
6116  // else if (ce.size()>1) { cout<<"Warning: More than one line correspond to such Eta="<< Eta[2][i] <<", Phi="<< Phi[2][i] <<", Depth="<< Depth[2][i] <<" in database"<<endl;}
6117 
6118  if (ce.size() >= 1) {
6119  htmlFile << "<tr>" << std::endl;
6120  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
6121  htmlFile << raw_class << Eta[2][i] << "</td>" << std::endl;
6122  htmlFile << raw_class << Phi[2][i] << "</td>" << std::endl;
6123  htmlFile << raw_class << Depth[2][i] << "</td>" << std::endl;
6124  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
6125  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
6126  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
6127  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
6128  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
6129  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
6130  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
6131  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
6132  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
6133  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
6134  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
6135  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
6136  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
6137  htmlFile << raw_class1 << Comment[2][i] << "</td>" << std::endl;
6138  htmlFile << "</tr>" << std::endl;
6139 
6140  ind += 1;
6141  }
6142  }
6143  htmlFile << "</table>" << std::endl;
6144  htmlFile << "<br>" << std::endl;
6145 
6146  htmlFile << "<h3> 2.C.List of Gain unstable channels </h3>" << std::endl;
6147  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
6148  htmlFile << " <td><a "
6149  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6150  "HcalRemoteMonitoring/RMT/LED_"
6151  << runnumber << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
6152 
6153  htmlFile << "<table>" << std::endl;
6154  htmlFile << "<tr>";
6155  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
6156  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
6157  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
6158  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
6159  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
6160  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
6161  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
6162  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
6163  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
6164  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
6165  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
6166  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
6167  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
6168  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
6169  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
6170  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
6171  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
6172  htmlFile << "<td class=\"s5\" align=\"center\">Failed criteria</td>" << std::endl;
6173  htmlFile << "</tr>" << std::endl;
6174 
6175  for (int i = 1; i <= NWarn; i++) {
6176  if ((ind % 2) == 1) {
6177  raw_class = "<td class=\"s2\" align=\"center\">";
6178  raw_class1 = "<td class=\"s6\" align=\"center\">";
6179  } else {
6180  raw_class = "<td class=\"s3\" align=\"center\">";
6181  raw_class1 = "<td class=\"s7\" align=\"center\">";
6182  }
6183  const CellDB db;
6184  const CellDB ce = db.find("Eta", Eta[1][i]).find("Phi", Phi[1][i]).find("Depth", Depth[1][i]);
6185  if (ce.size() == 0) {
6186  // cout<<"Error: No such Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;
6187  continue;
6188  }
6189  // else if (ce.size()>1) { cout<<"Warning: More than one line correspond to such Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;}
6190 
6191  if (ce.size() >= 1) {
6192  htmlFile << "<tr>" << std::endl;
6193  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
6194  htmlFile << raw_class << Eta[1][i] << "</td>" << std::endl;
6195  htmlFile << raw_class << Phi[1][i] << "</td>" << std::endl;
6196  htmlFile << raw_class << Depth[1][i] << "</td>" << std::endl;
6197  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
6198  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
6199  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
6200  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
6201  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
6202  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
6203  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
6204  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
6205  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
6206  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
6207  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
6208  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
6209  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
6210  htmlFile << raw_class1 << Comment[1][i] << "</td>" << std::endl;
6211  htmlFile << "</tr>" << std::endl;
6212 
6213  ind += 1;
6214  }
6215  }
6216 
6217  htmlFile << "</table>" << std::endl;
6218  htmlFile << "<br>" << std::endl;
6219 
6220  htmlFile << "<h3> 2.D.List of channels with bad Pedestals </h3>" << std::endl;
6221  // htmlFile << " <td><a href=\"HELP.html\"> Description of criteria for bad channel selection</a></td>"<< std::endl;
6222  htmlFile << " <td><a "
6223  "href=\"https://cms-cpt-software.web.cern.ch/cms-cpt-software/General/Validation/SVSuite/"
6224  "HcalRemoteMonitoring/RMT/LED_"
6225  << runnumber << "/HELP.html\"> Description of criteria for bad channel selection</a></td>" << std::endl;
6226 
6227  htmlFile << "<table>" << std::endl;
6228  htmlFile << "<tr>";
6229  htmlFile << "<td class=\"s4\" align=\"center\">#</td>" << std::endl;
6230  htmlFile << "<td class=\"s1\" align=\"center\">ETA</td>" << std::endl;
6231  htmlFile << "<td class=\"s1\" align=\"center\">PHI</td>" << std::endl;
6232  htmlFile << "<td class=\"s1\" align=\"center\">DEPTH</td>" << std::endl;
6233  htmlFile << "<td class=\"s1\" align=\"center\">RBX</td>" << std::endl;
6234  htmlFile << "<td class=\"s1\" align=\"center\">RM</td>" << std::endl;
6235  htmlFile << "<td class=\"s1\" align=\"center\">PIXEL</td>" << std::endl;
6236  htmlFile << "<td class=\"s1\" align=\"center\">RM_FIBER</td>" << std::endl;
6237  htmlFile << "<td class=\"s1\" align=\"center\">FIBER_CH</td>" << std::endl;
6238  htmlFile << "<td class=\"s1\" align=\"center\">QIE</td>" << std::endl;
6239  htmlFile << "<td class=\"s1\" align=\"center\">ADC</td>" << std::endl;
6240  htmlFile << "<td class=\"s1\" align=\"center\">CRATE</td>" << std::endl;
6241  htmlFile << "<td class=\"s1\" align=\"center\">DCC</td>" << std::endl;
6242  htmlFile << "<td class=\"s1\" align=\"center\">SPIGOT</td>" << std::endl;
6243  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FIBER</td>" << std::endl;
6244  htmlFile << "<td class=\"s1\" align=\"center\">HTR_SLOT</td>" << std::endl;
6245  htmlFile << "<td class=\"s1\" align=\"center\">HTR_FPGA</td>" << std::endl;
6246  htmlFile << "<td class=\"s5\" align=\"center\">Failed criteria</td>" << std::endl;
6247  htmlFile << "</tr>" << std::endl;
6248 
6249  for (int i = 1; i <= NPed; i++) {
6250  if ((ind % 2) == 1) {
6251  raw_class = "<td class=\"s2\" align=\"center\">";
6252  raw_class1 = "<td class=\"s6\" align=\"center\">";
6253  } else {
6254  raw_class = "<td class=\"s3\" align=\"center\">";
6255  raw_class1 = "<td class=\"s7\" align=\"center\">";
6256  }
6257  const CellDB db;
6258  const CellDB ce = db.find("Eta", Eta[3][i]).find("Phi", Phi[3][i]).find("Depth", Depth[3][i]);
6259  if (ce.size() == 0) {
6260  // cout<<"Error: No such Eta="<< Eta[3][i] << ", Phi="<< Phi[3][i] <<", Depth="<< Depth[3][i] <<" in database"<<endl;
6261  continue;
6262  }
6263  // else if (ce.size()>1) { cout<<"Warning: More than one line correspond to such Eta="<< Eta[1][i] <<", Phi="<< Phi[1][i] <<", Depth="<< Depth[1][i] <<" in database"<<endl;}
6264 
6265  if (ce.size() >= 1) {
6266  htmlFile << "<tr>" << std::endl;
6267  htmlFile << "<td class=\"s1\" align=\"center\">" << ind + 1 << "</td>" << std::endl;
6268  htmlFile << raw_class << Eta[3][i] << "</td>" << std::endl;
6269  htmlFile << raw_class << Phi[3][i] << "</td>" << std::endl;
6270  htmlFile << raw_class << Depth[3][i] << "</td>" << std::endl;
6271  htmlFile << raw_class << ce[0].RBX << "</td>" << std::endl;
6272  htmlFile << raw_class << ce[0].RM << "</td>" << std::endl;
6273  htmlFile << raw_class << ce[0].Pixel << "</td>" << std::endl;
6274  htmlFile << raw_class << ce[0].RMfiber << "</td>" << std::endl;
6275  htmlFile << raw_class << ce[0].FiberCh << "</td>" << std::endl;
6276  htmlFile << raw_class << ce[0].QIE << "</td>" << std::endl;
6277  htmlFile << raw_class << ce[0].ADC << "</td>" << std::endl;
6278  htmlFile << raw_class << ce[0].VMECardID << "</td>" << std::endl;
6279  htmlFile << raw_class << ce[0].dccID << "</td>" << std::endl;
6280  htmlFile << raw_class << ce[0].Spigot << "</td>" << std::endl;
6281  htmlFile << raw_class << ce[0].FiberIndex << "</td>" << std::endl;
6282  htmlFile << raw_class << ce[0].HtrSlot << "</td>" << std::endl;
6283  htmlFile << raw_class << ce[0].HtrTB << "</td>" << std::endl;
6284  htmlFile << raw_class1 << Comment[3][i] << "</td>" << std::endl;
6285  htmlFile << "</tr>" << std::endl;
6286 
6287  ind += 1;
6288  }
6289  }
6290 
6291  htmlFile << "</table>" << std::endl;
6292 
6293  htmlFile << "</body> " << std::endl;
6294  htmlFile << "</html> " << std::endl;
6295  htmlFile.close();
6296  //======================================================================
6297 
6298  //======================================================================
6299  // Close and delete all possible things:
6300  hfile->Close();
6301  // hfile->Delete();
6302  // Exit Root
6303  gSystem->Exit(0);
6304  //======================================================================
6305 }
nphi
const int nphi
Definition: CMTRawAnalyzer.cc:422
MAX
#define MAX(a, b)
Returns the max value between a and b.
Definition: IceTypes.h:90
CellDB::find
CellDB find(const std::string par, const T val) const
Definition: LogEleMapdb.h:14752
mps_fire.i
i
Definition: mps_fire.py:428
EcalCondDB.db
tuple db
Definition: EcalCondDB.py:153
MIN
#define MIN(a, b)
Returns the min value between a and b.
Definition: IceTypes.h:89
CellDB::size
int size() const
Definition: LogEleMapdb.h:14748
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
nsub
const int nsub
Definition: CMTRawAnalyzer.cc:419
neta
const int neta
Definition: CMTRawAnalyzer.cc:421
DeadROC_duringRun.dir
string dir
Definition: DeadROC_duringRun.py:23
g4TestOverlap_cfg.Depth
tuple Depth
Definition: g4TestOverlap_cfg.py:19
ctpps_dqm_sourceclient-live_cfg.test
test
Definition: ctpps_dqm_sourceclient-live_cfg.py:7
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
dir2webdir.argc
tuple argc
Definition: dir2webdir.py:39
SiStripCommissioningClient_cfg.runtype
int runtype
Definition: SiStripCommissioningClient_cfg.py:9
alignmentValidation.fname
string fname
main script
Definition: alignmentValidation.py:959
x
float x
Definition: beamSpotDipStandalone.cc:55
gather_cfg.cout
tuple cout
Definition: gather_cfg.py:144
ndepth
const int ndepth
Definition: CMTRawAnalyzer.cc:420
str
#define str(s)
Definition: TestProcessor.cc:54
Generated for CMSSW Reference Manual by doxygen 1.8.5